Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
22358 ashik.ali 104 
  def updateAddress(self, address):
105 
    """
106 
    Parameters:
107 
     - address
108 
    """
109 
    pass
110 
 
22364 ashik.ali 111 
  def updateCounter(self, counter):
112 
    """
113 
    Parameters:
114 
     - counter
115 
    """
116 
    pass
117 
 
94 ashish 118 
  def setUserAsLoggedIn(self, userId, timestamp):
119 
    """
120 
    Parameters:
121 
     - userId
122 
     - timestamp
123 
    """
124 
    pass
125 
 
126 
  def setUserAsLoggedOut(self, userid, timestamp):
127 
    """
128 
    Parameters:
129 
     - userid
130 
     - timestamp
131 
    """
132 
    pass
133 
 
504 rajveer 134 
  def setDefaultAddress(self, userid, addressId):
135 
    """
136 
    Parameters:
137 
     - userid
138 
     - addressId
139 
    """
140 
    pass
141 
 
594 rajveer 142 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 143 
    """
144 
    Parameters:
145 
     - userid
594 rajveer 146 
     - oldPassword
147 
     - newPassword
94 ashish 148 
    """
149 
    pass
150 
 
884 rajveer 151 
  def forgotPassword(self, email, newPassword):
581 rajveer 152 
    """
153 
    Parameters:
154 
     - email
884 rajveer 155 
     - newPassword
581 rajveer 156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getAllAddressesForUser(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
1894 vikas 166 
  def getAddressById(self, addressId):
167 
    """
168 
    Parameters:
169 
     - addressId
170 
    """
171 
    pass
172 
 
594 rajveer 173 
  def getDefaultAddressId(self, userId):
174 
    """
175 
    Parameters:
176 
     - userId
177 
    """
178 
    pass
179 
 
785 rajveer 180 
  def getDefaultPincode(self, userId):
181 
    """
182 
    Parameters:
183 
     - userId
184 
    """
185 
    pass
186 
 
1274 varun.gupt 187 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
188 
    """
189 
    Parameters:
190 
     - userId
191 
     - replyTo
192 
     - communicationType
193 
     - orderId
194 
     - airwaybillNo
195 
     - productName
196 
     - subject
197 
     - message
198 
    """
199 
    pass
200 
 
1590 varun.gupt 201 
  def getUserCommunicationById(self, id):
202 
    """
203 
    Parameters:
204 
     - id
205 
    """
206 
    pass
207 
 
208 
  def getUserCommunicationByUser(self, userId):
209 
    """
210 
    Parameters:
211 
     - userId
212 
    """
213 
    pass
214 
 
215 
  def getAllUserCommunications(self, ):
216 
    pass
217 
 
5407 amar.kumar 218 
  def removeUserCommunication(self, id):
219 
    """
220 
    Parameters:
221 
     - id
222 
    """
223 
    pass
224 
 
1859 vikas 225 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 226 
    """
227 
    Parameters:
228 
     - name
1859 vikas 229 
     - addedOn
1845 vikas 230 
    """
231 
    pass
232 
 
1899 vikas 233 
  def getAllMasterAffiliates(self, ):
234 
    pass
235 
 
1845 vikas 236 
  def getMasterAffiliateById(self, id):
237 
    """
238 
    Parameters:
239 
     - id
240 
    """
241 
    pass
242 
 
243 
  def getMasterAffiliateByName(self, name):
244 
    """
245 
    Parameters:
246 
     - name
247 
    """
248 
    pass
249 
 
1859 vikas 250 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 251 
    """
252 
    Parameters:
253 
     - name
254 
     - url
255 
     - masterAffiliateId
1859 vikas 256 
     - addedOn
1845 vikas 257 
    """
258 
    pass
259 
 
260 
  def getAffiliateById(self, id):
261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
267 
  def getAffiliateByName(self, name):
268 
    """
269 
    Parameters:
270 
     - name
271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def getTrackerById(self, id):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - id
278 
    """
279 
    pass
280 
 
1996 vikas 281 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 282 
    """
283 
    Parameters:
1996 vikas 284 
     - id
1845 vikas 285 
    """
286 
    pass
287 
 
1996 vikas 288 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 289 
    """
290 
    Parameters:
291 
     - affiliateId
292 
     - userId
293 
     - event
294 
     - url
295 
     - data
1859 vikas 296 
     - addedOn
1845 vikas 297 
    """
298 
    pass
299 
 
300 
  def getTrackLogById(self, id):
301 
    """
302 
    Parameters:
303 
     - id
304 
    """
305 
    pass
306 
 
3293 vikas 307 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 308 
    """
309 
    Parameters:
1996 vikas 310 
     - affiliateId
3293 vikas 311 
     - startDate
312 
     - endDate
1845 vikas 313 
    """
314 
    pass
315 
 
316 
  def getTrackLogsByUser(self, userId):
317 
    """
318 
    Parameters:
319 
     - userId
320 
    """
321 
    pass
322 
 
1996 vikas 323 
  def getTrackLogs(self, userId, event, url):
1845 vikas 324 
    """
325 
    Parameters:
326 
     - userId
327 
     - event
328 
     - url
329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCurrentCart(self, userId):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - userId
94 ashish 336 
    """
337 
    pass
338 
 
559 chandransh 339 
  def getCart(self, cartId):
94 ashish 340 
    """
341 
    Parameters:
559 chandransh 342 
     - cartId
94 ashish 343 
    """
344 
    pass
345 
 
559 chandransh 346 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 347 
    """
348 
    Parameters:
559 chandransh 349 
     - from_time
350 
     - to_time
351 
     - status
94 ashish 352 
    """
353 
    pass
354 
 
3557 rajveer 355 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 356 
    """
357 
    Parameters:
559 chandransh 358 
     - cartId
359 
     - itemId
360 
     - quantity
3557 rajveer 361 
     - sourceId
130 ashish 362 
    """
363 
    pass
364 
 
559 chandransh 365 
  def deleteItemFromCart(self, cartId, itemId):
366 
    """
367 
    Parameters:
368 
     - cartId
369 
     - itemId
370 
    """
371 
    pass
130 ashish 372 
 
559 chandransh 373 
  def addAddressToCart(self, cartId, addressId):
374 
    """
375 
    Parameters:
376 
     - cartId
377 
     - addressId
378 
    """
379 
    pass
380 
 
5553 rajveer 381 
  def addStoreToCart(self, cartId, storeId):
382 
    """
383 
    Parameters:
384 
     - cartId
385 
     - storeId
386 
    """
387 
    pass
388 
 
6922 anupam.sin 389 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 390 
    """
391 
    Parameters:
6922 anupam.sin 392 
     - cart
1976 varun.gupt 393 
     - couponCode
394 
    """
395 
    pass
396 
 
397 
  def removeCoupon(self, cartId):
398 
    """
399 
    Parameters:
400 
     - cartId
401 
    """
402 
    pass
403 
 
3554 varun.gupt 404 
  def deleteDiscountsFromCart(self, cartId):
405 
    """
406 
    Deletes all the discounts associated with the cart
407 
 
408 
    Parameters:
409 
     - cartId
410 
    """
411 
    pass
412 
 
413 
  def saveDiscounts(self, discounts):
414 
    """
415 
    Accepts a list of thrift objects of Discount type and saves them
416 
 
417 
    Parameters:
418 
     - discounts
419 
    """
420 
    pass
421 
 
21454 amit.gupta 422 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 423 
    """
690 chandransh 424 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 425 
 
559 chandransh 426 
    Parameters:
427 
     - cartId
2815 vikas 428 
     - sessionSource
429 
     - sessionStartTime
3858 vikas 430 
     - firstSource
431 
     - firstSourceTime
5326 rajveer 432 
     - userId
6389 rajveer 433 
     - schemeId
11526 amit.gupta 434 
     - orderSource
21454 amit.gupta 435 
     - selfPickup
559 chandransh 436 
    """
437 
    pass
438 
 
3557 rajveer 439 
  def validateCart(self, cartId, sourceId):
559 chandransh 440 
    """
690 chandransh 441 
    Validates that:
442 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 443 
    2. All of the lines in the cart are active items.
690 chandransh 444 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 445 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 446 
 
559 chandransh 447 
    Parameters:
448 
     - cartId
3557 rajveer 449 
     - sourceId
559 chandransh 450 
    """
451 
    pass
452 
 
11980 amit.gupta 453 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
454 
    """
455 
    Validates that:
456 
    1. The checkout timestamp is greater than the updatedOn timestamp.
457 
    2. All of the lines in the cart are active items.
458 
    3. The estimate for any of the lines in cart doesn't change.
459 
    If all three are true, returns empty string; else returns appropriate message.
460 
 
461 
    Parameters:
462 
     - cartId
463 
     - sourceId
464 
     - dealCoupon
465 
    """
466 
    pass
467 
 
690 chandransh 468 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 469 
    """
690 chandransh 470 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 471 
 
575 chandransh 472 
    Parameters:
690 chandransh 473 
     - fromCartId
474 
     - toCartId
475 
    """
476 
    pass
477 
 
478 
  def checkOut(self, cartId):
479 
    """
480 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 481 
 
690 chandransh 482 
    Parameters:
575 chandransh 483 
     - cartId
484 
    """
485 
    pass
486 
 
690 chandransh 487 
  def resetCart(self, cartId, items):
559 chandransh 488 
    """
690 chandransh 489 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
490 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 491 
 
559 chandransh 492 
    Parameters:
690 chandransh 493 
     - cartId
494 
     - items
559 chandransh 495 
    """
496 
    pass
497 
 
2981 rajveer 498 
  def getUserCount(self, userType):
559 chandransh 499 
    """
2981 rajveer 500 
    Returns number of registered users.
501 
    If userType = null, then it returns count of all users, including anonymous
502 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
503 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 504 
 
559 chandransh 505 
    Parameters:
2981 rajveer 506 
     - userType
559 chandransh 507 
    """
508 
    pass
509 
 
2981 rajveer 510 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 511 
    """
2981 rajveer 512 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
513 
    If any of startDate or endDate is -1, then that filter is ignored.
514 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 515 
 
516 
 
559 chandransh 517 
    Parameters:
2981 rajveer 518 
     - userType
519 
     - startDate
520 
     - endDate
559 chandransh 521 
    """
522 
    pass
523 
 
2981 rajveer 524 
  def getMyResearchItems(self, userId):
559 chandransh 525 
    """
2981 rajveer 526 
    Returns list of item ids in myresearch for the user
3431 rajveer 527 
 
559 chandransh 528 
    Parameters:
529 
     - userId
530 
    """
531 
    pass
532 
 
2981 rajveer 533 
  def updateMyResearch(self, userId, itemId):
559 chandransh 534 
    """
2981 rajveer 535 
    add item to my research for a user
3431 rajveer 536 
 
559 chandransh 537 
    Parameters:
2981 rajveer 538 
     - userId
539 
     - itemId
559 chandransh 540 
    """
541 
    pass
542 
 
2981 rajveer 543 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 544 
    """
2981 rajveer 545 
    delete item from my research for a user
3431 rajveer 546 
 
1596 ankur.sing 547 
    Parameters:
2981 rajveer 548 
     - userId
549 
     - itemId
1596 ankur.sing 550 
    """
551 
    pass
559 chandransh 552 
 
2981 rajveer 553 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 554 
    """
2981 rajveer 555 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 556 
 
1673 ankur.sing 557 
    Parameters:
2981 rajveer 558 
     - userId
1673 ankur.sing 559 
    """
560 
    pass
1596 ankur.sing 561 
 
2981 rajveer 562 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 563 
    """
2981 rajveer 564 
    add item to browse history for a user
3431 rajveer 565 
 
2642 varun.gupt 566 
    Parameters:
2981 rajveer 567 
     - userId
568 
     - itemId
2642 varun.gupt 569 
    """
570 
    pass
1673 ankur.sing 571 
 
3385 varun.gupt 572 
  def getCartsWithCouponCount(self, couponCode):
573 
    """
574 
    Returns count of Carts with given coupon applied
3431 rajveer 575 
 
3385 varun.gupt 576 
    Parameters:
577 
     - couponCode
578 
    """
579 
    pass
2642 varun.gupt 580 
 
3499 mandeep.dh 581 
  def increaseTrustLevel(self, userId, trustLevelDelta):
582 
    """
583 
    Updates COD trust level of a user
3385 varun.gupt 584 
 
3499 mandeep.dh 585 
    Parameters:
586 
     - userId
587 
     - trustLevelDelta
588 
    """
589 
    pass
590 
 
5407 amar.kumar 591 
  def getTrustLevel(self, userId):
592 
    """
593 
    Get trust level of a user
594 
 
595 
    Parameters:
596 
     - userId
597 
    """
598 
    pass
599 
 
4668 varun.gupt 600 
  def showCODOption(self, cartId, sourceId, pincode):
601 
    """
602 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 603 
 
4668 varun.gupt 604 
    Parameters:
605 
     - cartId
606 
     - sourceId
607 
     - pincode
608 
    """
609 
    pass
610 
 
5623 anupam.sin 611 
  def getUserEmails(self, startDate, endDate):
612 
    """
613 
    Get email addresses for users activated within a given date range
4668 varun.gupt 614 
 
5623 anupam.sin 615 
    Parameters:
616 
     - startDate
617 
     - endDate
618 
    """
619 
    pass
620 
 
9299 kshitij.so 621 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 622 
    """
623 
    Mark a cart lineitem as insured. Returns true/false.
624 
 
625 
    Parameters:
626 
     - itemId
627 
     - cartId
628 
     - toInsure
9299 kshitij.so 629 
     - insurerType
6903 anupam.sin 630 
    """
631 
    pass
632 
 
633 
  def cancelInsurance(self, cartId):
634 
    """
635 
    Cancel insurance for all items in the cart
636 
 
637 
    Parameters:
638 
     - cartId
639 
    """
640 
    pass
641 
 
642 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
643 
    """
644 
    Stores insurance specific details like date of birth and guardianName
645 
 
646 
    Parameters:
647 
     - addressId
648 
     - dob
649 
     - guardianName
650 
    """
651 
    pass
652 
 
653 
  def isInsuranceDetailPresent(self, addressId):
654 
    """
655 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
656 
 
657 
    Parameters:
658 
     - addressId
659 
    """
660 
    pass
661 
 
9791 rajveer 662 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 663 
    """
9791 rajveer 664 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 665 
 
6821 amar.kumar 666 
    Parameters:
667 
     - startDate
668 
     - endDate
669 
    """
670 
    pass
671 
 
11980 amit.gupta 672 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 673 
    """
674 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 675 
 
11592 amit.gupta 676 
    Parameters:
677 
     - cartId
678 
     - sourceId
11980 amit.gupta 679 
     - dealerCoupon
11592 amit.gupta 680 
    """
681 
    pass
682 
 
11679 vikram.rag 683 
  def isPrivateDealUser(self, userId):
684 
    """
685 
    Parameters:
686 
     - userId
687 
    """
688 
    pass
11592 amit.gupta 689 
 
11890 kshitij.so 690 
  def addPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
11679 vikram.rag 696 
 
11890 kshitij.so 697 
  def changePrivateDealUserStatus(self, userId, isActive):
698 
    """
699 
    Parameters:
700 
     - userId
701 
     - isActive
702 
    """
703 
    pass
704 
 
705 
  def getPrivateDealUser(self, userId):
706 
    """
707 
    Parameters:
708 
     - userId
709 
    """
710 
    pass
711 
 
12696 amit.gupta 712 
  def registerCounter(self, counter, userId):
713 
    """
714 
    Parameters:
715 
     - counter
716 
     - userId
717 
    """
718 
    pass
11890 kshitij.so 719 
 
12722 amit.gupta 720 
  def searchCounter(self, type1, searchString):
721 
    """
722 
    Parameters:
723 
     - type1
724 
     - searchString
725 
    """
726 
    pass
12696 amit.gupta 727 
 
18977 amit.gupta 728 
  def getCounterByUserId(self, userId):
729 
    """
730 
    Parameters:
731 
     - userId
732 
    """
733 
    pass
734 
 
12722 amit.gupta 735 
  def getAllUsersByCounter(self, counterId):
736 
    """
737 
    Parameters:
738 
     - counterId
739 
    """
740 
    pass
741 
 
15251 manish.sha 742 
  def getActiveAccessTokenForUser(self, userId, source):
743 
    """
744 
    Parameters:
745 
     - userId
746 
     - source
747 
    """
748 
    pass
12722 amit.gupta 749 
 
15251 manish.sha 750 
  def validateAccessToken(self, accessToken):
751 
    """
752 
    Parameters:
753 
     - accessToken
754 
    """
755 
    pass
756 
 
17782 amit.gupta 757 
  def addItemsToCart(self, cartId, itemQty, couponCode):
758 
    """
759 
    Parameters:
760 
     - cartId
761 
     - itemQty
762 
     - couponCode
763 
    """
764 
    pass
15251 manish.sha 765 
 
17782 amit.gupta 766 
  def validateCartNew(self, cartId, pinCode, sourceId):
767 
    """
768 
    Parameters:
769 
     - cartId
770 
     - pinCode
771 
     - sourceId
772 
    """
773 
    pass
774 
 
18644 manish.sha 775 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 776 
    """
777 
    Parameters:
778 
     - userId
779 
    """
780 
    pass
17782 amit.gupta 781 
 
18530 manish.sha 782 
  def getBillingAddressForUser(self, userId):
783 
    """
784 
    Parameters:
785 
     - userId
786 
    """
787 
    pass
788 
 
18590 manish.sha 789 
  def isCreditorAssigned(self, userId):
790 
    """
791 
    Parameters:
792 
     - userId
793 
    """
794 
    pass
18530 manish.sha 795 
 
18735 manish.sha 796 
  def isTaxInvoiceEnabledUser(self, userId):
797 
    """
798 
    Parameters:
799 
     - userId
800 
    """
801 
    pass
18590 manish.sha 802 
 
19182 amit.gupta 803 
  def taxInvoiceAvailable(self, addressId):
804 
    """
805 
    Parameters:
806 
     - addressId
807 
    """
808 
    pass
809 
 
18764 kshitij.so 810 
  def getCartByValue(self, cartIds):
811 
    """
812 
    Parameters:
813 
     - cartIds
814 
    """
815 
    pass
18735 manish.sha 816 
 
19889 manas 817 
  def getCounterName(self, userIds):
818 
    """
819 
    Parameters:
820 
     - userIds
821 
    """
822 
    pass
18764 kshitij.so 823 
 
20873 kshitij.so 824 
  def setWalletAmountInCart(self, cartId, wallet_amount):
825 
    """
826 
    Parameters:
827 
     - cartId
828 
     - wallet_amount
829 
    """
830 
    pass
19889 manas 831 
 
20873 kshitij.so 832 
 
3376 rajveer 833 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 834 
  """
835 
  service
836 
  """
837 
  def __init__(self, iprot, oprot=None):
3376 rajveer 838 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 839 
 
559 chandransh 840 
  def createAnonymousUser(self, jsessionId):
94 ashish 841 
    """
842 
    Parameters:
559 chandransh 843 
     - jsessionId
94 ashish 844 
    """
559 chandransh 845 
    self.send_createAnonymousUser(jsessionId)
846 
    return self.recv_createAnonymousUser()
94 ashish 847 
 
559 chandransh 848 
  def send_createAnonymousUser(self, jsessionId):
849 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
850 
    args = createAnonymousUser_args()
851 
    args.jsessionId = jsessionId
94 ashish 852 
    args.write(self._oprot)
853 
    self._oprot.writeMessageEnd()
854 
    self._oprot.trans.flush()
855 
 
559 chandransh 856 
  def recv_createAnonymousUser(self, ):
94 ashish 857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
858 
    if mtype == TMessageType.EXCEPTION:
859 
      x = TApplicationException()
860 
      x.read(self._iprot)
861 
      self._iprot.readMessageEnd()
862 
      raise x
559 chandransh 863 
    result = createAnonymousUser_result()
94 ashish 864 
    result.read(self._iprot)
865 
    self._iprot.readMessageEnd()
3431 rajveer 866 
    if result.success is not None:
94 ashish 867 
      return result.success
3431 rajveer 868 
    if result.ucex is not None:
559 chandransh 869 
      raise result.ucex
870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 871 
 
559 chandransh 872 
  def getUserById(self, userId):
94 ashish 873 
    """
874 
    Parameters:
875 
     - userId
876 
    """
559 chandransh 877 
    self.send_getUserById(userId)
878 
    return self.recv_getUserById()
94 ashish 879 
 
559 chandransh 880 
  def send_getUserById(self, userId):
881 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
882 
    args = getUserById_args()
94 ashish 883 
    args.userId = userId
884 
    args.write(self._oprot)
885 
    self._oprot.writeMessageEnd()
886 
    self._oprot.trans.flush()
887 
 
559 chandransh 888 
  def recv_getUserById(self, ):
94 ashish 889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
890 
    if mtype == TMessageType.EXCEPTION:
891 
      x = TApplicationException()
892 
      x.read(self._iprot)
893 
      self._iprot.readMessageEnd()
894 
      raise x
559 chandransh 895 
    result = getUserById_result()
94 ashish 896 
    result.read(self._iprot)
897 
    self._iprot.readMessageEnd()
3431 rajveer 898 
    if result.success is not None:
94 ashish 899 
      return result.success
3431 rajveer 900 
    if result.ucex is not None:
559 chandransh 901 
      raise result.ucex
902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 903 
 
5326 rajveer 904 
  def getUserByCartId(self, cartId):
905 
    """
906 
    Parameters:
907 
     - cartId
908 
    """
909 
    self.send_getUserByCartId(cartId)
910 
    return self.recv_getUserByCartId()
911 
 
912 
  def send_getUserByCartId(self, cartId):
913 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
914 
    args = getUserByCartId_args()
915 
    args.cartId = cartId
916 
    args.write(self._oprot)
917 
    self._oprot.writeMessageEnd()
918 
    self._oprot.trans.flush()
919 
 
920 
  def recv_getUserByCartId(self, ):
921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
922 
    if mtype == TMessageType.EXCEPTION:
923 
      x = TApplicationException()
924 
      x.read(self._iprot)
925 
      self._iprot.readMessageEnd()
926 
      raise x
927 
    result = getUserByCartId_result()
928 
    result.read(self._iprot)
929 
    self._iprot.readMessageEnd()
930 
    if result.success is not None:
931 
      return result.success
932 
    if result.ucex is not None:
933 
      raise result.ucex
934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
935 
 
1491 vikas 936 
  def getUserByEmail(self, email):
937 
    """
938 
    Parameters:
939 
     - email
940 
    """
941 
    self.send_getUserByEmail(email)
942 
    return self.recv_getUserByEmail()
943 
 
944 
  def send_getUserByEmail(self, email):
945 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
946 
    args = getUserByEmail_args()
947 
    args.email = email
948 
    args.write(self._oprot)
949 
    self._oprot.writeMessageEnd()
950 
    self._oprot.trans.flush()
951 
 
952 
  def recv_getUserByEmail(self, ):
953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
954 
    if mtype == TMessageType.EXCEPTION:
955 
      x = TApplicationException()
956 
      x.read(self._iprot)
957 
      self._iprot.readMessageEnd()
958 
      raise x
959 
    result = getUserByEmail_result()
960 
    result.read(self._iprot)
961 
    self._iprot.readMessageEnd()
3431 rajveer 962 
    if result.success is not None:
1491 vikas 963 
      return result.success
3431 rajveer 964 
    if result.ucex is not None:
1491 vikas 965 
      raise result.ucex
966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
967 
 
3032 mandeep.dh 968 
  def getUserByMobileNumber(self, mobileNumber):
969 
    """
970 
    Parameters:
971 
     - mobileNumber
972 
    """
973 
    self.send_getUserByMobileNumber(mobileNumber)
974 
    return self.recv_getUserByMobileNumber()
975 
 
976 
  def send_getUserByMobileNumber(self, mobileNumber):
977 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
978 
    args = getUserByMobileNumber_args()
979 
    args.mobileNumber = mobileNumber
980 
    args.write(self._oprot)
981 
    self._oprot.writeMessageEnd()
982 
    self._oprot.trans.flush()
983 
 
984 
  def recv_getUserByMobileNumber(self, ):
985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
986 
    if mtype == TMessageType.EXCEPTION:
987 
      x = TApplicationException()
988 
      x.read(self._iprot)
989 
      self._iprot.readMessageEnd()
990 
      raise x
991 
    result = getUserByMobileNumber_result()
992 
    result.read(self._iprot)
993 
    self._iprot.readMessageEnd()
3431 rajveer 994 
    if result.success is not None:
3032 mandeep.dh 995 
      return result.success
3431 rajveer 996 
    if result.ucex is not None:
3032 mandeep.dh 997 
      raise result.ucex
998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
999 
 
559 chandransh 1000 
  def createUser(self, user):
94 ashish 1001 
    """
1002 
    Parameters:
559 chandransh 1003 
     - user
94 ashish 1004 
    """
559 chandransh 1005 
    self.send_createUser(user)
1006 
    return self.recv_createUser()
94 ashish 1007 
 
559 chandransh 1008 
  def send_createUser(self, user):
1009 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
1010 
    args = createUser_args()
1011 
    args.user = user
94 ashish 1012 
    args.write(self._oprot)
1013 
    self._oprot.writeMessageEnd()
1014 
    self._oprot.trans.flush()
1015 
 
559 chandransh 1016 
  def recv_createUser(self, ):
94 ashish 1017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1018 
    if mtype == TMessageType.EXCEPTION:
1019 
      x = TApplicationException()
1020 
      x.read(self._iprot)
1021 
      self._iprot.readMessageEnd()
1022 
      raise x
559 chandransh 1023 
    result = createUser_result()
94 ashish 1024 
    result.read(self._iprot)
1025 
    self._iprot.readMessageEnd()
3431 rajveer 1026 
    if result.success is not None:
94 ashish 1027 
      return result.success
3431 rajveer 1028 
    if result.ucex is not None:
559 chandransh 1029 
      raise result.ucex
1030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1031 
 
559 chandransh 1032 
  def updateUser(self, user):
94 ashish 1033 
    """
1034 
    Parameters:
559 chandransh 1035 
     - user
94 ashish 1036 
    """
559 chandransh 1037 
    self.send_updateUser(user)
1038 
    return self.recv_updateUser()
94 ashish 1039 
 
559 chandransh 1040 
  def send_updateUser(self, user):
1041 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1042 
    args = updateUser_args()
1043 
    args.user = user
94 ashish 1044 
    args.write(self._oprot)
1045 
    self._oprot.writeMessageEnd()
1046 
    self._oprot.trans.flush()
1047 
 
559 chandransh 1048 
  def recv_updateUser(self, ):
94 ashish 1049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1050 
    if mtype == TMessageType.EXCEPTION:
1051 
      x = TApplicationException()
1052 
      x.read(self._iprot)
1053 
      self._iprot.readMessageEnd()
1054 
      raise x
559 chandransh 1055 
    result = updateUser_result()
94 ashish 1056 
    result.read(self._iprot)
1057 
    self._iprot.readMessageEnd()
3431 rajveer 1058 
    if result.success is not None:
94 ashish 1059 
      return result.success
3431 rajveer 1060 
    if result.ucex is not None:
559 chandransh 1061 
      raise result.ucex
1062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1063 
 
559 chandransh 1064 
  def authenticateUser(self, email, password):
94 ashish 1065 
    """
1066 
    Parameters:
1067 
     - email
1068 
     - password
1069 
    """
559 chandransh 1070 
    self.send_authenticateUser(email, password)
122 ashish 1071 
    return self.recv_authenticateUser()
1072 
 
559 chandransh 1073 
  def send_authenticateUser(self, email, password):
122 ashish 1074 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1075 
    args = authenticateUser_args()
559 chandransh 1076 
    args.email = email
122 ashish 1077 
    args.password = password
1078 
    args.write(self._oprot)
1079 
    self._oprot.writeMessageEnd()
1080 
    self._oprot.trans.flush()
1081 
 
1082 
  def recv_authenticateUser(self, ):
1083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1084 
    if mtype == TMessageType.EXCEPTION:
1085 
      x = TApplicationException()
1086 
      x.read(self._iprot)
1087 
      self._iprot.readMessageEnd()
1088 
      raise x
1089 
    result = authenticateUser_result()
1090 
    result.read(self._iprot)
1091 
    self._iprot.readMessageEnd()
3431 rajveer 1092 
    if result.success is not None:
122 ashish 1093 
      return result.success
3431 rajveer 1094 
    if result.auex is not None:
559 chandransh 1095 
      raise result.auex
122 ashish 1096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1097 
 
94 ashish 1098 
  def userExists(self, email):
1099 
    """
1100 
    Parameters:
1101 
     - email
1102 
    """
1103 
    self.send_userExists(email)
1104 
    return self.recv_userExists()
1105 
 
1106 
  def send_userExists(self, email):
1107 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1108 
    args = userExists_args()
1109 
    args.email = email
1110 
    args.write(self._oprot)
1111 
    self._oprot.writeMessageEnd()
1112 
    self._oprot.trans.flush()
1113 
 
1114 
  def recv_userExists(self, ):
1115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1116 
    if mtype == TMessageType.EXCEPTION:
1117 
      x = TApplicationException()
1118 
      x.read(self._iprot)
1119 
      self._iprot.readMessageEnd()
1120 
      raise x
1121 
    result = userExists_result()
1122 
    result.read(self._iprot)
1123 
    self._iprot.readMessageEnd()
3431 rajveer 1124 
    if result.success is not None:
94 ashish 1125 
      return result.success
3431 rajveer 1126 
    if result.ucx is not None:
94 ashish 1127 
      raise result.ucx
1128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1129 
 
567 rajveer 1130 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1131 
    """
1132 
    Parameters:
1133 
     - userId
1134 
     - address
513 rajveer 1135 
     - setDefault
94 ashish 1136 
    """
567 rajveer 1137 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1138 
    return self.recv_addAddressForUser()
1139 
 
567 rajveer 1140 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1141 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1142 
    args = addAddressForUser_args()
559 chandransh 1143 
    args.userId = userId
94 ashish 1144 
    args.address = address
513 rajveer 1145 
    args.setDefault = setDefault
94 ashish 1146 
    args.write(self._oprot)
1147 
    self._oprot.writeMessageEnd()
1148 
    self._oprot.trans.flush()
1149 
 
1150 
  def recv_addAddressForUser(self, ):
1151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1152 
    if mtype == TMessageType.EXCEPTION:
1153 
      x = TApplicationException()
1154 
      x.read(self._iprot)
1155 
      self._iprot.readMessageEnd()
1156 
      raise x
1157 
    result = addAddressForUser_result()
1158 
    result.read(self._iprot)
1159 
    self._iprot.readMessageEnd()
3431 rajveer 1160 
    if result.success is not None:
94 ashish 1161 
      return result.success
3431 rajveer 1162 
    if result.ucx is not None:
94 ashish 1163 
      raise result.ucx
1164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1165 
 
1166 
  def removeAddressForUser(self, userid, addressId):
1167 
    """
1168 
    Parameters:
1169 
     - userid
1170 
     - addressId
1171 
    """
1172 
    self.send_removeAddressForUser(userid, addressId)
1173 
    return self.recv_removeAddressForUser()
1174 
 
1175 
  def send_removeAddressForUser(self, userid, addressId):
1176 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1177 
    args = removeAddressForUser_args()
1178 
    args.userid = userid
1179 
    args.addressId = addressId
1180 
    args.write(self._oprot)
1181 
    self._oprot.writeMessageEnd()
1182 
    self._oprot.trans.flush()
1183 
 
1184 
  def recv_removeAddressForUser(self, ):
1185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1186 
    if mtype == TMessageType.EXCEPTION:
1187 
      x = TApplicationException()
1188 
      x.read(self._iprot)
1189 
      self._iprot.readMessageEnd()
1190 
      raise x
1191 
    result = removeAddressForUser_result()
1192 
    result.read(self._iprot)
1193 
    self._iprot.readMessageEnd()
3431 rajveer 1194 
    if result.success is not None:
94 ashish 1195 
      return result.success
3431 rajveer 1196 
    if result.ucx is not None:
94 ashish 1197 
      raise result.ucx
1198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1199 
 
22358 ashik.ali 1200 
  def updateAddress(self, address):
1201 
    """
1202 
    Parameters:
1203 
     - address
1204 
    """
1205 
    self.send_updateAddress(address)
1206 
    return self.recv_updateAddress()
1207 
 
1208 
  def send_updateAddress(self, address):
1209 
    self._oprot.writeMessageBegin('updateAddress', TMessageType.CALL, self._seqid)
1210 
    args = updateAddress_args()
1211 
    args.address = address
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_updateAddress(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = updateAddress_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
1226 
    if result.success is not None:
1227 
      return result.success
1228 
    if result.ucx is not None:
1229 
      raise result.ucx
1230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAddress failed: unknown result");
1231 
 
22364 ashik.ali 1232 
  def updateCounter(self, counter):
1233 
    """
1234 
    Parameters:
1235 
     - counter
1236 
    """
1237 
    self.send_updateCounter(counter)
1238 
    return self.recv_updateCounter()
1239 
 
1240 
  def send_updateCounter(self, counter):
1241 
    self._oprot.writeMessageBegin('updateCounter', TMessageType.CALL, self._seqid)
1242 
    args = updateCounter_args()
1243 
    args.counter = counter
1244 
    args.write(self._oprot)
1245 
    self._oprot.writeMessageEnd()
1246 
    self._oprot.trans.flush()
1247 
 
1248 
  def recv_updateCounter(self, ):
1249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1250 
    if mtype == TMessageType.EXCEPTION:
1251 
      x = TApplicationException()
1252 
      x.read(self._iprot)
1253 
      self._iprot.readMessageEnd()
1254 
      raise x
1255 
    result = updateCounter_result()
1256 
    result.read(self._iprot)
1257 
    self._iprot.readMessageEnd()
1258 
    if result.success is not None:
1259 
      return result.success
1260 
    if result.ucx is not None:
1261 
      raise result.ucx
1262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateCounter failed: unknown result");
1263 
 
94 ashish 1264 
  def setUserAsLoggedIn(self, userId, timestamp):
1265 
    """
1266 
    Parameters:
1267 
     - userId
1268 
     - timestamp
1269 
    """
1270 
    self.send_setUserAsLoggedIn(userId, timestamp)
1271 
    return self.recv_setUserAsLoggedIn()
1272 
 
1273 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1274 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1275 
    args = setUserAsLoggedIn_args()
1276 
    args.userId = userId
1277 
    args.timestamp = timestamp
1278 
    args.write(self._oprot)
1279 
    self._oprot.writeMessageEnd()
1280 
    self._oprot.trans.flush()
1281 
 
1282 
  def recv_setUserAsLoggedIn(self, ):
1283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1284 
    if mtype == TMessageType.EXCEPTION:
1285 
      x = TApplicationException()
1286 
      x.read(self._iprot)
1287 
      self._iprot.readMessageEnd()
1288 
      raise x
1289 
    result = setUserAsLoggedIn_result()
1290 
    result.read(self._iprot)
1291 
    self._iprot.readMessageEnd()
3431 rajveer 1292 
    if result.success is not None:
94 ashish 1293 
      return result.success
3431 rajveer 1294 
    if result.ucx is not None:
94 ashish 1295 
      raise result.ucx
1296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1297 
 
1298 
  def setUserAsLoggedOut(self, userid, timestamp):
1299 
    """
1300 
    Parameters:
1301 
     - userid
1302 
     - timestamp
1303 
    """
1304 
    self.send_setUserAsLoggedOut(userid, timestamp)
1305 
    return self.recv_setUserAsLoggedOut()
1306 
 
1307 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1308 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1309 
    args = setUserAsLoggedOut_args()
1310 
    args.userid = userid
1311 
    args.timestamp = timestamp
1312 
    args.write(self._oprot)
1313 
    self._oprot.writeMessageEnd()
1314 
    self._oprot.trans.flush()
1315 
 
1316 
  def recv_setUserAsLoggedOut(self, ):
1317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1318 
    if mtype == TMessageType.EXCEPTION:
1319 
      x = TApplicationException()
1320 
      x.read(self._iprot)
1321 
      self._iprot.readMessageEnd()
1322 
      raise x
1323 
    result = setUserAsLoggedOut_result()
1324 
    result.read(self._iprot)
1325 
    self._iprot.readMessageEnd()
3431 rajveer 1326 
    if result.success is not None:
94 ashish 1327 
      return result.success
3431 rajveer 1328 
    if result.ucx is not None:
94 ashish 1329 
      raise result.ucx
1330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1331 
 
504 rajveer 1332 
  def setDefaultAddress(self, userid, addressId):
1333 
    """
1334 
    Parameters:
1335 
     - userid
1336 
     - addressId
1337 
    """
1338 
    self.send_setDefaultAddress(userid, addressId)
1339 
    return self.recv_setDefaultAddress()
1340 
 
1341 
  def send_setDefaultAddress(self, userid, addressId):
1342 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1343 
    args = setDefaultAddress_args()
1344 
    args.userid = userid
1345 
    args.addressId = addressId
1346 
    args.write(self._oprot)
1347 
    self._oprot.writeMessageEnd()
1348 
    self._oprot.trans.flush()
1349 
 
1350 
  def recv_setDefaultAddress(self, ):
1351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1352 
    if mtype == TMessageType.EXCEPTION:
1353 
      x = TApplicationException()
1354 
      x.read(self._iprot)
1355 
      self._iprot.readMessageEnd()
1356 
      raise x
1357 
    result = setDefaultAddress_result()
1358 
    result.read(self._iprot)
1359 
    self._iprot.readMessageEnd()
3431 rajveer 1360 
    if result.success is not None:
504 rajveer 1361 
      return result.success
3431 rajveer 1362 
    if result.ucx is not None:
504 rajveer 1363 
      raise result.ucx
1364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1365 
 
594 rajveer 1366 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1367 
    """
1368 
    Parameters:
1369 
     - userid
594 rajveer 1370 
     - oldPassword
1371 
     - newPassword
94 ashish 1372 
    """
594 rajveer 1373 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1374 
    return self.recv_updatePassword()
1375 
 
594 rajveer 1376 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1377 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1378 
    args = updatePassword_args()
1379 
    args.userid = userid
594 rajveer 1380 
    args.oldPassword = oldPassword
1381 
    args.newPassword = newPassword
94 ashish 1382 
    args.write(self._oprot)
1383 
    self._oprot.writeMessageEnd()
1384 
    self._oprot.trans.flush()
1385 
 
1386 
  def recv_updatePassword(self, ):
1387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1388 
    if mtype == TMessageType.EXCEPTION:
1389 
      x = TApplicationException()
1390 
      x.read(self._iprot)
1391 
      self._iprot.readMessageEnd()
1392 
      raise x
1393 
    result = updatePassword_result()
1394 
    result.read(self._iprot)
1395 
    self._iprot.readMessageEnd()
3431 rajveer 1396 
    if result.success is not None:
94 ashish 1397 
      return result.success
3431 rajveer 1398 
    if result.ucx is not None:
94 ashish 1399 
      raise result.ucx
1400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1401 
 
884 rajveer 1402 
  def forgotPassword(self, email, newPassword):
581 rajveer 1403 
    """
1404 
    Parameters:
1405 
     - email
884 rajveer 1406 
     - newPassword
581 rajveer 1407 
    """
884 rajveer 1408 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1409 
    return self.recv_forgotPassword()
1410 
 
884 rajveer 1411 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1412 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1413 
    args = forgotPassword_args()
1414 
    args.email = email
884 rajveer 1415 
    args.newPassword = newPassword
581 rajveer 1416 
    args.write(self._oprot)
1417 
    self._oprot.writeMessageEnd()
1418 
    self._oprot.trans.flush()
1419 
 
1420 
  def recv_forgotPassword(self, ):
1421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1422 
    if mtype == TMessageType.EXCEPTION:
1423 
      x = TApplicationException()
1424 
      x.read(self._iprot)
1425 
      self._iprot.readMessageEnd()
1426 
      raise x
1427 
    result = forgotPassword_result()
1428 
    result.read(self._iprot)
1429 
    self._iprot.readMessageEnd()
3431 rajveer 1430 
    if result.success is not None:
581 rajveer 1431 
      return result.success
3431 rajveer 1432 
    if result.ucx is not None:
581 rajveer 1433 
      raise result.ucx
1434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1435 
 
594 rajveer 1436 
  def getAllAddressesForUser(self, userId):
1437 
    """
1438 
    Parameters:
1439 
     - userId
1440 
    """
1441 
    self.send_getAllAddressesForUser(userId)
1442 
    return self.recv_getAllAddressesForUser()
1443 
 
1444 
  def send_getAllAddressesForUser(self, userId):
1445 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1446 
    args = getAllAddressesForUser_args()
1447 
    args.userId = userId
1448 
    args.write(self._oprot)
1449 
    self._oprot.writeMessageEnd()
1450 
    self._oprot.trans.flush()
1451 
 
1452 
  def recv_getAllAddressesForUser(self, ):
1453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1454 
    if mtype == TMessageType.EXCEPTION:
1455 
      x = TApplicationException()
1456 
      x.read(self._iprot)
1457 
      self._iprot.readMessageEnd()
1458 
      raise x
1459 
    result = getAllAddressesForUser_result()
1460 
    result.read(self._iprot)
1461 
    self._iprot.readMessageEnd()
3431 rajveer 1462 
    if result.success is not None:
594 rajveer 1463 
      return result.success
3431 rajveer 1464 
    if result.ucx is not None:
594 rajveer 1465 
      raise result.ucx
1466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1467 
 
1894 vikas 1468 
  def getAddressById(self, addressId):
1469 
    """
1470 
    Parameters:
1471 
     - addressId
1472 
    """
1473 
    self.send_getAddressById(addressId)
1474 
    return self.recv_getAddressById()
1475 
 
1476 
  def send_getAddressById(self, addressId):
1477 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1478 
    args = getAddressById_args()
1479 
    args.addressId = addressId
1480 
    args.write(self._oprot)
1481 
    self._oprot.writeMessageEnd()
1482 
    self._oprot.trans.flush()
1483 
 
1484 
  def recv_getAddressById(self, ):
1485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1486 
    if mtype == TMessageType.EXCEPTION:
1487 
      x = TApplicationException()
1488 
      x.read(self._iprot)
1489 
      self._iprot.readMessageEnd()
1490 
      raise x
1491 
    result = getAddressById_result()
1492 
    result.read(self._iprot)
1493 
    self._iprot.readMessageEnd()
3431 rajveer 1494 
    if result.success is not None:
1894 vikas 1495 
      return result.success
3431 rajveer 1496 
    if result.ucx is not None:
1894 vikas 1497 
      raise result.ucx
1498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1499 
 
594 rajveer 1500 
  def getDefaultAddressId(self, userId):
1501 
    """
1502 
    Parameters:
1503 
     - userId
1504 
    """
1505 
    self.send_getDefaultAddressId(userId)
1506 
    return self.recv_getDefaultAddressId()
1507 
 
1508 
  def send_getDefaultAddressId(self, userId):
1509 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1510 
    args = getDefaultAddressId_args()
1511 
    args.userId = userId
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_getDefaultAddressId(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = getDefaultAddressId_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
3431 rajveer 1526 
    if result.success is not None:
594 rajveer 1527 
      return result.success
3431 rajveer 1528 
    if result.ucx is not None:
594 rajveer 1529 
      raise result.ucx
1530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1531 
 
785 rajveer 1532 
  def getDefaultPincode(self, userId):
1533 
    """
1534 
    Parameters:
1535 
     - userId
1536 
    """
1537 
    self.send_getDefaultPincode(userId)
1538 
    return self.recv_getDefaultPincode()
1539 
 
1540 
  def send_getDefaultPincode(self, userId):
1541 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1542 
    args = getDefaultPincode_args()
1543 
    args.userId = userId
1544 
    args.write(self._oprot)
1545 
    self._oprot.writeMessageEnd()
1546 
    self._oprot.trans.flush()
1547 
 
1548 
  def recv_getDefaultPincode(self, ):
1549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1550 
    if mtype == TMessageType.EXCEPTION:
1551 
      x = TApplicationException()
1552 
      x.read(self._iprot)
1553 
      self._iprot.readMessageEnd()
1554 
      raise x
1555 
    result = getDefaultPincode_result()
1556 
    result.read(self._iprot)
1557 
    self._iprot.readMessageEnd()
3431 rajveer 1558 
    if result.success is not None:
785 rajveer 1559 
      return result.success
3431 rajveer 1560 
    if result.ucx is not None:
785 rajveer 1561 
      raise result.ucx
1562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1563 
 
1274 varun.gupt 1564 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1565 
    """
1566 
    Parameters:
1567 
     - userId
1568 
     - replyTo
1569 
     - communicationType
1570 
     - orderId
1571 
     - airwaybillNo
1572 
     - productName
1573 
     - subject
1574 
     - message
1575 
    """
1576 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1577 
    return self.recv_saveUserCommunication()
1578 
 
1579 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1580 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1581 
    args = saveUserCommunication_args()
1582 
    args.userId = userId
1583 
    args.replyTo = replyTo
1584 
    args.communicationType = communicationType
1585 
    args.orderId = orderId
1586 
    args.airwaybillNo = airwaybillNo
1587 
    args.productName = productName
1588 
    args.subject = subject
1589 
    args.message = message
1590 
    args.write(self._oprot)
1591 
    self._oprot.writeMessageEnd()
1592 
    self._oprot.trans.flush()
1593 
 
1594 
  def recv_saveUserCommunication(self, ):
1595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1596 
    if mtype == TMessageType.EXCEPTION:
1597 
      x = TApplicationException()
1598 
      x.read(self._iprot)
1599 
      self._iprot.readMessageEnd()
1600 
      raise x
1601 
    result = saveUserCommunication_result()
1602 
    result.read(self._iprot)
1603 
    self._iprot.readMessageEnd()
3431 rajveer 1604 
    if result.success is not None:
1274 varun.gupt 1605 
      return result.success
3431 rajveer 1606 
    if result.ucx is not None:
1274 varun.gupt 1607 
      raise result.ucx
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1609 
 
1590 varun.gupt 1610 
  def getUserCommunicationById(self, id):
1611 
    """
1612 
    Parameters:
1613 
     - id
1614 
    """
1615 
    self.send_getUserCommunicationById(id)
1616 
    return self.recv_getUserCommunicationById()
1617 
 
1618 
  def send_getUserCommunicationById(self, id):
1619 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1620 
    args = getUserCommunicationById_args()
1621 
    args.id = id
1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
1626 
  def recv_getUserCommunicationById(self, ):
1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
1633 
    result = getUserCommunicationById_result()
1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
3431 rajveer 1636 
    if result.success is not None:
1590 varun.gupt 1637 
      return result.success
3431 rajveer 1638 
    if result.ucx is not None:
1590 varun.gupt 1639 
      raise result.ucx
1640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1641 
 
1642 
  def getUserCommunicationByUser(self, userId):
1643 
    """
1644 
    Parameters:
1645 
     - userId
1646 
    """
1647 
    self.send_getUserCommunicationByUser(userId)
1648 
    return self.recv_getUserCommunicationByUser()
1649 
 
1650 
  def send_getUserCommunicationByUser(self, userId):
1651 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1652 
    args = getUserCommunicationByUser_args()
1653 
    args.userId = userId
1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_getUserCommunicationByUser(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = getUserCommunicationByUser_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
3431 rajveer 1668 
    if result.success is not None:
1590 varun.gupt 1669 
      return result.success
3431 rajveer 1670 
    if result.ucx is not None:
1590 varun.gupt 1671 
      raise result.ucx
1672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1673 
 
1674 
  def getAllUserCommunications(self, ):
1675 
    self.send_getAllUserCommunications()
1676 
    return self.recv_getAllUserCommunications()
1677 
 
1678 
  def send_getAllUserCommunications(self, ):
1679 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1680 
    args = getAllUserCommunications_args()
1681 
    args.write(self._oprot)
1682 
    self._oprot.writeMessageEnd()
1683 
    self._oprot.trans.flush()
1684 
 
1685 
  def recv_getAllUserCommunications(self, ):
1686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1687 
    if mtype == TMessageType.EXCEPTION:
1688 
      x = TApplicationException()
1689 
      x.read(self._iprot)
1690 
      self._iprot.readMessageEnd()
1691 
      raise x
1692 
    result = getAllUserCommunications_result()
1693 
    result.read(self._iprot)
1694 
    self._iprot.readMessageEnd()
3431 rajveer 1695 
    if result.success is not None:
1590 varun.gupt 1696 
      return result.success
3431 rajveer 1697 
    if result.ucx is not None:
1590 varun.gupt 1698 
      raise result.ucx
1699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1700 
 
5407 amar.kumar 1701 
  def removeUserCommunication(self, id):
1702 
    """
1703 
    Parameters:
1704 
     - id
1705 
    """
1706 
    self.send_removeUserCommunication(id)
1707 
    self.recv_removeUserCommunication()
1708 
 
1709 
  def send_removeUserCommunication(self, id):
1710 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1711 
    args = removeUserCommunication_args()
1712 
    args.id = id
1713 
    args.write(self._oprot)
1714 
    self._oprot.writeMessageEnd()
1715 
    self._oprot.trans.flush()
1716 
 
1717 
  def recv_removeUserCommunication(self, ):
1718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1719 
    if mtype == TMessageType.EXCEPTION:
1720 
      x = TApplicationException()
1721 
      x.read(self._iprot)
1722 
      self._iprot.readMessageEnd()
1723 
      raise x
1724 
    result = removeUserCommunication_result()
1725 
    result.read(self._iprot)
1726 
    self._iprot.readMessageEnd()
1727 
    if result.ucx is not None:
1728 
      raise result.ucx
1729 
    return
1730 
 
1859 vikas 1731 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1732 
    """
1733 
    Parameters:
1734 
     - name
1859 vikas 1735 
     - addedOn
1845 vikas 1736 
    """
1859 vikas 1737 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1738 
    return self.recv_createMasterAffiliate()
1739 
 
1859 vikas 1740 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1741 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1742 
    args = createMasterAffiliate_args()
1743 
    args.name = name
1859 vikas 1744 
    args.addedOn = addedOn
1845 vikas 1745 
    args.write(self._oprot)
1746 
    self._oprot.writeMessageEnd()
1747 
    self._oprot.trans.flush()
1748 
 
1749 
  def recv_createMasterAffiliate(self, ):
1750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1751 
    if mtype == TMessageType.EXCEPTION:
1752 
      x = TApplicationException()
1753 
      x.read(self._iprot)
1754 
      self._iprot.readMessageEnd()
1755 
      raise x
1756 
    result = createMasterAffiliate_result()
1757 
    result.read(self._iprot)
1758 
    self._iprot.readMessageEnd()
3431 rajveer 1759 
    if result.success is not None:
1845 vikas 1760 
      return result.success
3431 rajveer 1761 
    if result.utx is not None:
1845 vikas 1762 
      raise result.utx
1763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1764 
 
1899 vikas 1765 
  def getAllMasterAffiliates(self, ):
1766 
    self.send_getAllMasterAffiliates()
1767 
    return self.recv_getAllMasterAffiliates()
1768 
 
1769 
  def send_getAllMasterAffiliates(self, ):
1770 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1771 
    args = getAllMasterAffiliates_args()
1772 
    args.write(self._oprot)
1773 
    self._oprot.writeMessageEnd()
1774 
    self._oprot.trans.flush()
1775 
 
1776 
  def recv_getAllMasterAffiliates(self, ):
1777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1778 
    if mtype == TMessageType.EXCEPTION:
1779 
      x = TApplicationException()
1780 
      x.read(self._iprot)
1781 
      self._iprot.readMessageEnd()
1782 
      raise x
1783 
    result = getAllMasterAffiliates_result()
1784 
    result.read(self._iprot)
1785 
    self._iprot.readMessageEnd()
3431 rajveer 1786 
    if result.success is not None:
1899 vikas 1787 
      return result.success
3431 rajveer 1788 
    if result.utx is not None:
1899 vikas 1789 
      raise result.utx
1790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1791 
 
1845 vikas 1792 
  def getMasterAffiliateById(self, id):
1793 
    """
1794 
    Parameters:
1795 
     - id
1796 
    """
1797 
    self.send_getMasterAffiliateById(id)
1798 
    return self.recv_getMasterAffiliateById()
1799 
 
1800 
  def send_getMasterAffiliateById(self, id):
1801 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1802 
    args = getMasterAffiliateById_args()
1803 
    args.id = id
1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
1808 
  def recv_getMasterAffiliateById(self, ):
1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
1815 
    result = getMasterAffiliateById_result()
1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
3431 rajveer 1818 
    if result.success is not None:
1845 vikas 1819 
      return result.success
3431 rajveer 1820 
    if result.utx is not None:
1845 vikas 1821 
      raise result.utx
1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1823 
 
1824 
  def getMasterAffiliateByName(self, name):
1825 
    """
1826 
    Parameters:
1827 
     - name
1828 
    """
1829 
    self.send_getMasterAffiliateByName(name)
1830 
    return self.recv_getMasterAffiliateByName()
1831 
 
1832 
  def send_getMasterAffiliateByName(self, name):
1833 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1834 
    args = getMasterAffiliateByName_args()
1835 
    args.name = name
1836 
    args.write(self._oprot)
1837 
    self._oprot.writeMessageEnd()
1838 
    self._oprot.trans.flush()
1839 
 
1840 
  def recv_getMasterAffiliateByName(self, ):
1841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1842 
    if mtype == TMessageType.EXCEPTION:
1843 
      x = TApplicationException()
1844 
      x.read(self._iprot)
1845 
      self._iprot.readMessageEnd()
1846 
      raise x
1847 
    result = getMasterAffiliateByName_result()
1848 
    result.read(self._iprot)
1849 
    self._iprot.readMessageEnd()
3431 rajveer 1850 
    if result.success is not None:
1845 vikas 1851 
      return result.success
3431 rajveer 1852 
    if result.utx is not None:
1845 vikas 1853 
      raise result.utx
1854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1855 
 
1859 vikas 1856 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1857 
    """
1858 
    Parameters:
1859 
     - name
1860 
     - url
1861 
     - masterAffiliateId
1859 vikas 1862 
     - addedOn
1845 vikas 1863 
    """
1859 vikas 1864 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1865 
    return self.recv_createAffiliate()
1866 
 
1859 vikas 1867 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1868 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1869 
    args = createAffiliate_args()
1870 
    args.name = name
1871 
    args.url = url
1872 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1873 
    args.addedOn = addedOn
1845 vikas 1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_createAffiliate(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = createAffiliate_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
1845 vikas 1889 
      return result.success
3431 rajveer 1890 
    if result.utx is not None:
1845 vikas 1891 
      raise result.utx
1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1893 
 
1894 
  def getAffiliateById(self, id):
1895 
    """
1896 
    Parameters:
1897 
     - id
1898 
    """
1899 
    self.send_getAffiliateById(id)
1900 
    return self.recv_getAffiliateById()
1901 
 
1902 
  def send_getAffiliateById(self, id):
1903 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1904 
    args = getAffiliateById_args()
1905 
    args.id = id
1906 
    args.write(self._oprot)
1907 
    self._oprot.writeMessageEnd()
1908 
    self._oprot.trans.flush()
1909 
 
1910 
  def recv_getAffiliateById(self, ):
1911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1912 
    if mtype == TMessageType.EXCEPTION:
1913 
      x = TApplicationException()
1914 
      x.read(self._iprot)
1915 
      self._iprot.readMessageEnd()
1916 
      raise x
1917 
    result = getAffiliateById_result()
1918 
    result.read(self._iprot)
1919 
    self._iprot.readMessageEnd()
3431 rajveer 1920 
    if result.success is not None:
1845 vikas 1921 
      return result.success
3431 rajveer 1922 
    if result.utx is not None:
1845 vikas 1923 
      raise result.utx
1924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1925 
 
1926 
  def getAffiliateByName(self, name):
1927 
    """
1928 
    Parameters:
1929 
     - name
1930 
    """
1931 
    self.send_getAffiliateByName(name)
1932 
    return self.recv_getAffiliateByName()
1933 
 
1934 
  def send_getAffiliateByName(self, name):
1935 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1936 
    args = getAffiliateByName_args()
1937 
    args.name = name
1938 
    args.write(self._oprot)
1939 
    self._oprot.writeMessageEnd()
1940 
    self._oprot.trans.flush()
1941 
 
1942 
  def recv_getAffiliateByName(self, ):
1943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1944 
    if mtype == TMessageType.EXCEPTION:
1945 
      x = TApplicationException()
1946 
      x.read(self._iprot)
1947 
      self._iprot.readMessageEnd()
1948 
      raise x
1949 
    result = getAffiliateByName_result()
1950 
    result.read(self._iprot)
1951 
    self._iprot.readMessageEnd()
3431 rajveer 1952 
    if result.success is not None:
1845 vikas 1953 
      return result.success
3431 rajveer 1954 
    if result.utx is not None:
1845 vikas 1955 
      raise result.utx
1956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1957 
 
1996 vikas 1958 
  def getTrackerById(self, id):
1845 vikas 1959 
    """
1960 
    Parameters:
1961 
     - id
1962 
    """
1996 vikas 1963 
    self.send_getTrackerById(id)
1845 vikas 1964 
    return self.recv_getTrackerById()
1965 
 
1996 vikas 1966 
  def send_getTrackerById(self, id):
1845 vikas 1967 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1968 
    args = getTrackerById_args()
1996 vikas 1969 
    args.id = id
1845 vikas 1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
1974 
  def recv_getTrackerById(self, ):
1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
1981 
    result = getTrackerById_result()
1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
3431 rajveer 1984 
    if result.success is not None:
1845 vikas 1985 
      return result.success
3431 rajveer 1986 
    if result.utx is not None:
1845 vikas 1987 
      raise result.utx
1988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1989 
 
1996 vikas 1990 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1991 
    """
1992 
    Parameters:
1996 vikas 1993 
     - id
1845 vikas 1994 
    """
1996 vikas 1995 
    self.send_getAffiliatesByMasterAffiliate(id)
1996 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1997 
 
1996 vikas 1998 
  def send_getAffiliatesByMasterAffiliate(self, id):
1999 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
2000 
    args = getAffiliatesByMasterAffiliate_args()
2001 
    args.id = id
1845 vikas 2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
1996 vikas 2006 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
1996 vikas 2013 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
3431 rajveer 2016 
    if result.success is not None:
1845 vikas 2017 
      return result.success
3431 rajveer 2018 
    if result.utx is not None:
1845 vikas 2019 
      raise result.utx
1996 vikas 2020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 2021 
 
1996 vikas 2022 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 2023 
    """
2024 
    Parameters:
1996 vikas 2025 
     - affiliateId
1845 vikas 2026 
     - userId
2027 
     - event
2028 
     - url
2029 
     - data
1859 vikas 2030 
     - addedOn
1845 vikas 2031 
    """
1996 vikas 2032 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 2033 
    return self.recv_addTrackLog()
2034 
 
1996 vikas 2035 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 2036 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
2037 
    args = addTrackLog_args()
1996 vikas 2038 
    args.affiliateId = affiliateId
1845 vikas 2039 
    args.userId = userId
2040 
    args.event = event
2041 
    args.url = url
2042 
    args.data = data
1859 vikas 2043 
    args.addedOn = addedOn
1845 vikas 2044 
    args.write(self._oprot)
2045 
    self._oprot.writeMessageEnd()
2046 
    self._oprot.trans.flush()
2047 
 
2048 
  def recv_addTrackLog(self, ):
2049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2050 
    if mtype == TMessageType.EXCEPTION:
2051 
      x = TApplicationException()
2052 
      x.read(self._iprot)
2053 
      self._iprot.readMessageEnd()
2054 
      raise x
2055 
    result = addTrackLog_result()
2056 
    result.read(self._iprot)
2057 
    self._iprot.readMessageEnd()
3431 rajveer 2058 
    if result.success is not None:
1845 vikas 2059 
      return result.success
3431 rajveer 2060 
    if result.utx is not None:
1845 vikas 2061 
      raise result.utx
2062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
2063 
 
2064 
  def getTrackLogById(self, id):
2065 
    """
2066 
    Parameters:
2067 
     - id
2068 
    """
2069 
    self.send_getTrackLogById(id)
2070 
    return self.recv_getTrackLogById()
2071 
 
2072 
  def send_getTrackLogById(self, id):
2073 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
2074 
    args = getTrackLogById_args()
2075 
    args.id = id
2076 
    args.write(self._oprot)
2077 
    self._oprot.writeMessageEnd()
2078 
    self._oprot.trans.flush()
2079 
 
2080 
  def recv_getTrackLogById(self, ):
2081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2082 
    if mtype == TMessageType.EXCEPTION:
2083 
      x = TApplicationException()
2084 
      x.read(self._iprot)
2085 
      self._iprot.readMessageEnd()
2086 
      raise x
2087 
    result = getTrackLogById_result()
2088 
    result.read(self._iprot)
2089 
    self._iprot.readMessageEnd()
3431 rajveer 2090 
    if result.success is not None:
1845 vikas 2091 
      return result.success
3431 rajveer 2092 
    if result.utx is not None:
1845 vikas 2093 
      raise result.utx
2094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2095 
 
3293 vikas 2096 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2097 
    """
2098 
    Parameters:
1996 vikas 2099 
     - affiliateId
3293 vikas 2100 
     - startDate
2101 
     - endDate
1845 vikas 2102 
    """
3293 vikas 2103 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2104 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2105 
 
3293 vikas 2106 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2107 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2108 
    args = getTrackLogsByAffiliate_args()
2109 
    args.affiliateId = affiliateId
3293 vikas 2110 
    args.startDate = startDate
2111 
    args.endDate = endDate
1845 vikas 2112 
    args.write(self._oprot)
2113 
    self._oprot.writeMessageEnd()
2114 
    self._oprot.trans.flush()
2115 
 
1996 vikas 2116 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2118 
    if mtype == TMessageType.EXCEPTION:
2119 
      x = TApplicationException()
2120 
      x.read(self._iprot)
2121 
      self._iprot.readMessageEnd()
2122 
      raise x
1996 vikas 2123 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2124 
    result.read(self._iprot)
2125 
    self._iprot.readMessageEnd()
3431 rajveer 2126 
    if result.success is not None:
1845 vikas 2127 
      return result.success
3431 rajveer 2128 
    if result.utx is not None:
1845 vikas 2129 
      raise result.utx
1996 vikas 2130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2131 
 
2132 
  def getTrackLogsByUser(self, userId):
2133 
    """
2134 
    Parameters:
2135 
     - userId
2136 
    """
2137 
    self.send_getTrackLogsByUser(userId)
2138 
    return self.recv_getTrackLogsByUser()
2139 
 
2140 
  def send_getTrackLogsByUser(self, userId):
2141 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2142 
    args = getTrackLogsByUser_args()
2143 
    args.userId = userId
2144 
    args.write(self._oprot)
2145 
    self._oprot.writeMessageEnd()
2146 
    self._oprot.trans.flush()
2147 
 
2148 
  def recv_getTrackLogsByUser(self, ):
2149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2150 
    if mtype == TMessageType.EXCEPTION:
2151 
      x = TApplicationException()
2152 
      x.read(self._iprot)
2153 
      self._iprot.readMessageEnd()
2154 
      raise x
2155 
    result = getTrackLogsByUser_result()
2156 
    result.read(self._iprot)
2157 
    self._iprot.readMessageEnd()
3431 rajveer 2158 
    if result.success is not None:
1845 vikas 2159 
      return result.success
3431 rajveer 2160 
    if result.utx is not None:
1845 vikas 2161 
      raise result.utx
2162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2163 
 
1996 vikas 2164 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2165 
    """
2166 
    Parameters:
2167 
     - userId
2168 
     - event
2169 
     - url
2170 
    """
1996 vikas 2171 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2172 
    return self.recv_getTrackLogs()
2173 
 
1996 vikas 2174 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2175 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2176 
    args = getTrackLogs_args()
2177 
    args.userId = userId
2178 
    args.event = event
2179 
    args.url = url
2180 
    args.write(self._oprot)
2181 
    self._oprot.writeMessageEnd()
2182 
    self._oprot.trans.flush()
2183 
 
2184 
  def recv_getTrackLogs(self, ):
2185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2186 
    if mtype == TMessageType.EXCEPTION:
2187 
      x = TApplicationException()
2188 
      x.read(self._iprot)
2189 
      self._iprot.readMessageEnd()
2190 
      raise x
2191 
    result = getTrackLogs_result()
2192 
    result.read(self._iprot)
2193 
    self._iprot.readMessageEnd()
3431 rajveer 2194 
    if result.success is not None:
1845 vikas 2195 
      return result.success
3431 rajveer 2196 
    if result.utx is not None:
1845 vikas 2197 
      raise result.utx
2198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2199 
 
559 chandransh 2200 
  def getCurrentCart(self, userId):
94 ashish 2201 
    """
2202 
    Parameters:
559 chandransh 2203 
     - userId
94 ashish 2204 
    """
559 chandransh 2205 
    self.send_getCurrentCart(userId)
2206 
    return self.recv_getCurrentCart()
94 ashish 2207 
 
559 chandransh 2208 
  def send_getCurrentCart(self, userId):
2209 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2210 
    args = getCurrentCart_args()
2211 
    args.userId = userId
94 ashish 2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
559 chandransh 2216 
  def recv_getCurrentCart(self, ):
94 ashish 2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
559 chandransh 2223 
    result = getCurrentCart_result()
94 ashish 2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
3431 rajveer 2226 
    if result.success is not None:
94 ashish 2227 
      return result.success
3431 rajveer 2228 
    if result.scx is not None:
559 chandransh 2229 
      raise result.scx
2230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2231 
 
559 chandransh 2232 
  def getCart(self, cartId):
94 ashish 2233 
    """
2234 
    Parameters:
559 chandransh 2235 
     - cartId
94 ashish 2236 
    """
559 chandransh 2237 
    self.send_getCart(cartId)
2238 
    return self.recv_getCart()
94 ashish 2239 
 
559 chandransh 2240 
  def send_getCart(self, cartId):
2241 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2242 
    args = getCart_args()
2243 
    args.cartId = cartId
94 ashish 2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
559 chandransh 2248 
  def recv_getCart(self, ):
94 ashish 2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
559 chandransh 2255 
    result = getCart_result()
94 ashish 2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
3431 rajveer 2258 
    if result.success is not None:
94 ashish 2259 
      return result.success
3431 rajveer 2260 
    if result.scx is not None:
559 chandransh 2261 
      raise result.scx
2262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2263 
 
559 chandransh 2264 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2265 
    """
2266 
    Parameters:
559 chandransh 2267 
     - from_time
2268 
     - to_time
2269 
     - status
94 ashish 2270 
    """
559 chandransh 2271 
    self.send_getCartsByTime(from_time, to_time, status)
2272 
    return self.recv_getCartsByTime()
94 ashish 2273 
 
559 chandransh 2274 
  def send_getCartsByTime(self, from_time, to_time, status):
2275 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2276 
    args = getCartsByTime_args()
2277 
    args.from_time = from_time
2278 
    args.to_time = to_time
2279 
    args.status = status
94 ashish 2280 
    args.write(self._oprot)
2281 
    self._oprot.writeMessageEnd()
2282 
    self._oprot.trans.flush()
2283 
 
559 chandransh 2284 
  def recv_getCartsByTime(self, ):
94 ashish 2285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2286 
    if mtype == TMessageType.EXCEPTION:
2287 
      x = TApplicationException()
2288 
      x.read(self._iprot)
2289 
      self._iprot.readMessageEnd()
2290 
      raise x
559 chandransh 2291 
    result = getCartsByTime_result()
94 ashish 2292 
    result.read(self._iprot)
2293 
    self._iprot.readMessageEnd()
3431 rajveer 2294 
    if result.success is not None:
94 ashish 2295 
      return result.success
3431 rajveer 2296 
    if result.scx is not None:
559 chandransh 2297 
      raise result.scx
2298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2299 
 
3557 rajveer 2300 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2301 
    """
2302 
    Parameters:
2303 
     - cartId
2304 
     - itemId
2305 
     - quantity
3557 rajveer 2306 
     - sourceId
559 chandransh 2307 
    """
3557 rajveer 2308 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2309 
    return self.recv_addItemToCart()
559 chandransh 2310 
 
3557 rajveer 2311 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2312 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2313 
    args = addItemToCart_args()
2314 
    args.cartId = cartId
2315 
    args.itemId = itemId
2316 
    args.quantity = quantity
3557 rajveer 2317 
    args.sourceId = sourceId
559 chandransh 2318 
    args.write(self._oprot)
2319 
    self._oprot.writeMessageEnd()
2320 
    self._oprot.trans.flush()
2321 
 
2322 
  def recv_addItemToCart(self, ):
2323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2324 
    if mtype == TMessageType.EXCEPTION:
2325 
      x = TApplicationException()
2326 
      x.read(self._iprot)
2327 
      self._iprot.readMessageEnd()
2328 
      raise x
2329 
    result = addItemToCart_result()
2330 
    result.read(self._iprot)
2331 
    self._iprot.readMessageEnd()
3431 rajveer 2332 
    if result.success is not None:
2035 rajveer 2333 
      return result.success
3431 rajveer 2334 
    if result.scx is not None:
559 chandransh 2335 
      raise result.scx
2035 rajveer 2336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2337 
 
2338 
  def deleteItemFromCart(self, cartId, itemId):
2339 
    """
2340 
    Parameters:
2341 
     - cartId
2342 
     - itemId
2343 
    """
2344 
    self.send_deleteItemFromCart(cartId, itemId)
2345 
    self.recv_deleteItemFromCart()
2346 
 
2347 
  def send_deleteItemFromCart(self, cartId, itemId):
2348 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2349 
    args = deleteItemFromCart_args()
2350 
    args.cartId = cartId
2351 
    args.itemId = itemId
2352 
    args.write(self._oprot)
2353 
    self._oprot.writeMessageEnd()
2354 
    self._oprot.trans.flush()
2355 
 
2356 
  def recv_deleteItemFromCart(self, ):
2357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2358 
    if mtype == TMessageType.EXCEPTION:
2359 
      x = TApplicationException()
2360 
      x.read(self._iprot)
2361 
      self._iprot.readMessageEnd()
2362 
      raise x
2363 
    result = deleteItemFromCart_result()
2364 
    result.read(self._iprot)
2365 
    self._iprot.readMessageEnd()
3431 rajveer 2366 
    if result.scx is not None:
559 chandransh 2367 
      raise result.scx
2368 
    return
2369 
 
2370 
  def addAddressToCart(self, cartId, addressId):
2371 
    """
2372 
    Parameters:
2373 
     - cartId
2374 
     - addressId
2375 
    """
2376 
    self.send_addAddressToCart(cartId, addressId)
2377 
    self.recv_addAddressToCart()
2378 
 
2379 
  def send_addAddressToCart(self, cartId, addressId):
2380 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2381 
    args = addAddressToCart_args()
2382 
    args.cartId = cartId
2383 
    args.addressId = addressId
2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
2388 
  def recv_addAddressToCart(self, ):
2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
2395 
    result = addAddressToCart_result()
2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
3431 rajveer 2398 
    if result.scx is not None:
575 chandransh 2399 
      raise result.scx
559 chandransh 2400 
    return
2401 
 
5553 rajveer 2402 
  def addStoreToCart(self, cartId, storeId):
2403 
    """
2404 
    Parameters:
2405 
     - cartId
2406 
     - storeId
2407 
    """
2408 
    self.send_addStoreToCart(cartId, storeId)
2409 
    self.recv_addStoreToCart()
2410 
 
2411 
  def send_addStoreToCart(self, cartId, storeId):
2412 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2413 
    args = addStoreToCart_args()
2414 
    args.cartId = cartId
2415 
    args.storeId = storeId
2416 
    args.write(self._oprot)
2417 
    self._oprot.writeMessageEnd()
2418 
    self._oprot.trans.flush()
2419 
 
2420 
  def recv_addStoreToCart(self, ):
2421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2422 
    if mtype == TMessageType.EXCEPTION:
2423 
      x = TApplicationException()
2424 
      x.read(self._iprot)
2425 
      self._iprot.readMessageEnd()
2426 
      raise x
2427 
    result = addStoreToCart_result()
2428 
    result.read(self._iprot)
2429 
    self._iprot.readMessageEnd()
2430 
    if result.scx is not None:
2431 
      raise result.scx
2432 
    return
2433 
 
6922 anupam.sin 2434 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2435 
    """
2436 
    Parameters:
6922 anupam.sin 2437 
     - cart
1976 varun.gupt 2438 
     - couponCode
2439 
    """
6922 anupam.sin 2440 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2441 
    self.recv_applyCouponToCart()
2442 
 
6922 anupam.sin 2443 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2444 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2445 
    args = applyCouponToCart_args()
6922 anupam.sin 2446 
    args.cart = cart
1976 varun.gupt 2447 
    args.couponCode = couponCode
2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_applyCouponToCart(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = applyCouponToCart_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
3431 rajveer 2462 
    if result.scx is not None:
1976 varun.gupt 2463 
      raise result.scx
2464 
    return
2465 
 
2466 
  def removeCoupon(self, cartId):
2467 
    """
2468 
    Parameters:
2469 
     - cartId
2470 
    """
2471 
    self.send_removeCoupon(cartId)
2472 
    self.recv_removeCoupon()
2473 
 
2474 
  def send_removeCoupon(self, cartId):
2475 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2476 
    args = removeCoupon_args()
2477 
    args.cartId = cartId
2478 
    args.write(self._oprot)
2479 
    self._oprot.writeMessageEnd()
2480 
    self._oprot.trans.flush()
2481 
 
2482 
  def recv_removeCoupon(self, ):
2483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2484 
    if mtype == TMessageType.EXCEPTION:
2485 
      x = TApplicationException()
2486 
      x.read(self._iprot)
2487 
      self._iprot.readMessageEnd()
2488 
      raise x
2489 
    result = removeCoupon_result()
2490 
    result.read(self._iprot)
2491 
    self._iprot.readMessageEnd()
3431 rajveer 2492 
    if result.scx is not None:
1976 varun.gupt 2493 
      raise result.scx
2494 
    return
2495 
 
3554 varun.gupt 2496 
  def deleteDiscountsFromCart(self, cartId):
2497 
    """
2498 
    Deletes all the discounts associated with the cart
2499 
 
2500 
    Parameters:
2501 
     - cartId
2502 
    """
2503 
    self.send_deleteDiscountsFromCart(cartId)
2504 
    self.recv_deleteDiscountsFromCart()
2505 
 
2506 
  def send_deleteDiscountsFromCart(self, cartId):
2507 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2508 
    args = deleteDiscountsFromCart_args()
2509 
    args.cartId = cartId
2510 
    args.write(self._oprot)
2511 
    self._oprot.writeMessageEnd()
2512 
    self._oprot.trans.flush()
2513 
 
2514 
  def recv_deleteDiscountsFromCart(self, ):
2515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2516 
    if mtype == TMessageType.EXCEPTION:
2517 
      x = TApplicationException()
2518 
      x.read(self._iprot)
2519 
      self._iprot.readMessageEnd()
2520 
      raise x
2521 
    result = deleteDiscountsFromCart_result()
2522 
    result.read(self._iprot)
2523 
    self._iprot.readMessageEnd()
2524 
    if result.scx is not None:
2525 
      raise result.scx
2526 
    return
2527 
 
2528 
  def saveDiscounts(self, discounts):
2529 
    """
2530 
    Accepts a list of thrift objects of Discount type and saves them
2531 
 
2532 
    Parameters:
2533 
     - discounts
2534 
    """
2535 
    self.send_saveDiscounts(discounts)
2536 
    self.recv_saveDiscounts()
2537 
 
2538 
  def send_saveDiscounts(self, discounts):
2539 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2540 
    args = saveDiscounts_args()
2541 
    args.discounts = discounts
2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
2546 
  def recv_saveDiscounts(self, ):
2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
2553 
    result = saveDiscounts_result()
2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
2556 
    if result.scx is not None:
2557 
      raise result.scx
2558 
    return
2559 
 
21454 amit.gupta 2560 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 2561 
    """
690 chandransh 2562 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2563 
 
559 chandransh 2564 
    Parameters:
2565 
     - cartId
2815 vikas 2566 
     - sessionSource
2567 
     - sessionStartTime
3858 vikas 2568 
     - firstSource
2569 
     - firstSourceTime
5326 rajveer 2570 
     - userId
6389 rajveer 2571 
     - schemeId
11526 amit.gupta 2572 
     - orderSource
21454 amit.gupta 2573 
     - selfPickup
559 chandransh 2574 
    """
21454 amit.gupta 2575 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup)
690 chandransh 2576 
    return self.recv_createOrders()
559 chandransh 2577 
 
21454 amit.gupta 2578 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
690 chandransh 2579 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2580 
    args = createOrders_args()
559 chandransh 2581 
    args.cartId = cartId
2815 vikas 2582 
    args.sessionSource = sessionSource
2583 
    args.sessionStartTime = sessionStartTime
3858 vikas 2584 
    args.firstSource = firstSource
2585 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2586 
    args.userId = userId
6389 rajveer 2587 
    args.schemeId = schemeId
11526 amit.gupta 2588 
    args.orderSource = orderSource
21454 amit.gupta 2589 
    args.selfPickup = selfPickup
559 chandransh 2590 
    args.write(self._oprot)
2591 
    self._oprot.writeMessageEnd()
2592 
    self._oprot.trans.flush()
2593 
 
690 chandransh 2594 
  def recv_createOrders(self, ):
559 chandransh 2595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2596 
    if mtype == TMessageType.EXCEPTION:
2597 
      x = TApplicationException()
2598 
      x.read(self._iprot)
2599 
      self._iprot.readMessageEnd()
2600 
      raise x
690 chandransh 2601 
    result = createOrders_result()
559 chandransh 2602 
    result.read(self._iprot)
2603 
    self._iprot.readMessageEnd()
3431 rajveer 2604 
    if result.success is not None:
130 ashish 2605 
      return result.success
3431 rajveer 2606 
    if result.scx is not None:
559 chandransh 2607 
      raise result.scx
690 chandransh 2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2609 
 
3557 rajveer 2610 
  def validateCart(self, cartId, sourceId):
130 ashish 2611 
    """
690 chandransh 2612 
    Validates that:
2613 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2614 
    2. All of the lines in the cart are active items.
690 chandransh 2615 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2616 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2617 
 
130 ashish 2618 
    Parameters:
559 chandransh 2619 
     - cartId
3557 rajveer 2620 
     - sourceId
130 ashish 2621 
    """
3557 rajveer 2622 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2623 
    return self.recv_validateCart()
130 ashish 2624 
 
3557 rajveer 2625 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2626 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2627 
    args = validateCart_args()
2628 
    args.cartId = cartId
3557 rajveer 2629 
    args.sourceId = sourceId
130 ashish 2630 
    args.write(self._oprot)
2631 
    self._oprot.writeMessageEnd()
2632 
    self._oprot.trans.flush()
2633 
 
559 chandransh 2634 
  def recv_validateCart(self, ):
130 ashish 2635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2636 
    if mtype == TMessageType.EXCEPTION:
2637 
      x = TApplicationException()
2638 
      x.read(self._iprot)
2639 
      self._iprot.readMessageEnd()
2640 
      raise x
559 chandransh 2641 
    result = validateCart_result()
130 ashish 2642 
    result.read(self._iprot)
2643 
    self._iprot.readMessageEnd()
3431 rajveer 2644 
    if result.success is not None:
130 ashish 2645 
      return result.success
3431 rajveer 2646 
    if result.scex is not None:
575 chandransh 2647 
      raise result.scex
559 chandransh 2648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2649 
 
11980 amit.gupta 2650 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2651 
    """
2652 
    Validates that:
2653 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2654 
    2. All of the lines in the cart are active items.
2655 
    3. The estimate for any of the lines in cart doesn't change.
2656 
    If all three are true, returns empty string; else returns appropriate message.
2657 
 
2658 
    Parameters:
2659 
     - cartId
2660 
     - sourceId
2661 
     - dealCoupon
2662 
    """
2663 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2664 
    return self.recv_validateCartWithDealerCoupon()
2665 
 
2666 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2667 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2668 
    args = validateCartWithDealerCoupon_args()
2669 
    args.cartId = cartId
2670 
    args.sourceId = sourceId
2671 
    args.dealCoupon = dealCoupon
2672 
    args.write(self._oprot)
2673 
    self._oprot.writeMessageEnd()
2674 
    self._oprot.trans.flush()
2675 
 
2676 
  def recv_validateCartWithDealerCoupon(self, ):
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
2683 
    result = validateCartWithDealerCoupon_result()
2684 
    result.read(self._iprot)
2685 
    self._iprot.readMessageEnd()
2686 
    if result.success is not None:
2687 
      return result.success
2688 
    if result.scex is not None:
2689 
      raise result.scex
2690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2691 
 
690 chandransh 2692 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2693 
    """
690 chandransh 2694 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2695 
 
575 chandransh 2696 
    Parameters:
690 chandransh 2697 
     - fromCartId
2698 
     - toCartId
2699 
    """
2700 
    self.send_mergeCart(fromCartId, toCartId)
2701 
    self.recv_mergeCart()
2702 
 
2703 
  def send_mergeCart(self, fromCartId, toCartId):
2704 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2705 
    args = mergeCart_args()
2706 
    args.fromCartId = fromCartId
2707 
    args.toCartId = toCartId
2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2712 
  def recv_mergeCart(self, ):
2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2719 
    result = mergeCart_result()
2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
2722 
    return
2723 
 
2724 
  def checkOut(self, cartId):
2725 
    """
2726 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2727 
 
690 chandransh 2728 
    Parameters:
575 chandransh 2729 
     - cartId
2730 
    """
690 chandransh 2731 
    self.send_checkOut(cartId)
2732 
    return self.recv_checkOut()
575 chandransh 2733 
 
690 chandransh 2734 
  def send_checkOut(self, cartId):
2735 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2736 
    args = checkOut_args()
575 chandransh 2737 
    args.cartId = cartId
2738 
    args.write(self._oprot)
2739 
    self._oprot.writeMessageEnd()
2740 
    self._oprot.trans.flush()
2741 
 
690 chandransh 2742 
  def recv_checkOut(self, ):
575 chandransh 2743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2744 
    if mtype == TMessageType.EXCEPTION:
2745 
      x = TApplicationException()
2746 
      x.read(self._iprot)
2747 
      self._iprot.readMessageEnd()
2748 
      raise x
690 chandransh 2749 
    result = checkOut_result()
575 chandransh 2750 
    result.read(self._iprot)
2751 
    self._iprot.readMessageEnd()
3431 rajveer 2752 
    if result.success is not None:
575 chandransh 2753 
      return result.success
3431 rajveer 2754 
    if result.scex is not None:
575 chandransh 2755 
      raise result.scex
690 chandransh 2756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2757 
 
690 chandransh 2758 
  def resetCart(self, cartId, items):
559 chandransh 2759 
    """
690 chandransh 2760 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2761 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2762 
 
559 chandransh 2763 
    Parameters:
690 chandransh 2764 
     - cartId
2765 
     - items
559 chandransh 2766 
    """
690 chandransh 2767 
    self.send_resetCart(cartId, items)
2768 
    return self.recv_resetCart()
130 ashish 2769 
 
690 chandransh 2770 
  def send_resetCart(self, cartId, items):
2771 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2772 
    args = resetCart_args()
2773 
    args.cartId = cartId
2774 
    args.items = items
559 chandransh 2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
690 chandransh 2779 
  def recv_resetCart(self, ):
559 chandransh 2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
690 chandransh 2786 
    result = resetCart_result()
559 chandransh 2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
3431 rajveer 2789 
    if result.success is not None:
690 chandransh 2790 
      return result.success
3431 rajveer 2791 
    if result.scex is not None:
690 chandransh 2792 
      raise result.scex
2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2794 
 
2981 rajveer 2795 
  def getUserCount(self, userType):
559 chandransh 2796 
    """
2981 rajveer 2797 
    Returns number of registered users.
2798 
    If userType = null, then it returns count of all users, including anonymous
2799 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2800 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2801 
 
559 chandransh 2802 
    Parameters:
2981 rajveer 2803 
     - userType
559 chandransh 2804 
    """
2981 rajveer 2805 
    self.send_getUserCount(userType)
2806 
    return self.recv_getUserCount()
559 chandransh 2807 
 
2981 rajveer 2808 
  def send_getUserCount(self, userType):
2809 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2810 
    args = getUserCount_args()
2811 
    args.userType = userType
559 chandransh 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
2981 rajveer 2816 
  def recv_getUserCount(self, ):
559 chandransh 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
2981 rajveer 2823 
    result = getUserCount_result()
559 chandransh 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
3431 rajveer 2826 
    if result.success is not None:
559 chandransh 2827 
      return result.success
2981 rajveer 2828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2829 
 
2981 rajveer 2830 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2831 
    """
2981 rajveer 2832 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2833 
    If any of startDate or endDate is -1, then that filter is ignored.
2834 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2835 
 
2836 
 
559 chandransh 2837 
    Parameters:
2981 rajveer 2838 
     - userType
2839 
     - startDate
2840 
     - endDate
559 chandransh 2841 
    """
2981 rajveer 2842 
    self.send_getAllUsers(userType, startDate, endDate)
2843 
    return self.recv_getAllUsers()
559 chandransh 2844 
 
2981 rajveer 2845 
  def send_getAllUsers(self, userType, startDate, endDate):
2846 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2847 
    args = getAllUsers_args()
2848 
    args.userType = userType
2849 
    args.startDate = startDate
2850 
    args.endDate = endDate
559 chandransh 2851 
    args.write(self._oprot)
2852 
    self._oprot.writeMessageEnd()
2853 
    self._oprot.trans.flush()
2854 
 
2981 rajveer 2855 
  def recv_getAllUsers(self, ):
559 chandransh 2856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2857 
    if mtype == TMessageType.EXCEPTION:
2858 
      x = TApplicationException()
2859 
      x.read(self._iprot)
2860 
      self._iprot.readMessageEnd()
2861 
      raise x
2981 rajveer 2862 
    result = getAllUsers_result()
559 chandransh 2863 
    result.read(self._iprot)
2864 
    self._iprot.readMessageEnd()
3431 rajveer 2865 
    if result.success is not None:
559 chandransh 2866 
      return result.success
2981 rajveer 2867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2868 
 
2981 rajveer 2869 
  def getMyResearchItems(self, userId):
559 chandransh 2870 
    """
2981 rajveer 2871 
    Returns list of item ids in myresearch for the user
3431 rajveer 2872 
 
559 chandransh 2873 
    Parameters:
772 rajveer 2874 
     - userId
559 chandransh 2875 
    """
2981 rajveer 2876 
    self.send_getMyResearchItems(userId)
2877 
    return self.recv_getMyResearchItems()
559 chandransh 2878 
 
2981 rajveer 2879 
  def send_getMyResearchItems(self, userId):
2880 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2881 
    args = getMyResearchItems_args()
772 rajveer 2882 
    args.userId = userId
559 chandransh 2883 
    args.write(self._oprot)
2884 
    self._oprot.writeMessageEnd()
2885 
    self._oprot.trans.flush()
2886 
 
2981 rajveer 2887 
  def recv_getMyResearchItems(self, ):
559 chandransh 2888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2889 
    if mtype == TMessageType.EXCEPTION:
2890 
      x = TApplicationException()
2891 
      x.read(self._iprot)
2892 
      self._iprot.readMessageEnd()
2893 
      raise x
2981 rajveer 2894 
    result = getMyResearchItems_result()
559 chandransh 2895 
    result.read(self._iprot)
2896 
    self._iprot.readMessageEnd()
3431 rajveer 2897 
    if result.success is not None:
559 chandransh 2898 
      return result.success
3431 rajveer 2899 
    if result.scx is not None:
559 chandransh 2900 
      raise result.scx
2981 rajveer 2901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2902 
 
2981 rajveer 2903 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2904 
    """
2981 rajveer 2905 
    add item to my research for a user
3431 rajveer 2906 
 
559 chandransh 2907 
    Parameters:
2981 rajveer 2908 
     - userId
2909 
     - itemId
559 chandransh 2910 
    """
2981 rajveer 2911 
    self.send_updateMyResearch(userId, itemId)
2912 
    return self.recv_updateMyResearch()
559 chandransh 2913 
 
2981 rajveer 2914 
  def send_updateMyResearch(self, userId, itemId):
2915 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2916 
    args = updateMyResearch_args()
2917 
    args.userId = userId
2918 
    args.itemId = itemId
559 chandransh 2919 
    args.write(self._oprot)
2920 
    self._oprot.writeMessageEnd()
2921 
    self._oprot.trans.flush()
2922 
 
2981 rajveer 2923 
  def recv_updateMyResearch(self, ):
559 chandransh 2924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2925 
    if mtype == TMessageType.EXCEPTION:
2926 
      x = TApplicationException()
2927 
      x.read(self._iprot)
2928 
      self._iprot.readMessageEnd()
2929 
      raise x
2981 rajveer 2930 
    result = updateMyResearch_result()
559 chandransh 2931 
    result.read(self._iprot)
2932 
    self._iprot.readMessageEnd()
3431 rajveer 2933 
    if result.success is not None:
2981 rajveer 2934 
      return result.success
3431 rajveer 2935 
    if result.scx is not None:
2981 rajveer 2936 
      raise result.scx
2937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2938 
 
2981 rajveer 2939 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2940 
    """
2981 rajveer 2941 
    delete item from my research for a user
3431 rajveer 2942 
 
1596 ankur.sing 2943 
    Parameters:
2981 rajveer 2944 
     - userId
2945 
     - itemId
1596 ankur.sing 2946 
    """
2981 rajveer 2947 
    self.send_deleteItemFromMyResearch(userId, itemId)
2948 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2949 
 
2981 rajveer 2950 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2951 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2952 
    args = deleteItemFromMyResearch_args()
2953 
    args.userId = userId
2954 
    args.itemId = itemId
1596 ankur.sing 2955 
    args.write(self._oprot)
2956 
    self._oprot.writeMessageEnd()
2957 
    self._oprot.trans.flush()
2958 
 
2981 rajveer 2959 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2961 
    if mtype == TMessageType.EXCEPTION:
2962 
      x = TApplicationException()
2963 
      x.read(self._iprot)
2964 
      self._iprot.readMessageEnd()
2965 
      raise x
2981 rajveer 2966 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2967 
    result.read(self._iprot)
2968 
    self._iprot.readMessageEnd()
3431 rajveer 2969 
    if result.scx is not None:
2981 rajveer 2970 
      raise result.scx
2971 
    return
1596 ankur.sing 2972 
 
2981 rajveer 2973 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2974 
    """
2981 rajveer 2975 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2976 
 
1673 ankur.sing 2977 
    Parameters:
2981 rajveer 2978 
     - userId
1673 ankur.sing 2979 
    """
2981 rajveer 2980 
    self.send_getBrowseHistoryItems(userId)
2981 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2982 
 
2981 rajveer 2983 
  def send_getBrowseHistoryItems(self, userId):
2984 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2985 
    args = getBrowseHistoryItems_args()
2986 
    args.userId = userId
1673 ankur.sing 2987 
    args.write(self._oprot)
2988 
    self._oprot.writeMessageEnd()
2989 
    self._oprot.trans.flush()
2990 
 
2981 rajveer 2991 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2993 
    if mtype == TMessageType.EXCEPTION:
2994 
      x = TApplicationException()
2995 
      x.read(self._iprot)
2996 
      self._iprot.readMessageEnd()
2997 
      raise x
2981 rajveer 2998 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2999 
    result.read(self._iprot)
3000 
    self._iprot.readMessageEnd()
3431 rajveer 3001 
    if result.success is not None:
1673 ankur.sing 3002 
      return result.success
3431 rajveer 3003 
    if result.scx is not None:
2981 rajveer 3004 
      raise result.scx
3005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 3006 
 
2981 rajveer 3007 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 3008 
    """
2981 rajveer 3009 
    add item to browse history for a user
3431 rajveer 3010 
 
2642 varun.gupt 3011 
    Parameters:
2981 rajveer 3012 
     - userId
3013 
     - itemId
2642 varun.gupt 3014 
    """
2981 rajveer 3015 
    self.send_updateBrowseHistory(userId, itemId)
3016 
    self.recv_updateBrowseHistory()
1673 ankur.sing 3017 
 
2981 rajveer 3018 
  def send_updateBrowseHistory(self, userId, itemId):
3019 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
3020 
    args = updateBrowseHistory_args()
3021 
    args.userId = userId
3022 
    args.itemId = itemId
2642 varun.gupt 3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
2981 rajveer 3027 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
2981 rajveer 3034 
    result = updateBrowseHistory_result()
2642 varun.gupt 3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3037 
    return
3038 
 
3385 varun.gupt 3039 
  def getCartsWithCouponCount(self, couponCode):
3040 
    """
3041 
    Returns count of Carts with given coupon applied
3431 rajveer 3042 
 
3385 varun.gupt 3043 
    Parameters:
3044 
     - couponCode
3045 
    """
3046 
    self.send_getCartsWithCouponCount(couponCode)
3047 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 3048 
 
3385 varun.gupt 3049 
  def send_getCartsWithCouponCount(self, couponCode):
3050 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
3051 
    args = getCartsWithCouponCount_args()
3052 
    args.couponCode = couponCode
3053 
    args.write(self._oprot)
3054 
    self._oprot.writeMessageEnd()
3055 
    self._oprot.trans.flush()
3056 
 
3057 
  def recv_getCartsWithCouponCount(self, ):
3058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3059 
    if mtype == TMessageType.EXCEPTION:
3060 
      x = TApplicationException()
3061 
      x.read(self._iprot)
3062 
      self._iprot.readMessageEnd()
3063 
      raise x
3064 
    result = getCartsWithCouponCount_result()
3065 
    result.read(self._iprot)
3066 
    self._iprot.readMessageEnd()
3431 rajveer 3067 
    if result.success is not None:
3385 varun.gupt 3068 
      return result.success
3069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
3070 
 
3499 mandeep.dh 3071 
  def increaseTrustLevel(self, userId, trustLevelDelta):
3072 
    """
3073 
    Updates COD trust level of a user
3385 varun.gupt 3074 
 
3499 mandeep.dh 3075 
    Parameters:
3076 
     - userId
3077 
     - trustLevelDelta
3078 
    """
3079 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
3080 
 
3081 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
3082 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
3083 
    args = increaseTrustLevel_args()
3084 
    args.userId = userId
3085 
    args.trustLevelDelta = trustLevelDelta
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
5407 amar.kumar 3089 
  def getTrustLevel(self, userId):
3090 
    """
3091 
    Get trust level of a user
3092 
 
3093 
    Parameters:
3094 
     - userId
3095 
    """
3096 
    self.send_getTrustLevel(userId)
3097 
    return self.recv_getTrustLevel()
3098 
 
3099 
  def send_getTrustLevel(self, userId):
3100 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3101 
    args = getTrustLevel_args()
3102 
    args.userId = userId
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_getTrustLevel(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = getTrustLevel_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3117 
    if result.success is not None:
3118 
      return result.success
3119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3120 
 
4668 varun.gupt 3121 
  def showCODOption(self, cartId, sourceId, pincode):
3122 
    """
3123 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3124 
 
4668 varun.gupt 3125 
    Parameters:
3126 
     - cartId
3127 
     - sourceId
3128 
     - pincode
3129 
    """
3130 
    self.send_showCODOption(cartId, sourceId, pincode)
3131 
    return self.recv_showCODOption()
3132 
 
3133 
  def send_showCODOption(self, cartId, sourceId, pincode):
3134 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3135 
    args = showCODOption_args()
3136 
    args.cartId = cartId
3137 
    args.sourceId = sourceId
3138 
    args.pincode = pincode
3139 
    args.write(self._oprot)
3140 
    self._oprot.writeMessageEnd()
3141 
    self._oprot.trans.flush()
3142 
 
3143 
  def recv_showCODOption(self, ):
3144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3145 
    if mtype == TMessageType.EXCEPTION:
3146 
      x = TApplicationException()
3147 
      x.read(self._iprot)
3148 
      self._iprot.readMessageEnd()
3149 
      raise x
3150 
    result = showCODOption_result()
3151 
    result.read(self._iprot)
3152 
    self._iprot.readMessageEnd()
3153 
    if result.success is not None:
3154 
      return result.success
3155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3156 
 
5623 anupam.sin 3157 
  def getUserEmails(self, startDate, endDate):
3158 
    """
3159 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3160 
 
5623 anupam.sin 3161 
    Parameters:
3162 
     - startDate
3163 
     - endDate
3164 
    """
3165 
    self.send_getUserEmails(startDate, endDate)
3166 
    return self.recv_getUserEmails()
3167 
 
3168 
  def send_getUserEmails(self, startDate, endDate):
3169 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3170 
    args = getUserEmails_args()
3171 
    args.startDate = startDate
3172 
    args.endDate = endDate
3173 
    args.write(self._oprot)
3174 
    self._oprot.writeMessageEnd()
3175 
    self._oprot.trans.flush()
3176 
 
3177 
  def recv_getUserEmails(self, ):
3178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3179 
    if mtype == TMessageType.EXCEPTION:
3180 
      x = TApplicationException()
3181 
      x.read(self._iprot)
3182 
      self._iprot.readMessageEnd()
3183 
      raise x
3184 
    result = getUserEmails_result()
3185 
    result.read(self._iprot)
3186 
    self._iprot.readMessageEnd()
3187 
    if result.success is not None:
3188 
      return result.success
3189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3190 
 
9299 kshitij.so 3191 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3192 
    """
3193 
    Mark a cart lineitem as insured. Returns true/false.
3194 
 
3195 
    Parameters:
3196 
     - itemId
3197 
     - cartId
3198 
     - toInsure
9299 kshitij.so 3199 
     - insurerType
6903 anupam.sin 3200 
    """
9299 kshitij.so 3201 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3202 
    return self.recv_insureItem()
3203 
 
9299 kshitij.so 3204 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3205 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3206 
    args = insureItem_args()
3207 
    args.itemId = itemId
3208 
    args.cartId = cartId
3209 
    args.toInsure = toInsure
9299 kshitij.so 3210 
    args.insurerType = insurerType
6903 anupam.sin 3211 
    args.write(self._oprot)
3212 
    self._oprot.writeMessageEnd()
3213 
    self._oprot.trans.flush()
3214 
 
3215 
  def recv_insureItem(self, ):
3216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3217 
    if mtype == TMessageType.EXCEPTION:
3218 
      x = TApplicationException()
3219 
      x.read(self._iprot)
3220 
      self._iprot.readMessageEnd()
3221 
      raise x
3222 
    result = insureItem_result()
3223 
    result.read(self._iprot)
3224 
    self._iprot.readMessageEnd()
3225 
    if result.success is not None:
3226 
      return result.success
3227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3228 
 
3229 
  def cancelInsurance(self, cartId):
3230 
    """
3231 
    Cancel insurance for all items in the cart
3232 
 
3233 
    Parameters:
3234 
     - cartId
3235 
    """
3236 
    self.send_cancelInsurance(cartId)
3237 
    return self.recv_cancelInsurance()
3238 
 
3239 
  def send_cancelInsurance(self, cartId):
3240 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3241 
    args = cancelInsurance_args()
3242 
    args.cartId = cartId
3243 
    args.write(self._oprot)
3244 
    self._oprot.writeMessageEnd()
3245 
    self._oprot.trans.flush()
3246 
 
3247 
  def recv_cancelInsurance(self, ):
3248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3249 
    if mtype == TMessageType.EXCEPTION:
3250 
      x = TApplicationException()
3251 
      x.read(self._iprot)
3252 
      self._iprot.readMessageEnd()
3253 
      raise x
3254 
    result = cancelInsurance_result()
3255 
    result.read(self._iprot)
3256 
    self._iprot.readMessageEnd()
3257 
    if result.success is not None:
3258 
      return result.success
3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3260 
 
3261 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3262 
    """
3263 
    Stores insurance specific details like date of birth and guardianName
3264 
 
3265 
    Parameters:
3266 
     - addressId
3267 
     - dob
3268 
     - guardianName
3269 
    """
3270 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3271 
    return self.recv_storeInsuranceSpecificDetails()
3272 
 
3273 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3274 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3275 
    args = storeInsuranceSpecificDetails_args()
3276 
    args.addressId = addressId
3277 
    args.dob = dob
3278 
    args.guardianName = guardianName
3279 
    args.write(self._oprot)
3280 
    self._oprot.writeMessageEnd()
3281 
    self._oprot.trans.flush()
3282 
 
3283 
  def recv_storeInsuranceSpecificDetails(self, ):
3284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3285 
    if mtype == TMessageType.EXCEPTION:
3286 
      x = TApplicationException()
3287 
      x.read(self._iprot)
3288 
      self._iprot.readMessageEnd()
3289 
      raise x
3290 
    result = storeInsuranceSpecificDetails_result()
3291 
    result.read(self._iprot)
3292 
    self._iprot.readMessageEnd()
3293 
    if result.success is not None:
3294 
      return result.success
3295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3296 
 
3297 
  def isInsuranceDetailPresent(self, addressId):
3298 
    """
3299 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3300 
 
3301 
    Parameters:
3302 
     - addressId
3303 
    """
3304 
    self.send_isInsuranceDetailPresent(addressId)
3305 
    return self.recv_isInsuranceDetailPresent()
3306 
 
3307 
  def send_isInsuranceDetailPresent(self, addressId):
3308 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3309 
    args = isInsuranceDetailPresent_args()
3310 
    args.addressId = addressId
3311 
    args.write(self._oprot)
3312 
    self._oprot.writeMessageEnd()
3313 
    self._oprot.trans.flush()
3314 
 
3315 
  def recv_isInsuranceDetailPresent(self, ):
3316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3317 
    if mtype == TMessageType.EXCEPTION:
3318 
      x = TApplicationException()
3319 
      x.read(self._iprot)
3320 
      self._iprot.readMessageEnd()
3321 
      raise x
3322 
    result = isInsuranceDetailPresent_result()
3323 
    result.read(self._iprot)
3324 
    self._iprot.readMessageEnd()
3325 
    if result.success is not None:
3326 
      return result.success
3327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3328 
 
9791 rajveer 3329 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3330 
    """
9791 rajveer 3331 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3332 
 
6821 amar.kumar 3333 
    Parameters:
3334 
     - startDate
3335 
     - endDate
3336 
    """
9791 rajveer 3337 
    self.send_getProductsAddedToCart(startDate, endDate)
3338 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3339 
 
9791 rajveer 3340 
  def send_getProductsAddedToCart(self, startDate, endDate):
3341 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3342 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3343 
    args.startDate = startDate
3344 
    args.endDate = endDate
3345 
    args.write(self._oprot)
3346 
    self._oprot.writeMessageEnd()
3347 
    self._oprot.trans.flush()
3348 
 
9791 rajveer 3349 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3351 
    if mtype == TMessageType.EXCEPTION:
3352 
      x = TApplicationException()
3353 
      x.read(self._iprot)
3354 
      self._iprot.readMessageEnd()
3355 
      raise x
9791 rajveer 3356 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3357 
    result.read(self._iprot)
3358 
    self._iprot.readMessageEnd()
3359 
    if result.success is not None:
3360 
      return result.success
9791 rajveer 3361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3362 
 
11980 amit.gupta 3363 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3364 
    """
3365 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3366 
 
11592 amit.gupta 3367 
    Parameters:
3368 
     - cartId
3369 
     - sourceId
11980 amit.gupta 3370 
     - dealerCoupon
11592 amit.gupta 3371 
    """
11980 amit.gupta 3372 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3373 
    return self.recv_validateCartPlus()
3374 
 
11980 amit.gupta 3375 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3376 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3377 
    args = validateCartPlus_args()
3378 
    args.cartId = cartId
3379 
    args.sourceId = sourceId
11980 amit.gupta 3380 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3381 
    args.write(self._oprot)
3382 
    self._oprot.writeMessageEnd()
3383 
    self._oprot.trans.flush()
3384 
 
3385 
  def recv_validateCartPlus(self, ):
3386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3387 
    if mtype == TMessageType.EXCEPTION:
3388 
      x = TApplicationException()
3389 
      x.read(self._iprot)
3390 
      self._iprot.readMessageEnd()
3391 
      raise x
3392 
    result = validateCartPlus_result()
3393 
    result.read(self._iprot)
3394 
    self._iprot.readMessageEnd()
3395 
    if result.success is not None:
3396 
      return result.success
3397 
    if result.scex is not None:
3398 
      raise result.scex
3399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3400 
 
11679 vikram.rag 3401 
  def isPrivateDealUser(self, userId):
3402 
    """
3403 
    Parameters:
3404 
     - userId
3405 
    """
3406 
    self.send_isPrivateDealUser(userId)
3407 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3408 
 
11679 vikram.rag 3409 
  def send_isPrivateDealUser(self, userId):
3410 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3411 
    args = isPrivateDealUser_args()
3412 
    args.userId = userId
3413 
    args.write(self._oprot)
3414 
    self._oprot.writeMessageEnd()
3415 
    self._oprot.trans.flush()
3416 
 
3417 
  def recv_isPrivateDealUser(self, ):
3418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3419 
    if mtype == TMessageType.EXCEPTION:
3420 
      x = TApplicationException()
3421 
      x.read(self._iprot)
3422 
      self._iprot.readMessageEnd()
3423 
      raise x
3424 
    result = isPrivateDealUser_result()
3425 
    result.read(self._iprot)
3426 
    self._iprot.readMessageEnd()
3427 
    if result.success is not None:
3428 
      return result.success
3429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3430 
 
11890 kshitij.so 3431 
  def addPrivateDealUser(self, userId):
3432 
    """
3433 
    Parameters:
3434 
     - userId
3435 
    """
3436 
    self.send_addPrivateDealUser(userId)
3437 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3438 
 
11890 kshitij.so 3439 
  def send_addPrivateDealUser(self, userId):
3440 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3441 
    args = addPrivateDealUser_args()
3442 
    args.userId = userId
3443 
    args.write(self._oprot)
3444 
    self._oprot.writeMessageEnd()
3445 
    self._oprot.trans.flush()
3446 
 
3447 
  def recv_addPrivateDealUser(self, ):
3448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3449 
    if mtype == TMessageType.EXCEPTION:
3450 
      x = TApplicationException()
3451 
      x.read(self._iprot)
3452 
      self._iprot.readMessageEnd()
3453 
      raise x
3454 
    result = addPrivateDealUser_result()
3455 
    result.read(self._iprot)
3456 
    self._iprot.readMessageEnd()
3457 
    if result.success is not None:
3458 
      return result.success
3459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3460 
 
3461 
  def changePrivateDealUserStatus(self, userId, isActive):
3462 
    """
3463 
    Parameters:
3464 
     - userId
3465 
     - isActive
3466 
    """
3467 
    self.send_changePrivateDealUserStatus(userId, isActive)
3468 
    return self.recv_changePrivateDealUserStatus()
3469 
 
3470 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3471 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3472 
    args = changePrivateDealUserStatus_args()
3473 
    args.userId = userId
3474 
    args.isActive = isActive
3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_changePrivateDealUserStatus(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = changePrivateDealUserStatus_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3489 
    if result.success is not None:
3490 
      return result.success
3491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3492 
 
3493 
  def getPrivateDealUser(self, userId):
3494 
    """
3495 
    Parameters:
3496 
     - userId
3497 
    """
3498 
    self.send_getPrivateDealUser(userId)
3499 
    return self.recv_getPrivateDealUser()
3500 
 
3501 
  def send_getPrivateDealUser(self, userId):
3502 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3503 
    args = getPrivateDealUser_args()
3504 
    args.userId = userId
3505 
    args.write(self._oprot)
3506 
    self._oprot.writeMessageEnd()
3507 
    self._oprot.trans.flush()
3508 
 
3509 
  def recv_getPrivateDealUser(self, ):
3510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3511 
    if mtype == TMessageType.EXCEPTION:
3512 
      x = TApplicationException()
3513 
      x.read(self._iprot)
3514 
      self._iprot.readMessageEnd()
3515 
      raise x
3516 
    result = getPrivateDealUser_result()
3517 
    result.read(self._iprot)
3518 
    self._iprot.readMessageEnd()
3519 
    if result.success is not None:
3520 
      return result.success
3521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3522 
 
12696 amit.gupta 3523 
  def registerCounter(self, counter, userId):
3524 
    """
3525 
    Parameters:
3526 
     - counter
3527 
     - userId
3528 
    """
3529 
    self.send_registerCounter(counter, userId)
3530 
    return self.recv_registerCounter()
11890 kshitij.so 3531 
 
12696 amit.gupta 3532 
  def send_registerCounter(self, counter, userId):
3533 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3534 
    args = registerCounter_args()
3535 
    args.counter = counter
3536 
    args.userId = userId
3537 
    args.write(self._oprot)
3538 
    self._oprot.writeMessageEnd()
3539 
    self._oprot.trans.flush()
3540 
 
3541 
  def recv_registerCounter(self, ):
3542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3543 
    if mtype == TMessageType.EXCEPTION:
3544 
      x = TApplicationException()
3545 
      x.read(self._iprot)
3546 
      self._iprot.readMessageEnd()
3547 
      raise x
3548 
    result = registerCounter_result()
3549 
    result.read(self._iprot)
3550 
    self._iprot.readMessageEnd()
3551 
    if result.success is not None:
3552 
      return result.success
3553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3554 
 
12722 amit.gupta 3555 
  def searchCounter(self, type1, searchString):
3556 
    """
3557 
    Parameters:
3558 
     - type1
3559 
     - searchString
3560 
    """
3561 
    self.send_searchCounter(type1, searchString)
3562 
    return self.recv_searchCounter()
12696 amit.gupta 3563 
 
12722 amit.gupta 3564 
  def send_searchCounter(self, type1, searchString):
3565 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3566 
    args = searchCounter_args()
3567 
    args.type1 = type1
3568 
    args.searchString = searchString
3569 
    args.write(self._oprot)
3570 
    self._oprot.writeMessageEnd()
3571 
    self._oprot.trans.flush()
3572 
 
3573 
  def recv_searchCounter(self, ):
3574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3575 
    if mtype == TMessageType.EXCEPTION:
3576 
      x = TApplicationException()
3577 
      x.read(self._iprot)
3578 
      self._iprot.readMessageEnd()
3579 
      raise x
3580 
    result = searchCounter_result()
3581 
    result.read(self._iprot)
3582 
    self._iprot.readMessageEnd()
3583 
    if result.success is not None:
3584 
      return result.success
3585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3586 
 
18977 amit.gupta 3587 
  def getCounterByUserId(self, userId):
3588 
    """
3589 
    Parameters:
3590 
     - userId
3591 
    """
3592 
    self.send_getCounterByUserId(userId)
3593 
    return self.recv_getCounterByUserId()
3594 
 
3595 
  def send_getCounterByUserId(self, userId):
3596 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3597 
    args = getCounterByUserId_args()
3598 
    args.userId = userId
3599 
    args.write(self._oprot)
3600 
    self._oprot.writeMessageEnd()
3601 
    self._oprot.trans.flush()
3602 
 
3603 
  def recv_getCounterByUserId(self, ):
3604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3605 
    if mtype == TMessageType.EXCEPTION:
3606 
      x = TApplicationException()
3607 
      x.read(self._iprot)
3608 
      self._iprot.readMessageEnd()
3609 
      raise x
3610 
    result = getCounterByUserId_result()
3611 
    result.read(self._iprot)
3612 
    self._iprot.readMessageEnd()
3613 
    if result.success is not None:
3614 
      return result.success
3615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3616 
 
12722 amit.gupta 3617 
  def getAllUsersByCounter(self, counterId):
3618 
    """
3619 
    Parameters:
3620 
     - counterId
3621 
    """
3622 
    self.send_getAllUsersByCounter(counterId)
3623 
    return self.recv_getAllUsersByCounter()
3624 
 
3625 
  def send_getAllUsersByCounter(self, counterId):
3626 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3627 
    args = getAllUsersByCounter_args()
3628 
    args.counterId = counterId
3629 
    args.write(self._oprot)
3630 
    self._oprot.writeMessageEnd()
3631 
    self._oprot.trans.flush()
3632 
 
3633 
  def recv_getAllUsersByCounter(self, ):
3634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3635 
    if mtype == TMessageType.EXCEPTION:
3636 
      x = TApplicationException()
3637 
      x.read(self._iprot)
3638 
      self._iprot.readMessageEnd()
3639 
      raise x
3640 
    result = getAllUsersByCounter_result()
3641 
    result.read(self._iprot)
3642 
    self._iprot.readMessageEnd()
3643 
    if result.success is not None:
3644 
      return result.success
3645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3646 
 
15251 manish.sha 3647 
  def getActiveAccessTokenForUser(self, userId, source):
3648 
    """
3649 
    Parameters:
3650 
     - userId
3651 
     - source
3652 
    """
3653 
    self.send_getActiveAccessTokenForUser(userId, source)
3654 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3655 
 
15251 manish.sha 3656 
  def send_getActiveAccessTokenForUser(self, userId, source):
3657 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3658 
    args = getActiveAccessTokenForUser_args()
3659 
    args.userId = userId
3660 
    args.source = source
3661 
    args.write(self._oprot)
3662 
    self._oprot.writeMessageEnd()
3663 
    self._oprot.trans.flush()
3664 
 
3665 
  def recv_getActiveAccessTokenForUser(self, ):
3666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3667 
    if mtype == TMessageType.EXCEPTION:
3668 
      x = TApplicationException()
3669 
      x.read(self._iprot)
3670 
      self._iprot.readMessageEnd()
3671 
      raise x
3672 
    result = getActiveAccessTokenForUser_result()
3673 
    result.read(self._iprot)
3674 
    self._iprot.readMessageEnd()
3675 
    if result.success is not None:
3676 
      return result.success
3677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3678 
 
3679 
  def validateAccessToken(self, accessToken):
3680 
    """
3681 
    Parameters:
3682 
     - accessToken
3683 
    """
3684 
    self.send_validateAccessToken(accessToken)
3685 
    return self.recv_validateAccessToken()
3686 
 
3687 
  def send_validateAccessToken(self, accessToken):
3688 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3689 
    args = validateAccessToken_args()
3690 
    args.accessToken = accessToken
3691 
    args.write(self._oprot)
3692 
    self._oprot.writeMessageEnd()
3693 
    self._oprot.trans.flush()
3694 
 
3695 
  def recv_validateAccessToken(self, ):
3696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3697 
    if mtype == TMessageType.EXCEPTION:
3698 
      x = TApplicationException()
3699 
      x.read(self._iprot)
3700 
      self._iprot.readMessageEnd()
3701 
      raise x
3702 
    result = validateAccessToken_result()
3703 
    result.read(self._iprot)
3704 
    self._iprot.readMessageEnd()
3705 
    if result.success is not None:
3706 
      return result.success
3707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3708 
 
17782 amit.gupta 3709 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3710 
    """
3711 
    Parameters:
3712 
     - cartId
3713 
     - itemQty
3714 
     - couponCode
3715 
    """
3716 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3717 
    return self.recv_addItemsToCart()
15251 manish.sha 3718 
 
17782 amit.gupta 3719 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3720 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3721 
    args = addItemsToCart_args()
3722 
    args.cartId = cartId
3723 
    args.itemQty = itemQty
3724 
    args.couponCode = couponCode
3725 
    args.write(self._oprot)
3726 
    self._oprot.writeMessageEnd()
3727 
    self._oprot.trans.flush()
3728 
 
3729 
  def recv_addItemsToCart(self, ):
3730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3731 
    if mtype == TMessageType.EXCEPTION:
3732 
      x = TApplicationException()
3733 
      x.read(self._iprot)
3734 
      self._iprot.readMessageEnd()
3735 
      raise x
3736 
    result = addItemsToCart_result()
3737 
    result.read(self._iprot)
3738 
    self._iprot.readMessageEnd()
3739 
    if result.success is not None:
3740 
      return result.success
3741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3742 
 
3743 
  def validateCartNew(self, cartId, pinCode, sourceId):
3744 
    """
3745 
    Parameters:
3746 
     - cartId
3747 
     - pinCode
3748 
     - sourceId
3749 
    """
3750 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3751 
    return self.recv_validateCartNew()
3752 
 
3753 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3754 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3755 
    args = validateCartNew_args()
3756 
    args.cartId = cartId
3757 
    args.pinCode = pinCode
3758 
    args.sourceId = sourceId
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_validateCartNew(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = validateCartNew_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3776 
 
18644 manish.sha 3777 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3778 
    """
3779 
    Parameters:
3780 
     - userId
3781 
    """
18644 manish.sha 3782 
    self.send_isAddressEditableForCounter(userId)
3783 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3784 
 
18644 manish.sha 3785 
  def send_isAddressEditableForCounter(self, userId):
3786 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3787 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3788 
    args.userId = userId
3789 
    args.write(self._oprot)
3790 
    self._oprot.writeMessageEnd()
3791 
    self._oprot.trans.flush()
3792 
 
18644 manish.sha 3793 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3795 
    if mtype == TMessageType.EXCEPTION:
3796 
      x = TApplicationException()
3797 
      x.read(self._iprot)
3798 
      self._iprot.readMessageEnd()
3799 
      raise x
18644 manish.sha 3800 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3801 
    result.read(self._iprot)
3802 
    self._iprot.readMessageEnd()
3803 
    if result.success is not None:
3804 
      return result.success
18644 manish.sha 3805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3806 
 
3807 
  def getBillingAddressForUser(self, userId):
3808 
    """
3809 
    Parameters:
3810 
     - userId
3811 
    """
3812 
    self.send_getBillingAddressForUser(userId)
3813 
    return self.recv_getBillingAddressForUser()
3814 
 
3815 
  def send_getBillingAddressForUser(self, userId):
3816 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3817 
    args = getBillingAddressForUser_args()
3818 
    args.userId = userId
3819 
    args.write(self._oprot)
3820 
    self._oprot.writeMessageEnd()
3821 
    self._oprot.trans.flush()
3822 
 
3823 
  def recv_getBillingAddressForUser(self, ):
3824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3825 
    if mtype == TMessageType.EXCEPTION:
3826 
      x = TApplicationException()
3827 
      x.read(self._iprot)
3828 
      self._iprot.readMessageEnd()
3829 
      raise x
3830 
    result = getBillingAddressForUser_result()
3831 
    result.read(self._iprot)
3832 
    self._iprot.readMessageEnd()
3833 
    if result.success is not None:
3834 
      return result.success
3835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3836 
 
18590 manish.sha 3837 
  def isCreditorAssigned(self, userId):
3838 
    """
3839 
    Parameters:
3840 
     - userId
3841 
    """
3842 
    self.send_isCreditorAssigned(userId)
3843 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3844 
 
18590 manish.sha 3845 
  def send_isCreditorAssigned(self, userId):
3846 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3847 
    args = isCreditorAssigned_args()
3848 
    args.userId = userId
3849 
    args.write(self._oprot)
3850 
    self._oprot.writeMessageEnd()
3851 
    self._oprot.trans.flush()
3852 
 
3853 
  def recv_isCreditorAssigned(self, ):
3854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3855 
    if mtype == TMessageType.EXCEPTION:
3856 
      x = TApplicationException()
3857 
      x.read(self._iprot)
3858 
      self._iprot.readMessageEnd()
3859 
      raise x
3860 
    result = isCreditorAssigned_result()
3861 
    result.read(self._iprot)
3862 
    self._iprot.readMessageEnd()
3863 
    if result.success is not None:
3864 
      return result.success
3865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3866 
 
18735 manish.sha 3867 
  def isTaxInvoiceEnabledUser(self, userId):
3868 
    """
3869 
    Parameters:
3870 
     - userId
3871 
    """
3872 
    self.send_isTaxInvoiceEnabledUser(userId)
3873 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3874 
 
18735 manish.sha 3875 
  def send_isTaxInvoiceEnabledUser(self, userId):
3876 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3877 
    args = isTaxInvoiceEnabledUser_args()
3878 
    args.userId = userId
3879 
    args.write(self._oprot)
3880 
    self._oprot.writeMessageEnd()
3881 
    self._oprot.trans.flush()
3882 
 
3883 
  def recv_isTaxInvoiceEnabledUser(self, ):
3884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3885 
    if mtype == TMessageType.EXCEPTION:
3886 
      x = TApplicationException()
3887 
      x.read(self._iprot)
3888 
      self._iprot.readMessageEnd()
3889 
      raise x
3890 
    result = isTaxInvoiceEnabledUser_result()
3891 
    result.read(self._iprot)
3892 
    self._iprot.readMessageEnd()
3893 
    if result.success is not None:
3894 
      return result.success
3895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3896 
 
19182 amit.gupta 3897 
  def taxInvoiceAvailable(self, addressId):
3898 
    """
3899 
    Parameters:
3900 
     - addressId
3901 
    """
3902 
    self.send_taxInvoiceAvailable(addressId)
3903 
    return self.recv_taxInvoiceAvailable()
3904 
 
3905 
  def send_taxInvoiceAvailable(self, addressId):
3906 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3907 
    args = taxInvoiceAvailable_args()
3908 
    args.addressId = addressId
3909 
    args.write(self._oprot)
3910 
    self._oprot.writeMessageEnd()
3911 
    self._oprot.trans.flush()
3912 
 
3913 
  def recv_taxInvoiceAvailable(self, ):
3914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3915 
    if mtype == TMessageType.EXCEPTION:
3916 
      x = TApplicationException()
3917 
      x.read(self._iprot)
3918 
      self._iprot.readMessageEnd()
3919 
      raise x
3920 
    result = taxInvoiceAvailable_result()
3921 
    result.read(self._iprot)
3922 
    self._iprot.readMessageEnd()
3923 
    if result.success is not None:
3924 
      return result.success
3925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3926 
 
18764 kshitij.so 3927 
  def getCartByValue(self, cartIds):
3928 
    """
3929 
    Parameters:
3930 
     - cartIds
3931 
    """
3932 
    self.send_getCartByValue(cartIds)
3933 
    return self.recv_getCartByValue()
18735 manish.sha 3934 
 
18764 kshitij.so 3935 
  def send_getCartByValue(self, cartIds):
3936 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3937 
    args = getCartByValue_args()
3938 
    args.cartIds = cartIds
3939 
    args.write(self._oprot)
3940 
    self._oprot.writeMessageEnd()
3941 
    self._oprot.trans.flush()
3942 
 
3943 
  def recv_getCartByValue(self, ):
3944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3945 
    if mtype == TMessageType.EXCEPTION:
3946 
      x = TApplicationException()
3947 
      x.read(self._iprot)
3948 
      self._iprot.readMessageEnd()
3949 
      raise x
3950 
    result = getCartByValue_result()
3951 
    result.read(self._iprot)
3952 
    self._iprot.readMessageEnd()
3953 
    if result.success is not None:
3954 
      return result.success
3955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3956 
 
19889 manas 3957 
  def getCounterName(self, userIds):
3958 
    """
3959 
    Parameters:
3960 
     - userIds
3961 
    """
3962 
    self.send_getCounterName(userIds)
3963 
    return self.recv_getCounterName()
18764 kshitij.so 3964 
 
19889 manas 3965 
  def send_getCounterName(self, userIds):
3966 
    self._oprot.writeMessageBegin('getCounterName', TMessageType.CALL, self._seqid)
3967 
    args = getCounterName_args()
3968 
    args.userIds = userIds
3969 
    args.write(self._oprot)
3970 
    self._oprot.writeMessageEnd()
3971 
    self._oprot.trans.flush()
3972 
 
3973 
  def recv_getCounterName(self, ):
3974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3975 
    if mtype == TMessageType.EXCEPTION:
3976 
      x = TApplicationException()
3977 
      x.read(self._iprot)
3978 
      self._iprot.readMessageEnd()
3979 
      raise x
3980 
    result = getCounterName_result()
3981 
    result.read(self._iprot)
3982 
    self._iprot.readMessageEnd()
3983 
    if result.success is not None:
3984 
      return result.success
3985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterName failed: unknown result");
3986 
 
20873 kshitij.so 3987 
  def setWalletAmountInCart(self, cartId, wallet_amount):
3988 
    """
3989 
    Parameters:
3990 
     - cartId
3991 
     - wallet_amount
3992 
    """
3993 
    self.send_setWalletAmountInCart(cartId, wallet_amount)
3994 
    return self.recv_setWalletAmountInCart()
19889 manas 3995 
 
20873 kshitij.so 3996 
  def send_setWalletAmountInCart(self, cartId, wallet_amount):
3997 
    self._oprot.writeMessageBegin('setWalletAmountInCart', TMessageType.CALL, self._seqid)
3998 
    args = setWalletAmountInCart_args()
3999 
    args.cartId = cartId
4000 
    args.wallet_amount = wallet_amount
4001 
    args.write(self._oprot)
4002 
    self._oprot.writeMessageEnd()
4003 
    self._oprot.trans.flush()
4004 
 
4005 
  def recv_setWalletAmountInCart(self, ):
4006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4007 
    if mtype == TMessageType.EXCEPTION:
4008 
      x = TApplicationException()
4009 
      x.read(self._iprot)
4010 
      self._iprot.readMessageEnd()
4011 
      raise x
4012 
    result = setWalletAmountInCart_result()
4013 
    result.read(self._iprot)
4014 
    self._iprot.readMessageEnd()
4015 
    if result.success is not None:
4016 
      return result.success
4017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setWalletAmountInCart failed: unknown result");
4018 
 
4019 
 
3376 rajveer 4020 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4021 
  def __init__(self, handler):
3376 rajveer 4022 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 4023 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
4024 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 4025 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 4026 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 4027 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 4028 
    self._processMap["createUser"] = Processor.process_createUser
4029 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 4030 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 4031 
    self._processMap["userExists"] = Processor.process_userExists
4032 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
4033 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
22358 ashik.ali 4034 
    self._processMap["updateAddress"] = Processor.process_updateAddress
22364 ashik.ali 4035 
    self._processMap["updateCounter"] = Processor.process_updateCounter
94 ashish 4036 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
4037 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 4038 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 4039 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 4040 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 4041 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 4042 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 4043 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 4044 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 4045 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 4046 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
4047 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
4048 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 4049 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 4050 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 4051 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 4052 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
4053 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
4054 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
4055 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
4056 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 4057 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 4058 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
4059 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
4060 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 4061 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 4062 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
4063 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 4064 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
4065 
    self._processMap["getCart"] = Processor.process_getCart
4066 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
4067 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
4068 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
4069 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 4070 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 4071 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
4072 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 4073 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
4074 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 4075 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 4076 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 4077 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 4078 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 4079 
    self._processMap["checkOut"] = Processor.process_checkOut
4080 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 4081 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 4082 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 4083 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
4084 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
4085 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
4086 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
4087 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 4088 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 4089 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 4090 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 4091 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 4092 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 4093 
    self._processMap["insureItem"] = Processor.process_insureItem
4094 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
4095 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
4096 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 4097 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 4098 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 4099 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 4100 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
4101 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
4102 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 4103 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 4104 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 4105 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 4106 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 4107 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
4108 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 4109 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
4110 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 4111 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 4112 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 4113 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 4114 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 4115 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 4116 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
19889 manas 4117 
    self._processMap["getCounterName"] = Processor.process_getCounterName
20873 kshitij.so 4118 
    self._processMap["setWalletAmountInCart"] = Processor.process_setWalletAmountInCart
94 ashish 4119 
 
4120 
  def process(self, iprot, oprot):
4121 
    (name, type, seqid) = iprot.readMessageBegin()
4122 
    if name not in self._processMap:
4123 
      iprot.skip(TType.STRUCT)
4124 
      iprot.readMessageEnd()
4125 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4126 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4127 
      x.write(oprot)
4128 
      oprot.writeMessageEnd()
4129 
      oprot.trans.flush()
4130 
      return
4131 
    else:
4132 
      self._processMap[name](self, seqid, iprot, oprot)
4133 
    return True
4134 
 
559 chandransh 4135 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
4136 
    args = createAnonymousUser_args()
94 ashish 4137 
    args.read(iprot)
4138 
    iprot.readMessageEnd()
559 chandransh 4139 
    result = createAnonymousUser_result()
94 ashish 4140 
    try:
559 chandransh 4141 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
4142 
    except UserContextException, ucex:
4143 
      result.ucex = ucex
4144 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 4145 
    result.write(oprot)
4146 
    oprot.writeMessageEnd()
4147 
    oprot.trans.flush()
4148 
 
559 chandransh 4149 
  def process_getUserById(self, seqid, iprot, oprot):
4150 
    args = getUserById_args()
94 ashish 4151 
    args.read(iprot)
4152 
    iprot.readMessageEnd()
559 chandransh 4153 
    result = getUserById_result()
94 ashish 4154 
    try:
559 chandransh 4155 
      result.success = self._handler.getUserById(args.userId)
4156 
    except UserContextException, ucex:
4157 
      result.ucex = ucex
4158 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 4159 
    result.write(oprot)
4160 
    oprot.writeMessageEnd()
4161 
    oprot.trans.flush()
4162 
 
5326 rajveer 4163 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4164 
    args = getUserByCartId_args()
4165 
    args.read(iprot)
4166 
    iprot.readMessageEnd()
4167 
    result = getUserByCartId_result()
4168 
    try:
4169 
      result.success = self._handler.getUserByCartId(args.cartId)
4170 
    except UserContextException, ucex:
4171 
      result.ucex = ucex
4172 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4173 
    result.write(oprot)
4174 
    oprot.writeMessageEnd()
4175 
    oprot.trans.flush()
4176 
 
1491 vikas 4177 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4178 
    args = getUserByEmail_args()
4179 
    args.read(iprot)
4180 
    iprot.readMessageEnd()
4181 
    result = getUserByEmail_result()
4182 
    try:
4183 
      result.success = self._handler.getUserByEmail(args.email)
4184 
    except UserContextException, ucex:
4185 
      result.ucex = ucex
4186 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4187 
    result.write(oprot)
4188 
    oprot.writeMessageEnd()
4189 
    oprot.trans.flush()
4190 
 
3032 mandeep.dh 4191 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4192 
    args = getUserByMobileNumber_args()
4193 
    args.read(iprot)
4194 
    iprot.readMessageEnd()
4195 
    result = getUserByMobileNumber_result()
4196 
    try:
4197 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4198 
    except UserContextException, ucex:
4199 
      result.ucex = ucex
4200 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4201 
    result.write(oprot)
4202 
    oprot.writeMessageEnd()
4203 
    oprot.trans.flush()
4204 
 
559 chandransh 4205 
  def process_createUser(self, seqid, iprot, oprot):
4206 
    args = createUser_args()
94 ashish 4207 
    args.read(iprot)
4208 
    iprot.readMessageEnd()
559 chandransh 4209 
    result = createUser_result()
94 ashish 4210 
    try:
559 chandransh 4211 
      result.success = self._handler.createUser(args.user)
4212 
    except UserContextException, ucex:
4213 
      result.ucex = ucex
4214 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4215 
    result.write(oprot)
4216 
    oprot.writeMessageEnd()
4217 
    oprot.trans.flush()
4218 
 
559 chandransh 4219 
  def process_updateUser(self, seqid, iprot, oprot):
4220 
    args = updateUser_args()
94 ashish 4221 
    args.read(iprot)
4222 
    iprot.readMessageEnd()
559 chandransh 4223 
    result = updateUser_result()
94 ashish 4224 
    try:
559 chandransh 4225 
      result.success = self._handler.updateUser(args.user)
4226 
    except UserContextException, ucex:
4227 
      result.ucex = ucex
4228 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4229 
    result.write(oprot)
4230 
    oprot.writeMessageEnd()
4231 
    oprot.trans.flush()
4232 
 
122 ashish 4233 
  def process_authenticateUser(self, seqid, iprot, oprot):
4234 
    args = authenticateUser_args()
4235 
    args.read(iprot)
4236 
    iprot.readMessageEnd()
4237 
    result = authenticateUser_result()
4238 
    try:
559 chandransh 4239 
      result.success = self._handler.authenticateUser(args.email, args.password)
4240 
    except AuthenticationException, auex:
4241 
      result.auex = auex
122 ashish 4242 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4243 
    result.write(oprot)
4244 
    oprot.writeMessageEnd()
4245 
    oprot.trans.flush()
4246 
 
94 ashish 4247 
  def process_userExists(self, seqid, iprot, oprot):
4248 
    args = userExists_args()
4249 
    args.read(iprot)
4250 
    iprot.readMessageEnd()
4251 
    result = userExists_result()
4252 
    try:
4253 
      result.success = self._handler.userExists(args.email)
4254 
    except UserContextException, ucx:
4255 
      result.ucx = ucx
4256 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4257 
    result.write(oprot)
4258 
    oprot.writeMessageEnd()
4259 
    oprot.trans.flush()
4260 
 
4261 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4262 
    args = addAddressForUser_args()
4263 
    args.read(iprot)
4264 
    iprot.readMessageEnd()
4265 
    result = addAddressForUser_result()
4266 
    try:
567 rajveer 4267 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4268 
    except UserContextException, ucx:
4269 
      result.ucx = ucx
4270 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4271 
    result.write(oprot)
4272 
    oprot.writeMessageEnd()
4273 
    oprot.trans.flush()
4274 
 
4275 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4276 
    args = removeAddressForUser_args()
4277 
    args.read(iprot)
4278 
    iprot.readMessageEnd()
4279 
    result = removeAddressForUser_result()
4280 
    try:
4281 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4282 
    except UserContextException, ucx:
4283 
      result.ucx = ucx
4284 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4285 
    result.write(oprot)
4286 
    oprot.writeMessageEnd()
4287 
    oprot.trans.flush()
4288 
 
22358 ashik.ali 4289 
  def process_updateAddress(self, seqid, iprot, oprot):
4290 
    args = updateAddress_args()
4291 
    args.read(iprot)
4292 
    iprot.readMessageEnd()
4293 
    result = updateAddress_result()
4294 
    try:
4295 
      result.success = self._handler.updateAddress(args.address)
4296 
    except UserContextException, ucx:
4297 
      result.ucx = ucx
4298 
    oprot.writeMessageBegin("updateAddress", TMessageType.REPLY, seqid)
4299 
    result.write(oprot)
4300 
    oprot.writeMessageEnd()
4301 
    oprot.trans.flush()
4302 
 
22364 ashik.ali 4303 
  def process_updateCounter(self, seqid, iprot, oprot):
4304 
    args = updateCounter_args()
4305 
    args.read(iprot)
4306 
    iprot.readMessageEnd()
4307 
    result = updateCounter_result()
4308 
    try:
4309 
      result.success = self._handler.updateCounter(args.counter)
4310 
    except UserContextException, ucx:
4311 
      result.ucx = ucx
4312 
    oprot.writeMessageBegin("updateCounter", TMessageType.REPLY, seqid)
4313 
    result.write(oprot)
4314 
    oprot.writeMessageEnd()
4315 
    oprot.trans.flush()
4316 
 
94 ashish 4317 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4318 
    args = setUserAsLoggedIn_args()
4319 
    args.read(iprot)
4320 
    iprot.readMessageEnd()
4321 
    result = setUserAsLoggedIn_result()
4322 
    try:
4323 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4324 
    except UserContextException, ucx:
4325 
      result.ucx = ucx
4326 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
4330 
 
4331 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4332 
    args = setUserAsLoggedOut_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = setUserAsLoggedOut_result()
4336 
    try:
4337 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4338 
    except UserContextException, ucx:
4339 
      result.ucx = ucx
4340 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4341 
    result.write(oprot)
4342 
    oprot.writeMessageEnd()
4343 
    oprot.trans.flush()
4344 
 
504 rajveer 4345 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4346 
    args = setDefaultAddress_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = setDefaultAddress_result()
4350 
    try:
4351 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4352 
    except UserContextException, ucx:
4353 
      result.ucx = ucx
4354 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4355 
    result.write(oprot)
4356 
    oprot.writeMessageEnd()
4357 
    oprot.trans.flush()
4358 
 
94 ashish 4359 
  def process_updatePassword(self, seqid, iprot, oprot):
4360 
    args = updatePassword_args()
4361 
    args.read(iprot)
4362 
    iprot.readMessageEnd()
4363 
    result = updatePassword_result()
4364 
    try:
594 rajveer 4365 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4366 
    except UserContextException, ucx:
4367 
      result.ucx = ucx
4368 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4369 
    result.write(oprot)
4370 
    oprot.writeMessageEnd()
4371 
    oprot.trans.flush()
4372 
 
581 rajveer 4373 
  def process_forgotPassword(self, seqid, iprot, oprot):
4374 
    args = forgotPassword_args()
4375 
    args.read(iprot)
4376 
    iprot.readMessageEnd()
4377 
    result = forgotPassword_result()
4378 
    try:
884 rajveer 4379 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4380 
    except UserContextException, ucx:
4381 
      result.ucx = ucx
4382 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4383 
    result.write(oprot)
4384 
    oprot.writeMessageEnd()
4385 
    oprot.trans.flush()
4386 
 
594 rajveer 4387 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4388 
    args = getAllAddressesForUser_args()
4389 
    args.read(iprot)
4390 
    iprot.readMessageEnd()
4391 
    result = getAllAddressesForUser_result()
4392 
    try:
4393 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4394 
    except UserContextException, ucx:
4395 
      result.ucx = ucx
4396 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4397 
    result.write(oprot)
4398 
    oprot.writeMessageEnd()
4399 
    oprot.trans.flush()
4400 
 
1894 vikas 4401 
  def process_getAddressById(self, seqid, iprot, oprot):
4402 
    args = getAddressById_args()
4403 
    args.read(iprot)
4404 
    iprot.readMessageEnd()
4405 
    result = getAddressById_result()
4406 
    try:
4407 
      result.success = self._handler.getAddressById(args.addressId)
4408 
    except UserContextException, ucx:
4409 
      result.ucx = ucx
4410 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4411 
    result.write(oprot)
4412 
    oprot.writeMessageEnd()
4413 
    oprot.trans.flush()
4414 
 
594 rajveer 4415 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4416 
    args = getDefaultAddressId_args()
4417 
    args.read(iprot)
4418 
    iprot.readMessageEnd()
4419 
    result = getDefaultAddressId_result()
4420 
    try:
4421 
      result.success = self._handler.getDefaultAddressId(args.userId)
4422 
    except UserContextException, ucx:
4423 
      result.ucx = ucx
4424 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
785 rajveer 4429 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4430 
    args = getDefaultPincode_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = getDefaultPincode_result()
4434 
    try:
4435 
      result.success = self._handler.getDefaultPincode(args.userId)
4436 
    except UserContextException, ucx:
4437 
      result.ucx = ucx
4438 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
4442 
 
1274 varun.gupt 4443 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4444 
    args = saveUserCommunication_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = saveUserCommunication_result()
4448 
    try:
4449 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4450 
    except UserCommunicationException, ucx:
4451 
      result.ucx = ucx
4452 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
4456 
 
1590 varun.gupt 4457 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4458 
    args = getUserCommunicationById_args()
4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
4461 
    result = getUserCommunicationById_result()
4462 
    try:
4463 
      result.success = self._handler.getUserCommunicationById(args.id)
4464 
    except UserCommunicationException, ucx:
4465 
      result.ucx = ucx
4466 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4467 
    result.write(oprot)
4468 
    oprot.writeMessageEnd()
4469 
    oprot.trans.flush()
4470 
 
4471 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4472 
    args = getUserCommunicationByUser_args()
4473 
    args.read(iprot)
4474 
    iprot.readMessageEnd()
4475 
    result = getUserCommunicationByUser_result()
4476 
    try:
4477 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4478 
    except UserCommunicationException, ucx:
4479 
      result.ucx = ucx
4480 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
4485 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4486 
    args = getAllUserCommunications_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = getAllUserCommunications_result()
4490 
    try:
4491 
      result.success = self._handler.getAllUserCommunications()
4492 
    except UserCommunicationException, ucx:
4493 
      result.ucx = ucx
4494 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
5407 amar.kumar 4499 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4500 
    args = removeUserCommunication_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = removeUserCommunication_result()
4504 
    try:
4505 
      self._handler.removeUserCommunication(args.id)
4506 
    except UserCommunicationException, ucx:
4507 
      result.ucx = ucx
4508 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
4512 
 
1845 vikas 4513 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4514 
    args = createMasterAffiliate_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = createMasterAffiliate_result()
4518 
    try:
1859 vikas 4519 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4520 
    except UserAffiliateException, utx:
1845 vikas 4521 
      result.utx = utx
4522 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4523 
    result.write(oprot)
4524 
    oprot.writeMessageEnd()
4525 
    oprot.trans.flush()
4526 
 
1899 vikas 4527 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4528 
    args = getAllMasterAffiliates_args()
4529 
    args.read(iprot)
4530 
    iprot.readMessageEnd()
4531 
    result = getAllMasterAffiliates_result()
4532 
    try:
4533 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4534 
    except UserAffiliateException, utx:
1899 vikas 4535 
      result.utx = utx
4536 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
4540 
 
1845 vikas 4541 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4542 
    args = getMasterAffiliateById_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = getMasterAffiliateById_result()
4546 
    try:
4547 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4548 
    except UserAffiliateException, utx:
1845 vikas 4549 
      result.utx = utx
4550 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4551 
    result.write(oprot)
4552 
    oprot.writeMessageEnd()
4553 
    oprot.trans.flush()
4554 
 
4555 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4556 
    args = getMasterAffiliateByName_args()
4557 
    args.read(iprot)
4558 
    iprot.readMessageEnd()
4559 
    result = getMasterAffiliateByName_result()
4560 
    try:
4561 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4562 
    except UserAffiliateException, utx:
1845 vikas 4563 
      result.utx = utx
4564 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4565 
    result.write(oprot)
4566 
    oprot.writeMessageEnd()
4567 
    oprot.trans.flush()
4568 
 
4569 
  def process_createAffiliate(self, seqid, iprot, oprot):
4570 
    args = createAffiliate_args()
4571 
    args.read(iprot)
4572 
    iprot.readMessageEnd()
4573 
    result = createAffiliate_result()
4574 
    try:
1859 vikas 4575 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4576 
    except UserAffiliateException, utx:
1845 vikas 4577 
      result.utx = utx
4578 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4579 
    result.write(oprot)
4580 
    oprot.writeMessageEnd()
4581 
    oprot.trans.flush()
4582 
 
4583 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4584 
    args = getAffiliateById_args()
4585 
    args.read(iprot)
4586 
    iprot.readMessageEnd()
4587 
    result = getAffiliateById_result()
4588 
    try:
4589 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4590 
    except UserAffiliateException, utx:
1845 vikas 4591 
      result.utx = utx
4592 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4593 
    result.write(oprot)
4594 
    oprot.writeMessageEnd()
4595 
    oprot.trans.flush()
4596 
 
4597 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4598 
    args = getAffiliateByName_args()
4599 
    args.read(iprot)
4600 
    iprot.readMessageEnd()
4601 
    result = getAffiliateByName_result()
4602 
    try:
4603 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4604 
    except UserAffiliateException, utx:
1845 vikas 4605 
      result.utx = utx
4606 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4611 
  def process_getTrackerById(self, seqid, iprot, oprot):
4612 
    args = getTrackerById_args()
4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4615 
    result = getTrackerById_result()
4616 
    try:
1996 vikas 4617 
      result.success = self._handler.getTrackerById(args.id)
4618 
    except UserAffiliateException, utx:
1845 vikas 4619 
      result.utx = utx
4620 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4621 
    result.write(oprot)
4622 
    oprot.writeMessageEnd()
4623 
    oprot.trans.flush()
4624 
 
1996 vikas 4625 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4626 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4627 
    args.read(iprot)
4628 
    iprot.readMessageEnd()
1996 vikas 4629 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4630 
    try:
1996 vikas 4631 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4632 
    except UserAffiliateException, utx:
1845 vikas 4633 
      result.utx = utx
1996 vikas 4634 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4635 
    result.write(oprot)
4636 
    oprot.writeMessageEnd()
4637 
    oprot.trans.flush()
4638 
 
4639 
  def process_addTrackLog(self, seqid, iprot, oprot):
4640 
    args = addTrackLog_args()
4641 
    args.read(iprot)
4642 
    iprot.readMessageEnd()
4643 
    result = addTrackLog_result()
4644 
    try:
1996 vikas 4645 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4646 
    except UserAffiliateException, utx:
1845 vikas 4647 
      result.utx = utx
4648 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4649 
    result.write(oprot)
4650 
    oprot.writeMessageEnd()
4651 
    oprot.trans.flush()
4652 
 
4653 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4654 
    args = getTrackLogById_args()
4655 
    args.read(iprot)
4656 
    iprot.readMessageEnd()
4657 
    result = getTrackLogById_result()
4658 
    try:
4659 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4660 
    except UserAffiliateException, utx:
1845 vikas 4661 
      result.utx = utx
4662 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4663 
    result.write(oprot)
4664 
    oprot.writeMessageEnd()
4665 
    oprot.trans.flush()
4666 
 
1996 vikas 4667 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4668 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4669 
    args.read(iprot)
4670 
    iprot.readMessageEnd()
1996 vikas 4671 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4672 
    try:
3293 vikas 4673 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4674 
    except UserAffiliateException, utx:
1845 vikas 4675 
      result.utx = utx
1996 vikas 4676 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4677 
    result.write(oprot)
4678 
    oprot.writeMessageEnd()
4679 
    oprot.trans.flush()
4680 
 
4681 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4682 
    args = getTrackLogsByUser_args()
4683 
    args.read(iprot)
4684 
    iprot.readMessageEnd()
4685 
    result = getTrackLogsByUser_result()
4686 
    try:
4687 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4688 
    except UserAffiliateException, utx:
1845 vikas 4689 
      result.utx = utx
4690 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4691 
    result.write(oprot)
4692 
    oprot.writeMessageEnd()
4693 
    oprot.trans.flush()
4694 
 
4695 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4696 
    args = getTrackLogs_args()
4697 
    args.read(iprot)
4698 
    iprot.readMessageEnd()
4699 
    result = getTrackLogs_result()
4700 
    try:
1996 vikas 4701 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4702 
    except UserAffiliateException, utx:
1845 vikas 4703 
      result.utx = utx
4704 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
559 chandransh 4709 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4710 
    args = getCurrentCart_args()
94 ashish 4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
559 chandransh 4713 
    result = getCurrentCart_result()
94 ashish 4714 
    try:
559 chandransh 4715 
      result.success = self._handler.getCurrentCart(args.userId)
4716 
    except ShoppingCartException, scx:
4717 
      result.scx = scx
4718 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4719 
    result.write(oprot)
4720 
    oprot.writeMessageEnd()
4721 
    oprot.trans.flush()
4722 
 
559 chandransh 4723 
  def process_getCart(self, seqid, iprot, oprot):
4724 
    args = getCart_args()
94 ashish 4725 
    args.read(iprot)
4726 
    iprot.readMessageEnd()
559 chandransh 4727 
    result = getCart_result()
94 ashish 4728 
    try:
559 chandransh 4729 
      result.success = self._handler.getCart(args.cartId)
4730 
    except ShoppingCartException, scx:
4731 
      result.scx = scx
4732 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4733 
    result.write(oprot)
4734 
    oprot.writeMessageEnd()
4735 
    oprot.trans.flush()
4736 
 
559 chandransh 4737 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4738 
    args = getCartsByTime_args()
94 ashish 4739 
    args.read(iprot)
4740 
    iprot.readMessageEnd()
559 chandransh 4741 
    result = getCartsByTime_result()
94 ashish 4742 
    try:
559 chandransh 4743 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4744 
    except ShoppingCartException, scx:
4745 
      result.scx = scx
4746 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4747 
    result.write(oprot)
4748 
    oprot.writeMessageEnd()
4749 
    oprot.trans.flush()
4750 
 
559 chandransh 4751 
  def process_addItemToCart(self, seqid, iprot, oprot):
4752 
    args = addItemToCart_args()
130 ashish 4753 
    args.read(iprot)
4754 
    iprot.readMessageEnd()
559 chandransh 4755 
    result = addItemToCart_result()
130 ashish 4756 
    try:
3557 rajveer 4757 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4758 
    except ShoppingCartException, scx:
4759 
      result.scx = scx
4760 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4761 
    result.write(oprot)
4762 
    oprot.writeMessageEnd()
4763 
    oprot.trans.flush()
4764 
 
559 chandransh 4765 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4766 
    args = deleteItemFromCart_args()
4767 
    args.read(iprot)
4768 
    iprot.readMessageEnd()
4769 
    result = deleteItemFromCart_result()
4770 
    try:
4771 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4772 
    except ShoppingCartException, scx:
4773 
      result.scx = scx
4774 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4775 
    result.write(oprot)
4776 
    oprot.writeMessageEnd()
4777 
    oprot.trans.flush()
130 ashish 4778 
 
559 chandransh 4779 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4780 
    args = addAddressToCart_args()
4781 
    args.read(iprot)
4782 
    iprot.readMessageEnd()
4783 
    result = addAddressToCart_result()
575 chandransh 4784 
    try:
4785 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4786 
    except ShoppingCartException, scx:
4787 
      result.scx = scx
559 chandransh 4788 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4789 
    result.write(oprot)
4790 
    oprot.writeMessageEnd()
4791 
    oprot.trans.flush()
4792 
 
5553 rajveer 4793 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4794 
    args = addStoreToCart_args()
4795 
    args.read(iprot)
4796 
    iprot.readMessageEnd()
4797 
    result = addStoreToCart_result()
4798 
    try:
4799 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4800 
    except ShoppingCartException, scx:
4801 
      result.scx = scx
4802 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4803 
    result.write(oprot)
4804 
    oprot.writeMessageEnd()
4805 
    oprot.trans.flush()
4806 
 
1976 varun.gupt 4807 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4808 
    args = applyCouponToCart_args()
4809 
    args.read(iprot)
4810 
    iprot.readMessageEnd()
4811 
    result = applyCouponToCart_result()
4812 
    try:
6922 anupam.sin 4813 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4814 
    except ShoppingCartException, scx:
4815 
      result.scx = scx
4816 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4817 
    result.write(oprot)
4818 
    oprot.writeMessageEnd()
4819 
    oprot.trans.flush()
4820 
 
4821 
  def process_removeCoupon(self, seqid, iprot, oprot):
4822 
    args = removeCoupon_args()
4823 
    args.read(iprot)
4824 
    iprot.readMessageEnd()
4825 
    result = removeCoupon_result()
4826 
    try:
4827 
      self._handler.removeCoupon(args.cartId)
4828 
    except ShoppingCartException, scx:
4829 
      result.scx = scx
4830 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4831 
    result.write(oprot)
4832 
    oprot.writeMessageEnd()
4833 
    oprot.trans.flush()
4834 
 
3554 varun.gupt 4835 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4836 
    args = deleteDiscountsFromCart_args()
4837 
    args.read(iprot)
4838 
    iprot.readMessageEnd()
4839 
    result = deleteDiscountsFromCart_result()
4840 
    try:
4841 
      self._handler.deleteDiscountsFromCart(args.cartId)
4842 
    except ShoppingCartException, scx:
4843 
      result.scx = scx
4844 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4845 
    result.write(oprot)
4846 
    oprot.writeMessageEnd()
4847 
    oprot.trans.flush()
4848 
 
4849 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4850 
    args = saveDiscounts_args()
4851 
    args.read(iprot)
4852 
    iprot.readMessageEnd()
4853 
    result = saveDiscounts_result()
4854 
    try:
4855 
      self._handler.saveDiscounts(args.discounts)
4856 
    except ShoppingCartException, scx:
4857 
      result.scx = scx
4858 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4859 
    result.write(oprot)
4860 
    oprot.writeMessageEnd()
4861 
    oprot.trans.flush()
4862 
 
690 chandransh 4863 
  def process_createOrders(self, seqid, iprot, oprot):
4864 
    args = createOrders_args()
559 chandransh 4865 
    args.read(iprot)
4866 
    iprot.readMessageEnd()
690 chandransh 4867 
    result = createOrders_result()
559 chandransh 4868 
    try:
21454 amit.gupta 4869 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource, args.selfPickup)
559 chandransh 4870 
    except ShoppingCartException, scx:
4871 
      result.scx = scx
690 chandransh 4872 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4873 
    result.write(oprot)
4874 
    oprot.writeMessageEnd()
4875 
    oprot.trans.flush()
4876 
 
4877 
  def process_validateCart(self, seqid, iprot, oprot):
4878 
    args = validateCart_args()
4879 
    args.read(iprot)
4880 
    iprot.readMessageEnd()
4881 
    result = validateCart_result()
575 chandransh 4882 
    try:
3557 rajveer 4883 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4884 
    except ShoppingCartException, scex:
4885 
      result.scex = scex
559 chandransh 4886 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4887 
    result.write(oprot)
4888 
    oprot.writeMessageEnd()
4889 
    oprot.trans.flush()
4890 
 
11980 amit.gupta 4891 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4892 
    args = validateCartWithDealerCoupon_args()
4893 
    args.read(iprot)
4894 
    iprot.readMessageEnd()
4895 
    result = validateCartWithDealerCoupon_result()
4896 
    try:
4897 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4898 
    except ShoppingCartException, scex:
4899 
      result.scex = scex
4900 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
4904 
 
690 chandransh 4905 
  def process_mergeCart(self, seqid, iprot, oprot):
4906 
    args = mergeCart_args()
575 chandransh 4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
690 chandransh 4909 
    result = mergeCart_result()
4910 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4911 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
4916 
  def process_checkOut(self, seqid, iprot, oprot):
4917 
    args = checkOut_args()
4918 
    args.read(iprot)
4919 
    iprot.readMessageEnd()
4920 
    result = checkOut_result()
575 chandransh 4921 
    try:
690 chandransh 4922 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4923 
    except ShoppingCartException, scex:
4924 
      result.scex = scex
690 chandransh 4925 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4926 
    result.write(oprot)
4927 
    oprot.writeMessageEnd()
4928 
    oprot.trans.flush()
4929 
 
690 chandransh 4930 
  def process_resetCart(self, seqid, iprot, oprot):
4931 
    args = resetCart_args()
559 chandransh 4932 
    args.read(iprot)
4933 
    iprot.readMessageEnd()
690 chandransh 4934 
    result = resetCart_result()
4935 
    try:
4936 
      result.success = self._handler.resetCart(args.cartId, args.items)
4937 
    except ShoppingCartException, scex:
4938 
      result.scex = scex
4939 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4940 
    result.write(oprot)
4941 
    oprot.writeMessageEnd()
4942 
    oprot.trans.flush()
4943 
 
2981 rajveer 4944 
  def process_getUserCount(self, seqid, iprot, oprot):
4945 
    args = getUserCount_args()
559 chandransh 4946 
    args.read(iprot)
4947 
    iprot.readMessageEnd()
2981 rajveer 4948 
    result = getUserCount_result()
4949 
    result.success = self._handler.getUserCount(args.userType)
4950 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4951 
    result.write(oprot)
4952 
    oprot.writeMessageEnd()
4953 
    oprot.trans.flush()
4954 
 
2981 rajveer 4955 
  def process_getAllUsers(self, seqid, iprot, oprot):
4956 
    args = getAllUsers_args()
559 chandransh 4957 
    args.read(iprot)
4958 
    iprot.readMessageEnd()
2981 rajveer 4959 
    result = getAllUsers_result()
4960 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4961 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4962 
    result.write(oprot)
4963 
    oprot.writeMessageEnd()
4964 
    oprot.trans.flush()
4965 
 
2981 rajveer 4966 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4967 
    args = getMyResearchItems_args()
559 chandransh 4968 
    args.read(iprot)
4969 
    iprot.readMessageEnd()
2981 rajveer 4970 
    result = getMyResearchItems_result()
559 chandransh 4971 
    try:
2981 rajveer 4972 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4973 
    except WidgetException, scx:
4974 
      result.scx = scx
2981 rajveer 4975 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
4979 
 
2981 rajveer 4980 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4981 
    args = updateMyResearch_args()
772 rajveer 4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
2981 rajveer 4984 
    result = updateMyResearch_result()
4985 
    try:
4986 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4987 
    except WidgetException, scx:
4988 
      result.scx = scx
4989 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4990 
    result.write(oprot)
4991 
    oprot.writeMessageEnd()
4992 
    oprot.trans.flush()
559 chandransh 4993 
 
2981 rajveer 4994 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4995 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4996 
    args.read(iprot)
4997 
    iprot.readMessageEnd()
2981 rajveer 4998 
    result = deleteItemFromMyResearch_result()
4999 
    try:
5000 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
5001 
    except WidgetException, scx:
5002 
      result.scx = scx
5003 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
772 rajveer 5007 
 
2981 rajveer 5008 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
5009 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
2981 rajveer 5012 
    result = getBrowseHistoryItems_result()
5013 
    try:
5014 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
5015 
    except WidgetException, scx:
5016 
      result.scx = scx
5017 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 5018 
    result.write(oprot)
5019 
    oprot.writeMessageEnd()
5020 
    oprot.trans.flush()
1596 ankur.sing 5021 
 
2981 rajveer 5022 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
5023 
    args = updateBrowseHistory_args()
2642 varun.gupt 5024 
    args.read(iprot)
5025 
    iprot.readMessageEnd()
2981 rajveer 5026 
    result = updateBrowseHistory_result()
5027 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
5028 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 5029 
    result.write(oprot)
5030 
    oprot.writeMessageEnd()
5031 
    oprot.trans.flush()
1673 ankur.sing 5032 
 
3385 varun.gupt 5033 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
5034 
    args = getCartsWithCouponCount_args()
5035 
    args.read(iprot)
5036 
    iprot.readMessageEnd()
5037 
    result = getCartsWithCouponCount_result()
5038 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
5039 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
5040 
    result.write(oprot)
5041 
    oprot.writeMessageEnd()
5042 
    oprot.trans.flush()
2642 varun.gupt 5043 
 
3499 mandeep.dh 5044 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
5045 
    args = increaseTrustLevel_args()
5046 
    args.read(iprot)
5047 
    iprot.readMessageEnd()
5048 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 5049 
    return
3385 varun.gupt 5050 
 
5407 amar.kumar 5051 
  def process_getTrustLevel(self, seqid, iprot, oprot):
5052 
    args = getTrustLevel_args()
5053 
    args.read(iprot)
5054 
    iprot.readMessageEnd()
5055 
    result = getTrustLevel_result()
5056 
    result.success = self._handler.getTrustLevel(args.userId)
5057 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
5058 
    result.write(oprot)
5059 
    oprot.writeMessageEnd()
5060 
    oprot.trans.flush()
5061 
 
4668 varun.gupt 5062 
  def process_showCODOption(self, seqid, iprot, oprot):
5063 
    args = showCODOption_args()
5064 
    args.read(iprot)
5065 
    iprot.readMessageEnd()
5066 
    result = showCODOption_result()
5067 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
5068 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
5069 
    result.write(oprot)
5070 
    oprot.writeMessageEnd()
5071 
    oprot.trans.flush()
3499 mandeep.dh 5072 
 
5623 anupam.sin 5073 
  def process_getUserEmails(self, seqid, iprot, oprot):
5074 
    args = getUserEmails_args()
5075 
    args.read(iprot)
5076 
    iprot.readMessageEnd()
5077 
    result = getUserEmails_result()
5078 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
5079 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
5080 
    result.write(oprot)
5081 
    oprot.writeMessageEnd()
5082 
    oprot.trans.flush()
4668 varun.gupt 5083 
 
6903 anupam.sin 5084 
  def process_insureItem(self, seqid, iprot, oprot):
5085 
    args = insureItem_args()
5086 
    args.read(iprot)
5087 
    iprot.readMessageEnd()
5088 
    result = insureItem_result()
9299 kshitij.so 5089 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 5090 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
5091 
    result.write(oprot)
5092 
    oprot.writeMessageEnd()
5093 
    oprot.trans.flush()
5094 
 
5095 
  def process_cancelInsurance(self, seqid, iprot, oprot):
5096 
    args = cancelInsurance_args()
5097 
    args.read(iprot)
5098 
    iprot.readMessageEnd()
5099 
    result = cancelInsurance_result()
5100 
    result.success = self._handler.cancelInsurance(args.cartId)
5101 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
5102 
    result.write(oprot)
5103 
    oprot.writeMessageEnd()
5104 
    oprot.trans.flush()
5105 
 
5106 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
5107 
    args = storeInsuranceSpecificDetails_args()
5108 
    args.read(iprot)
5109 
    iprot.readMessageEnd()
5110 
    result = storeInsuranceSpecificDetails_result()
5111 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
5112 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
5113 
    result.write(oprot)
5114 
    oprot.writeMessageEnd()
5115 
    oprot.trans.flush()
5116 
 
5117 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
5118 
    args = isInsuranceDetailPresent_args()
5119 
    args.read(iprot)
5120 
    iprot.readMessageEnd()
5121 
    result = isInsuranceDetailPresent_result()
5122 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
5123 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
5124 
    result.write(oprot)
5125 
    oprot.writeMessageEnd()
5126 
    oprot.trans.flush()
5127 
 
9791 rajveer 5128 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
5129 
    args = getProductsAddedToCart_args()
6821 amar.kumar 5130 
    args.read(iprot)
5131 
    iprot.readMessageEnd()
9791 rajveer 5132 
    result = getProductsAddedToCart_result()
5133 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
5134 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 5135 
    result.write(oprot)
5136 
    oprot.writeMessageEnd()
5137 
    oprot.trans.flush()
5623 anupam.sin 5138 
 
11592 amit.gupta 5139 
  def process_validateCartPlus(self, seqid, iprot, oprot):
5140 
    args = validateCartPlus_args()
5141 
    args.read(iprot)
5142 
    iprot.readMessageEnd()
5143 
    result = validateCartPlus_result()
5144 
    try:
11980 amit.gupta 5145 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 5146 
    except ShoppingCartException, scex:
5147 
      result.scex = scex
5148 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
5149 
    result.write(oprot)
5150 
    oprot.writeMessageEnd()
5151 
    oprot.trans.flush()
6821 amar.kumar 5152 
 
11679 vikram.rag 5153 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
5154 
    args = isPrivateDealUser_args()
5155 
    args.read(iprot)
5156 
    iprot.readMessageEnd()
5157 
    result = isPrivateDealUser_result()
5158 
    result.success = self._handler.isPrivateDealUser(args.userId)
5159 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
5160 
    result.write(oprot)
5161 
    oprot.writeMessageEnd()
5162 
    oprot.trans.flush()
11592 amit.gupta 5163 
 
11890 kshitij.so 5164 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
5165 
    args = addPrivateDealUser_args()
5166 
    args.read(iprot)
5167 
    iprot.readMessageEnd()
5168 
    result = addPrivateDealUser_result()
5169 
    result.success = self._handler.addPrivateDealUser(args.userId)
5170 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
5171 
    result.write(oprot)
5172 
    oprot.writeMessageEnd()
5173 
    oprot.trans.flush()
11679 vikram.rag 5174 
 
11890 kshitij.so 5175 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
5176 
    args = changePrivateDealUserStatus_args()
5177 
    args.read(iprot)
5178 
    iprot.readMessageEnd()
5179 
    result = changePrivateDealUserStatus_result()
5180 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
5181 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
5182 
    result.write(oprot)
5183 
    oprot.writeMessageEnd()
5184 
    oprot.trans.flush()
5185 
 
5186 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
5187 
    args = getPrivateDealUser_args()
5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
5190 
    result = getPrivateDealUser_result()
5191 
    result.success = self._handler.getPrivateDealUser(args.userId)
5192 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5193 
    result.write(oprot)
5194 
    oprot.writeMessageEnd()
5195 
    oprot.trans.flush()
5196 
 
12696 amit.gupta 5197 
  def process_registerCounter(self, seqid, iprot, oprot):
5198 
    args = registerCounter_args()
5199 
    args.read(iprot)
5200 
    iprot.readMessageEnd()
5201 
    result = registerCounter_result()
5202 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5203 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5204 
    result.write(oprot)
5205 
    oprot.writeMessageEnd()
5206 
    oprot.trans.flush()
11890 kshitij.so 5207 
 
12722 amit.gupta 5208 
  def process_searchCounter(self, seqid, iprot, oprot):
5209 
    args = searchCounter_args()
5210 
    args.read(iprot)
5211 
    iprot.readMessageEnd()
5212 
    result = searchCounter_result()
5213 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5214 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5215 
    result.write(oprot)
5216 
    oprot.writeMessageEnd()
5217 
    oprot.trans.flush()
12696 amit.gupta 5218 
 
18977 amit.gupta 5219 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5220 
    args = getCounterByUserId_args()
5221 
    args.read(iprot)
5222 
    iprot.readMessageEnd()
5223 
    result = getCounterByUserId_result()
5224 
    result.success = self._handler.getCounterByUserId(args.userId)
5225 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5226 
    result.write(oprot)
5227 
    oprot.writeMessageEnd()
5228 
    oprot.trans.flush()
5229 
 
12722 amit.gupta 5230 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5231 
    args = getAllUsersByCounter_args()
5232 
    args.read(iprot)
5233 
    iprot.readMessageEnd()
5234 
    result = getAllUsersByCounter_result()
5235 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5236 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5237 
    result.write(oprot)
5238 
    oprot.writeMessageEnd()
5239 
    oprot.trans.flush()
5240 
 
15251 manish.sha 5241 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5242 
    args = getActiveAccessTokenForUser_args()
5243 
    args.read(iprot)
5244 
    iprot.readMessageEnd()
5245 
    result = getActiveAccessTokenForUser_result()
5246 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5247 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5248 
    result.write(oprot)
5249 
    oprot.writeMessageEnd()
5250 
    oprot.trans.flush()
12722 amit.gupta 5251 
 
15251 manish.sha 5252 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5253 
    args = validateAccessToken_args()
5254 
    args.read(iprot)
5255 
    iprot.readMessageEnd()
5256 
    result = validateAccessToken_result()
5257 
    result.success = self._handler.validateAccessToken(args.accessToken)
5258 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5259 
    result.write(oprot)
5260 
    oprot.writeMessageEnd()
5261 
    oprot.trans.flush()
5262 
 
17782 amit.gupta 5263 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5264 
    args = addItemsToCart_args()
5265 
    args.read(iprot)
5266 
    iprot.readMessageEnd()
5267 
    result = addItemsToCart_result()
5268 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5269 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5270 
    result.write(oprot)
5271 
    oprot.writeMessageEnd()
5272 
    oprot.trans.flush()
15251 manish.sha 5273 
 
17782 amit.gupta 5274 
  def process_validateCartNew(self, seqid, iprot, oprot):
5275 
    args = validateCartNew_args()
5276 
    args.read(iprot)
5277 
    iprot.readMessageEnd()
5278 
    result = validateCartNew_result()
5279 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5280 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5281 
    result.write(oprot)
5282 
    oprot.writeMessageEnd()
5283 
    oprot.trans.flush()
5284 
 
18644 manish.sha 5285 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5286 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5287 
    args.read(iprot)
5288 
    iprot.readMessageEnd()
18644 manish.sha 5289 
    result = isAddressEditableForCounter_result()
5290 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5291 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5292 
    result.write(oprot)
5293 
    oprot.writeMessageEnd()
5294 
    oprot.trans.flush()
17782 amit.gupta 5295 
 
18530 manish.sha 5296 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5297 
    args = getBillingAddressForUser_args()
5298 
    args.read(iprot)
5299 
    iprot.readMessageEnd()
5300 
    result = getBillingAddressForUser_result()
5301 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5302 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5303 
    result.write(oprot)
5304 
    oprot.writeMessageEnd()
5305 
    oprot.trans.flush()
5306 
 
18590 manish.sha 5307 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5308 
    args = isCreditorAssigned_args()
5309 
    args.read(iprot)
5310 
    iprot.readMessageEnd()
5311 
    result = isCreditorAssigned_result()
5312 
    result.success = self._handler.isCreditorAssigned(args.userId)
5313 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5314 
    result.write(oprot)
5315 
    oprot.writeMessageEnd()
5316 
    oprot.trans.flush()
18530 manish.sha 5317 
 
18735 manish.sha 5318 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5319 
    args = isTaxInvoiceEnabledUser_args()
5320 
    args.read(iprot)
5321 
    iprot.readMessageEnd()
5322 
    result = isTaxInvoiceEnabledUser_result()
5323 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5324 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5325 
    result.write(oprot)
5326 
    oprot.writeMessageEnd()
5327 
    oprot.trans.flush()
18590 manish.sha 5328 
 
19182 amit.gupta 5329 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5330 
    args = taxInvoiceAvailable_args()
5331 
    args.read(iprot)
5332 
    iprot.readMessageEnd()
5333 
    result = taxInvoiceAvailable_result()
5334 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5335 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5336 
    result.write(oprot)
5337 
    oprot.writeMessageEnd()
5338 
    oprot.trans.flush()
5339 
 
18764 kshitij.so 5340 
  def process_getCartByValue(self, seqid, iprot, oprot):
5341 
    args = getCartByValue_args()
5342 
    args.read(iprot)
5343 
    iprot.readMessageEnd()
5344 
    result = getCartByValue_result()
5345 
    result.success = self._handler.getCartByValue(args.cartIds)
5346 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5347 
    result.write(oprot)
5348 
    oprot.writeMessageEnd()
5349 
    oprot.trans.flush()
18735 manish.sha 5350 
 
19889 manas 5351 
  def process_getCounterName(self, seqid, iprot, oprot):
5352 
    args = getCounterName_args()
5353 
    args.read(iprot)
5354 
    iprot.readMessageEnd()
5355 
    result = getCounterName_result()
5356 
    result.success = self._handler.getCounterName(args.userIds)
5357 
    oprot.writeMessageBegin("getCounterName", TMessageType.REPLY, seqid)
5358 
    result.write(oprot)
5359 
    oprot.writeMessageEnd()
5360 
    oprot.trans.flush()
18764 kshitij.so 5361 
 
20873 kshitij.so 5362 
  def process_setWalletAmountInCart(self, seqid, iprot, oprot):
5363 
    args = setWalletAmountInCart_args()
5364 
    args.read(iprot)
5365 
    iprot.readMessageEnd()
5366 
    result = setWalletAmountInCart_result()
5367 
    result.success = self._handler.setWalletAmountInCart(args.cartId, args.wallet_amount)
5368 
    oprot.writeMessageBegin("setWalletAmountInCart", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
19889 manas 5372 
 
20873 kshitij.so 5373 
 
94 ashish 5374 
# HELPER FUNCTIONS AND STRUCTURES
5375 
 
559 chandransh 5376 
class createAnonymousUser_args:
94 ashish 5377 
  """
5378 
  Attributes:
559 chandransh 5379 
   - jsessionId
94 ashish 5380 
  """
5381 
 
5382 
  thrift_spec = (
5383 
    None, # 0
559 chandransh 5384 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5385 
  )
5386 
 
559 chandransh 5387 
  def __init__(self, jsessionId=None,):
5388 
    self.jsessionId = jsessionId
94 ashish 5389 
 
5390 
  def read(self, iprot):
5391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5393 
      return
5394 
    iprot.readStructBegin()
5395 
    while True:
5396 
      (fname, ftype, fid) = iprot.readFieldBegin()
5397 
      if ftype == TType.STOP:
5398 
        break
5399 
      if fid == 1:
559 chandransh 5400 
        if ftype == TType.STRING:
5401 
          self.jsessionId = iprot.readString();
94 ashish 5402 
        else:
5403 
          iprot.skip(ftype)
5404 
      else:
5405 
        iprot.skip(ftype)
5406 
      iprot.readFieldEnd()
5407 
    iprot.readStructEnd()
5408 
 
5409 
  def write(self, oprot):
5410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5412 
      return
559 chandransh 5413 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5414 
    if self.jsessionId is not None:
559 chandransh 5415 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5416 
      oprot.writeString(self.jsessionId)
94 ashish 5417 
      oprot.writeFieldEnd()
5418 
    oprot.writeFieldStop()
5419 
    oprot.writeStructEnd()
5420 
 
3431 rajveer 5421 
  def validate(self):
5422 
    return
5423 
 
5424 
 
94 ashish 5425 
  def __repr__(self):
5426 
    L = ['%s=%r' % (key, value)
5427 
      for key, value in self.__dict__.iteritems()]
5428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5429 
 
5430 
  def __eq__(self, other):
5431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5432 
 
5433 
  def __ne__(self, other):
5434 
    return not (self == other)
5435 
 
559 chandransh 5436 
class createAnonymousUser_result:
94 ashish 5437 
  """
5438 
  Attributes:
5439 
   - success
559 chandransh 5440 
   - ucex
94 ashish 5441 
  """
5442 
 
5443 
  thrift_spec = (
559 chandransh 5444 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5445 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5446 
  )
5447 
 
559 chandransh 5448 
  def __init__(self, success=None, ucex=None,):
94 ashish 5449 
    self.success = success
559 chandransh 5450 
    self.ucex = ucex
94 ashish 5451 
 
5452 
  def read(self, iprot):
5453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5455 
      return
5456 
    iprot.readStructBegin()
5457 
    while True:
5458 
      (fname, ftype, fid) = iprot.readFieldBegin()
5459 
      if ftype == TType.STOP:
5460 
        break
5461 
      if fid == 0:
5462 
        if ftype == TType.STRUCT:
559 chandransh 5463 
          self.success = User()
94 ashish 5464 
          self.success.read(iprot)
5465 
        else:
5466 
          iprot.skip(ftype)
5467 
      elif fid == 1:
5468 
        if ftype == TType.STRUCT:
559 chandransh 5469 
          self.ucex = UserContextException()
5470 
          self.ucex.read(iprot)
94 ashish 5471 
        else:
5472 
          iprot.skip(ftype)
5473 
      else:
5474 
        iprot.skip(ftype)
5475 
      iprot.readFieldEnd()
5476 
    iprot.readStructEnd()
5477 
 
5478 
  def write(self, oprot):
5479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5481 
      return
559 chandransh 5482 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5483 
    if self.success is not None:
94 ashish 5484 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5485 
      self.success.write(oprot)
5486 
      oprot.writeFieldEnd()
3431 rajveer 5487 
    if self.ucex is not None:
559 chandransh 5488 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5489 
      self.ucex.write(oprot)
94 ashish 5490 
      oprot.writeFieldEnd()
5491 
    oprot.writeFieldStop()
5492 
    oprot.writeStructEnd()
5493 
 
3431 rajveer 5494 
  def validate(self):
5495 
    return
5496 
 
5497 
 
94 ashish 5498 
  def __repr__(self):
5499 
    L = ['%s=%r' % (key, value)
5500 
      for key, value in self.__dict__.iteritems()]
5501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5502 
 
5503 
  def __eq__(self, other):
5504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5505 
 
5506 
  def __ne__(self, other):
5507 
    return not (self == other)
5508 
 
559 chandransh 5509 
class getUserById_args:
94 ashish 5510 
  """
5511 
  Attributes:
5512 
   - userId
5513 
  """
5514 
 
5515 
  thrift_spec = (
5516 
    None, # 0
5517 
    (1, TType.I64, 'userId', None, None, ), # 1
5518 
  )
5519 
 
559 chandransh 5520 
  def __init__(self, userId=None,):
94 ashish 5521 
    self.userId = userId
5522 
 
5523 
  def read(self, iprot):
5524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5526 
      return
5527 
    iprot.readStructBegin()
5528 
    while True:
5529 
      (fname, ftype, fid) = iprot.readFieldBegin()
5530 
      if ftype == TType.STOP:
5531 
        break
5532 
      if fid == 1:
5533 
        if ftype == TType.I64:
5534 
          self.userId = iprot.readI64();
5535 
        else:
5536 
          iprot.skip(ftype)
5537 
      else:
5538 
        iprot.skip(ftype)
5539 
      iprot.readFieldEnd()
5540 
    iprot.readStructEnd()
5541 
 
5542 
  def write(self, oprot):
5543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5545 
      return
559 chandransh 5546 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5547 
    if self.userId is not None:
94 ashish 5548 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5549 
      oprot.writeI64(self.userId)
5550 
      oprot.writeFieldEnd()
5551 
    oprot.writeFieldStop()
5552 
    oprot.writeStructEnd()
5553 
 
3431 rajveer 5554 
  def validate(self):
5555 
    return
5556 
 
5557 
 
94 ashish 5558 
  def __repr__(self):
5559 
    L = ['%s=%r' % (key, value)
5560 
      for key, value in self.__dict__.iteritems()]
5561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5562 
 
5563 
  def __eq__(self, other):
5564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5565 
 
5566 
  def __ne__(self, other):
5567 
    return not (self == other)
5568 
 
559 chandransh 5569 
class getUserById_result:
94 ashish 5570 
  """
5571 
  Attributes:
5572 
   - success
559 chandransh 5573 
   - ucex
94 ashish 5574 
  """
5575 
 
5576 
  thrift_spec = (
559 chandransh 5577 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5578 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5579 
  )
5580 
 
559 chandransh 5581 
  def __init__(self, success=None, ucex=None,):
94 ashish 5582 
    self.success = success
559 chandransh 5583 
    self.ucex = ucex
94 ashish 5584 
 
5585 
  def read(self, iprot):
5586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5588 
      return
5589 
    iprot.readStructBegin()
5590 
    while True:
5591 
      (fname, ftype, fid) = iprot.readFieldBegin()
5592 
      if ftype == TType.STOP:
5593 
        break
5594 
      if fid == 0:
5595 
        if ftype == TType.STRUCT:
559 chandransh 5596 
          self.success = User()
94 ashish 5597 
          self.success.read(iprot)
5598 
        else:
5599 
          iprot.skip(ftype)
5600 
      elif fid == 1:
5601 
        if ftype == TType.STRUCT:
559 chandransh 5602 
          self.ucex = UserContextException()
5603 
          self.ucex.read(iprot)
94 ashish 5604 
        else:
5605 
          iprot.skip(ftype)
5606 
      else:
5607 
        iprot.skip(ftype)
5608 
      iprot.readFieldEnd()
5609 
    iprot.readStructEnd()
5610 
 
5611 
  def write(self, oprot):
5612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5614 
      return
559 chandransh 5615 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5616 
    if self.success is not None:
94 ashish 5617 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5618 
      self.success.write(oprot)
5619 
      oprot.writeFieldEnd()
3431 rajveer 5620 
    if self.ucex is not None:
559 chandransh 5621 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5622 
      self.ucex.write(oprot)
94 ashish 5623 
      oprot.writeFieldEnd()
5624 
    oprot.writeFieldStop()
5625 
    oprot.writeStructEnd()
5626 
 
3431 rajveer 5627 
  def validate(self):
5628 
    return
5629 
 
5630 
 
94 ashish 5631 
  def __repr__(self):
5632 
    L = ['%s=%r' % (key, value)
5633 
      for key, value in self.__dict__.iteritems()]
5634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5635 
 
5636 
  def __eq__(self, other):
5637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5638 
 
5639 
  def __ne__(self, other):
5640 
    return not (self == other)
5641 
 
5326 rajveer 5642 
class getUserByCartId_args:
1491 vikas 5643 
  """
5644 
  Attributes:
5326 rajveer 5645 
   - cartId
1491 vikas 5646 
  """
5647 
 
5648 
  thrift_spec = (
5649 
    None, # 0
5326 rajveer 5650 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5651 
  )
5652 
 
5326 rajveer 5653 
  def __init__(self, cartId=None,):
5654 
    self.cartId = cartId
1491 vikas 5655 
 
5656 
  def read(self, iprot):
5657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5659 
      return
5660 
    iprot.readStructBegin()
5661 
    while True:
5662 
      (fname, ftype, fid) = iprot.readFieldBegin()
5663 
      if ftype == TType.STOP:
5664 
        break
5665 
      if fid == 1:
5326 rajveer 5666 
        if ftype == TType.I64:
5667 
          self.cartId = iprot.readI64();
1491 vikas 5668 
        else:
5669 
          iprot.skip(ftype)
5670 
      else:
5671 
        iprot.skip(ftype)
5672 
      iprot.readFieldEnd()
5673 
    iprot.readStructEnd()
5674 
 
5675 
  def write(self, oprot):
5676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5678 
      return
5326 rajveer 5679 
    oprot.writeStructBegin('getUserByCartId_args')
5680 
    if self.cartId is not None:
5681 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5682 
      oprot.writeI64(self.cartId)
1491 vikas 5683 
      oprot.writeFieldEnd()
5684 
    oprot.writeFieldStop()
5685 
    oprot.writeStructEnd()
5686 
 
3431 rajveer 5687 
  def validate(self):
5688 
    return
5689 
 
5690 
 
1491 vikas 5691 
  def __repr__(self):
5692 
    L = ['%s=%r' % (key, value)
5693 
      for key, value in self.__dict__.iteritems()]
5694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5695 
 
5696 
  def __eq__(self, other):
5697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5698 
 
5699 
  def __ne__(self, other):
5700 
    return not (self == other)
5701 
 
5326 rajveer 5702 
class getUserByCartId_result:
1491 vikas 5703 
  """
5704 
  Attributes:
5705 
   - success
5706 
   - ucex
5707 
  """
5708 
 
5709 
  thrift_spec = (
5710 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5711 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5712 
  )
5713 
 
5714 
  def __init__(self, success=None, ucex=None,):
5715 
    self.success = success
5716 
    self.ucex = ucex
5717 
 
5718 
  def read(self, iprot):
5719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5721 
      return
5722 
    iprot.readStructBegin()
5723 
    while True:
5724 
      (fname, ftype, fid) = iprot.readFieldBegin()
5725 
      if ftype == TType.STOP:
5726 
        break
5727 
      if fid == 0:
5728 
        if ftype == TType.STRUCT:
5729 
          self.success = User()
5730 
          self.success.read(iprot)
5731 
        else:
5732 
          iprot.skip(ftype)
5733 
      elif fid == 1:
5734 
        if ftype == TType.STRUCT:
5735 
          self.ucex = UserContextException()
5736 
          self.ucex.read(iprot)
5737 
        else:
5738 
          iprot.skip(ftype)
5739 
      else:
5740 
        iprot.skip(ftype)
5741 
      iprot.readFieldEnd()
5742 
    iprot.readStructEnd()
5743 
 
5744 
  def write(self, oprot):
5745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5747 
      return
5326 rajveer 5748 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5749 
    if self.success is not None:
1491 vikas 5750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5751 
      self.success.write(oprot)
5752 
      oprot.writeFieldEnd()
3431 rajveer 5753 
    if self.ucex is not None:
1491 vikas 5754 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5755 
      self.ucex.write(oprot)
5756 
      oprot.writeFieldEnd()
5757 
    oprot.writeFieldStop()
5758 
    oprot.writeStructEnd()
5759 
 
3431 rajveer 5760 
  def validate(self):
5761 
    return
5762 
 
5763 
 
1491 vikas 5764 
  def __repr__(self):
5765 
    L = ['%s=%r' % (key, value)
5766 
      for key, value in self.__dict__.iteritems()]
5767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5768 
 
5769 
  def __eq__(self, other):
5770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5771 
 
5772 
  def __ne__(self, other):
5773 
    return not (self == other)
5774 
 
5326 rajveer 5775 
class getUserByEmail_args:
3032 mandeep.dh 5776 
  """
5777 
  Attributes:
5326 rajveer 5778 
   - email
3032 mandeep.dh 5779 
  """
5780 
 
5781 
  thrift_spec = (
5782 
    None, # 0
5326 rajveer 5783 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5784 
  )
5785 
 
5326 rajveer 5786 
  def __init__(self, email=None,):
5787 
    self.email = email
3032 mandeep.dh 5788 
 
5789 
  def read(self, iprot):
5790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5792 
      return
5793 
    iprot.readStructBegin()
5794 
    while True:
5795 
      (fname, ftype, fid) = iprot.readFieldBegin()
5796 
      if ftype == TType.STOP:
5797 
        break
5798 
      if fid == 1:
5326 rajveer 5799 
        if ftype == TType.STRING:
5800 
          self.email = iprot.readString();
3032 mandeep.dh 5801 
        else:
5802 
          iprot.skip(ftype)
5803 
      else:
5804 
        iprot.skip(ftype)
5805 
      iprot.readFieldEnd()
5806 
    iprot.readStructEnd()
5807 
 
5808 
  def write(self, oprot):
5809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5811 
      return
5326 rajveer 5812 
    oprot.writeStructBegin('getUserByEmail_args')
5813 
    if self.email is not None:
5814 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5815 
      oprot.writeString(self.email)
3032 mandeep.dh 5816 
      oprot.writeFieldEnd()
5817 
    oprot.writeFieldStop()
5818 
    oprot.writeStructEnd()
5819 
 
3431 rajveer 5820 
  def validate(self):
5821 
    return
5822 
 
5823 
 
3032 mandeep.dh 5824 
  def __repr__(self):
5825 
    L = ['%s=%r' % (key, value)
5826 
      for key, value in self.__dict__.iteritems()]
5827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5828 
 
5829 
  def __eq__(self, other):
5830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5831 
 
5832 
  def __ne__(self, other):
5833 
    return not (self == other)
5834 
 
5326 rajveer 5835 
class getUserByEmail_result:
3032 mandeep.dh 5836 
  """
5837 
  Attributes:
5838 
   - success
5839 
   - ucex
5840 
  """
5841 
 
5842 
  thrift_spec = (
5843 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5844 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5845 
  )
5846 
 
5847 
  def __init__(self, success=None, ucex=None,):
5848 
    self.success = success
5849 
    self.ucex = ucex
5850 
 
5851 
  def read(self, iprot):
5852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5854 
      return
5855 
    iprot.readStructBegin()
5856 
    while True:
5857 
      (fname, ftype, fid) = iprot.readFieldBegin()
5858 
      if ftype == TType.STOP:
5859 
        break
5860 
      if fid == 0:
5861 
        if ftype == TType.STRUCT:
5862 
          self.success = User()
5863 
          self.success.read(iprot)
5864 
        else:
5865 
          iprot.skip(ftype)
5866 
      elif fid == 1:
5867 
        if ftype == TType.STRUCT:
5868 
          self.ucex = UserContextException()
5869 
          self.ucex.read(iprot)
5870 
        else:
5871 
          iprot.skip(ftype)
5872 
      else:
5873 
        iprot.skip(ftype)
5874 
      iprot.readFieldEnd()
5875 
    iprot.readStructEnd()
5876 
 
5877 
  def write(self, oprot):
5878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5880 
      return
5326 rajveer 5881 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5882 
    if self.success is not None:
3032 mandeep.dh 5883 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5884 
      self.success.write(oprot)
5885 
      oprot.writeFieldEnd()
3431 rajveer 5886 
    if self.ucex is not None:
3032 mandeep.dh 5887 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5888 
      self.ucex.write(oprot)
5889 
      oprot.writeFieldEnd()
5890 
    oprot.writeFieldStop()
5891 
    oprot.writeStructEnd()
5892 
 
3431 rajveer 5893 
  def validate(self):
5894 
    return
5895 
 
5896 
 
3032 mandeep.dh 5897 
  def __repr__(self):
5898 
    L = ['%s=%r' % (key, value)
5899 
      for key, value in self.__dict__.iteritems()]
5900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5901 
 
5902 
  def __eq__(self, other):
5903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5904 
 
5905 
  def __ne__(self, other):
5906 
    return not (self == other)
5907 
 
5326 rajveer 5908 
class getUserByMobileNumber_args:
94 ashish 5909 
  """
5910 
  Attributes:
5326 rajveer 5911 
   - mobileNumber
94 ashish 5912 
  """
5913 
 
5914 
  thrift_spec = (
5915 
    None, # 0
5326 rajveer 5916 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5917 
  )
5918 
 
5326 rajveer 5919 
  def __init__(self, mobileNumber=None,):
5920 
    self.mobileNumber = mobileNumber
94 ashish 5921 
 
5922 
  def read(self, iprot):
5923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5925 
      return
5926 
    iprot.readStructBegin()
5927 
    while True:
5928 
      (fname, ftype, fid) = iprot.readFieldBegin()
5929 
      if ftype == TType.STOP:
5930 
        break
5931 
      if fid == 1:
5326 rajveer 5932 
        if ftype == TType.I64:
5933 
          self.mobileNumber = iprot.readI64();
94 ashish 5934 
        else:
5935 
          iprot.skip(ftype)
5936 
      else:
5937 
        iprot.skip(ftype)
5938 
      iprot.readFieldEnd()
5939 
    iprot.readStructEnd()
5940 
 
5941 
  def write(self, oprot):
5942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5944 
      return
5326 rajveer 5945 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5946 
    if self.mobileNumber is not None:
5947 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5948 
      oprot.writeI64(self.mobileNumber)
94 ashish 5949 
      oprot.writeFieldEnd()
5950 
    oprot.writeFieldStop()
5951 
    oprot.writeStructEnd()
5952 
 
3431 rajveer 5953 
  def validate(self):
5954 
    return
5955 
 
5956 
 
94 ashish 5957 
  def __repr__(self):
5958 
    L = ['%s=%r' % (key, value)
5959 
      for key, value in self.__dict__.iteritems()]
5960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5961 
 
5962 
  def __eq__(self, other):
5963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5964 
 
5965 
  def __ne__(self, other):
5966 
    return not (self == other)
5967 
 
5326 rajveer 5968 
class getUserByMobileNumber_result:
94 ashish 5969 
  """
5970 
  Attributes:
5971 
   - success
559 chandransh 5972 
   - ucex
94 ashish 5973 
  """
5974 
 
5975 
  thrift_spec = (
559 chandransh 5976 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5977 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5978 
  )
5979 
 
559 chandransh 5980 
  def __init__(self, success=None, ucex=None,):
94 ashish 5981 
    self.success = success
559 chandransh 5982 
    self.ucex = ucex
94 ashish 5983 
 
5984 
  def read(self, iprot):
5985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5987 
      return
5988 
    iprot.readStructBegin()
5989 
    while True:
5990 
      (fname, ftype, fid) = iprot.readFieldBegin()
5991 
      if ftype == TType.STOP:
5992 
        break
5993 
      if fid == 0:
5994 
        if ftype == TType.STRUCT:
559 chandransh 5995 
          self.success = User()
94 ashish 5996 
          self.success.read(iprot)
5997 
        else:
5998 
          iprot.skip(ftype)
5999 
      elif fid == 1:
6000 
        if ftype == TType.STRUCT:
559 chandransh 6001 
          self.ucex = UserContextException()
6002 
          self.ucex.read(iprot)
94 ashish 6003 
        else:
6004 
          iprot.skip(ftype)
6005 
      else:
6006 
        iprot.skip(ftype)
6007 
      iprot.readFieldEnd()
6008 
    iprot.readStructEnd()
6009 
 
6010 
  def write(self, oprot):
6011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6013 
      return
5326 rajveer 6014 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 6015 
    if self.success is not None:
94 ashish 6016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6017 
      self.success.write(oprot)
6018 
      oprot.writeFieldEnd()
3431 rajveer 6019 
    if self.ucex is not None:
559 chandransh 6020 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6021 
      self.ucex.write(oprot)
94 ashish 6022 
      oprot.writeFieldEnd()
6023 
    oprot.writeFieldStop()
6024 
    oprot.writeStructEnd()
6025 
 
3431 rajveer 6026 
  def validate(self):
6027 
    return
6028 
 
6029 
 
94 ashish 6030 
  def __repr__(self):
6031 
    L = ['%s=%r' % (key, value)
6032 
      for key, value in self.__dict__.iteritems()]
6033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6034 
 
6035 
  def __eq__(self, other):
6036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6037 
 
6038 
  def __ne__(self, other):
6039 
    return not (self == other)
6040 
 
5326 rajveer 6041 
class createUser_args:
94 ashish 6042 
  """
6043 
  Attributes:
559 chandransh 6044 
   - user
94 ashish 6045 
  """
6046 
 
6047 
  thrift_spec = (
6048 
    None, # 0
559 chandransh 6049 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6050 
  )
6051 
 
559 chandransh 6052 
  def __init__(self, user=None,):
6053 
    self.user = user
94 ashish 6054 
 
6055 
  def read(self, iprot):
6056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6058 
      return
6059 
    iprot.readStructBegin()
6060 
    while True:
6061 
      (fname, ftype, fid) = iprot.readFieldBegin()
6062 
      if ftype == TType.STOP:
6063 
        break
6064 
      if fid == 1:
559 chandransh 6065 
        if ftype == TType.STRUCT:
6066 
          self.user = User()
6067 
          self.user.read(iprot)
94 ashish 6068 
        else:
6069 
          iprot.skip(ftype)
6070 
      else:
6071 
        iprot.skip(ftype)
6072 
      iprot.readFieldEnd()
6073 
    iprot.readStructEnd()
6074 
 
6075 
  def write(self, oprot):
6076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6078 
      return
5326 rajveer 6079 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 6080 
    if self.user is not None:
559 chandransh 6081 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6082 
      self.user.write(oprot)
94 ashish 6083 
      oprot.writeFieldEnd()
6084 
    oprot.writeFieldStop()
6085 
    oprot.writeStructEnd()
6086 
 
3431 rajveer 6087 
  def validate(self):
6088 
    return
6089 
 
6090 
 
94 ashish 6091 
  def __repr__(self):
6092 
    L = ['%s=%r' % (key, value)
6093 
      for key, value in self.__dict__.iteritems()]
6094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6095 
 
6096 
  def __eq__(self, other):
6097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6098 
 
6099 
  def __ne__(self, other):
6100 
    return not (self == other)
6101 
 
5326 rajveer 6102 
class createUser_result:
94 ashish 6103 
  """
6104 
  Attributes:
6105 
   - success
559 chandransh 6106 
   - ucex
94 ashish 6107 
  """
6108 
 
6109 
  thrift_spec = (
559 chandransh 6110 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6111 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6112 
  )
6113 
 
559 chandransh 6114 
  def __init__(self, success=None, ucex=None,):
94 ashish 6115 
    self.success = success
559 chandransh 6116 
    self.ucex = ucex
94 ashish 6117 
 
6118 
  def read(self, iprot):
6119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6121 
      return
6122 
    iprot.readStructBegin()
6123 
    while True:
6124 
      (fname, ftype, fid) = iprot.readFieldBegin()
6125 
      if ftype == TType.STOP:
6126 
        break
6127 
      if fid == 0:
6128 
        if ftype == TType.STRUCT:
559 chandransh 6129 
          self.success = User()
94 ashish 6130 
          self.success.read(iprot)
6131 
        else:
6132 
          iprot.skip(ftype)
6133 
      elif fid == 1:
6134 
        if ftype == TType.STRUCT:
559 chandransh 6135 
          self.ucex = UserContextException()
6136 
          self.ucex.read(iprot)
94 ashish 6137 
        else:
6138 
          iprot.skip(ftype)
6139 
      else:
6140 
        iprot.skip(ftype)
6141 
      iprot.readFieldEnd()
6142 
    iprot.readStructEnd()
6143 
 
6144 
  def write(self, oprot):
6145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6147 
      return
5326 rajveer 6148 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 6149 
    if self.success is not None:
94 ashish 6150 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6151 
      self.success.write(oprot)
6152 
      oprot.writeFieldEnd()
3431 rajveer 6153 
    if self.ucex is not None:
559 chandransh 6154 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6155 
      self.ucex.write(oprot)
94 ashish 6156 
      oprot.writeFieldEnd()
6157 
    oprot.writeFieldStop()
6158 
    oprot.writeStructEnd()
6159 
 
3431 rajveer 6160 
  def validate(self):
6161 
    return
6162 
 
6163 
 
94 ashish 6164 
  def __repr__(self):
6165 
    L = ['%s=%r' % (key, value)
6166 
      for key, value in self.__dict__.iteritems()]
6167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6168 
 
6169 
  def __eq__(self, other):
6170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6171 
 
6172 
  def __ne__(self, other):
6173 
    return not (self == other)
6174 
 
5326 rajveer 6175 
class updateUser_args:
94 ashish 6176 
  """
6177 
  Attributes:
5326 rajveer 6178 
   - user
94 ashish 6179 
  """
6180 
 
6181 
  thrift_spec = (
6182 
    None, # 0
5326 rajveer 6183 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6184 
  )
6185 
 
5326 rajveer 6186 
  def __init__(self, user=None,):
6187 
    self.user = user
94 ashish 6188 
 
6189 
  def read(self, iprot):
6190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6192 
      return
6193 
    iprot.readStructBegin()
6194 
    while True:
6195 
      (fname, ftype, fid) = iprot.readFieldBegin()
6196 
      if ftype == TType.STOP:
6197 
        break
6198 
      if fid == 1:
5326 rajveer 6199 
        if ftype == TType.STRUCT:
6200 
          self.user = User()
6201 
          self.user.read(iprot)
94 ashish 6202 
        else:
6203 
          iprot.skip(ftype)
6204 
      else:
6205 
        iprot.skip(ftype)
6206 
      iprot.readFieldEnd()
6207 
    iprot.readStructEnd()
6208 
 
6209 
  def write(self, oprot):
6210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6212 
      return
5326 rajveer 6213 
    oprot.writeStructBegin('updateUser_args')
6214 
    if self.user is not None:
6215 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6216 
      self.user.write(oprot)
94 ashish 6217 
      oprot.writeFieldEnd()
6218 
    oprot.writeFieldStop()
6219 
    oprot.writeStructEnd()
6220 
 
3431 rajveer 6221 
  def validate(self):
6222 
    return
6223 
 
6224 
 
94 ashish 6225 
  def __repr__(self):
6226 
    L = ['%s=%r' % (key, value)
6227 
      for key, value in self.__dict__.iteritems()]
6228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6229 
 
6230 
  def __eq__(self, other):
6231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6232 
 
6233 
  def __ne__(self, other):
6234 
    return not (self == other)
6235 
 
5326 rajveer 6236 
class updateUser_result:
94 ashish 6237 
  """
6238 
  Attributes:
6239 
   - success
559 chandransh 6240 
   - ucex
94 ashish 6241 
  """
6242 
 
6243 
  thrift_spec = (
5326 rajveer 6244 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6245 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6246 
  )
6247 
 
559 chandransh 6248 
  def __init__(self, success=None, ucex=None,):
94 ashish 6249 
    self.success = success
559 chandransh 6250 
    self.ucex = ucex
94 ashish 6251 
 
6252 
  def read(self, iprot):
6253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6255 
      return
6256 
    iprot.readStructBegin()
6257 
    while True:
6258 
      (fname, ftype, fid) = iprot.readFieldBegin()
6259 
      if ftype == TType.STOP:
6260 
        break
6261 
      if fid == 0:
5326 rajveer 6262 
        if ftype == TType.STRUCT:
6263 
          self.success = User()
6264 
          self.success.read(iprot)
94 ashish 6265 
        else:
6266 
          iprot.skip(ftype)
6267 
      elif fid == 1:
6268 
        if ftype == TType.STRUCT:
559 chandransh 6269 
          self.ucex = UserContextException()
6270 
          self.ucex.read(iprot)
94 ashish 6271 
        else:
6272 
          iprot.skip(ftype)
6273 
      else:
6274 
        iprot.skip(ftype)
6275 
      iprot.readFieldEnd()
6276 
    iprot.readStructEnd()
6277 
 
6278 
  def write(self, oprot):
6279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6281 
      return
5326 rajveer 6282 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6283 
    if self.success is not None:
5326 rajveer 6284 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6285 
      self.success.write(oprot)
94 ashish 6286 
      oprot.writeFieldEnd()
3431 rajveer 6287 
    if self.ucex is not None:
559 chandransh 6288 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6289 
      self.ucex.write(oprot)
94 ashish 6290 
      oprot.writeFieldEnd()
6291 
    oprot.writeFieldStop()
6292 
    oprot.writeStructEnd()
6293 
 
3431 rajveer 6294 
  def validate(self):
6295 
    return
6296 
 
6297 
 
94 ashish 6298 
  def __repr__(self):
6299 
    L = ['%s=%r' % (key, value)
6300 
      for key, value in self.__dict__.iteritems()]
6301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6302 
 
6303 
  def __eq__(self, other):
6304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6305 
 
6306 
  def __ne__(self, other):
6307 
    return not (self == other)
6308 
 
559 chandransh 6309 
class authenticateUser_args:
94 ashish 6310 
  """
6311 
  Attributes:
6312 
   - email
6313 
   - password
6314 
  """
6315 
 
6316 
  thrift_spec = (
6317 
    None, # 0
6318 
    (1, TType.STRING, 'email', None, None, ), # 1
6319 
    (2, TType.STRING, 'password', None, None, ), # 2
6320 
  )
6321 
 
6322 
  def __init__(self, email=None, password=None,):
6323 
    self.email = email
6324 
    self.password = password
6325 
 
6326 
  def read(self, iprot):
6327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6329 
      return
6330 
    iprot.readStructBegin()
6331 
    while True:
6332 
      (fname, ftype, fid) = iprot.readFieldBegin()
6333 
      if ftype == TType.STOP:
6334 
        break
6335 
      if fid == 1:
6336 
        if ftype == TType.STRING:
6337 
          self.email = iprot.readString();
6338 
        else:
6339 
          iprot.skip(ftype)
6340 
      elif fid == 2:
6341 
        if ftype == TType.STRING:
6342 
          self.password = iprot.readString();
6343 
        else:
6344 
          iprot.skip(ftype)
6345 
      else:
6346 
        iprot.skip(ftype)
6347 
      iprot.readFieldEnd()
6348 
    iprot.readStructEnd()
6349 
 
6350 
  def write(self, oprot):
6351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6353 
      return
559 chandransh 6354 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6355 
    if self.email is not None:
94 ashish 6356 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6357 
      oprot.writeString(self.email)
6358 
      oprot.writeFieldEnd()
3431 rajveer 6359 
    if self.password is not None:
94 ashish 6360 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6361 
      oprot.writeString(self.password)
6362 
      oprot.writeFieldEnd()
6363 
    oprot.writeFieldStop()
6364 
    oprot.writeStructEnd()
6365 
 
3431 rajveer 6366 
  def validate(self):
6367 
    return
6368 
 
6369 
 
94 ashish 6370 
  def __repr__(self):
6371 
    L = ['%s=%r' % (key, value)
6372 
      for key, value in self.__dict__.iteritems()]
6373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6374 
 
6375 
  def __eq__(self, other):
6376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6377 
 
6378 
  def __ne__(self, other):
6379 
    return not (self == other)
6380 
 
559 chandransh 6381 
class authenticateUser_result:
94 ashish 6382 
  """
6383 
  Attributes:
6384 
   - success
559 chandransh 6385 
   - auex
94 ashish 6386 
  """
6387 
 
6388 
  thrift_spec = (
559 chandransh 6389 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6390 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6391 
  )
6392 
 
559 chandransh 6393 
  def __init__(self, success=None, auex=None,):
94 ashish 6394 
    self.success = success
559 chandransh 6395 
    self.auex = auex
94 ashish 6396 
 
6397 
  def read(self, iprot):
6398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6400 
      return
6401 
    iprot.readStructBegin()
6402 
    while True:
6403 
      (fname, ftype, fid) = iprot.readFieldBegin()
6404 
      if ftype == TType.STOP:
6405 
        break
6406 
      if fid == 0:
6407 
        if ftype == TType.STRUCT:
559 chandransh 6408 
          self.success = User()
94 ashish 6409 
          self.success.read(iprot)
6410 
        else:
6411 
          iprot.skip(ftype)
6412 
      elif fid == 1:
6413 
        if ftype == TType.STRUCT:
559 chandransh 6414 
          self.auex = AuthenticationException()
6415 
          self.auex.read(iprot)
94 ashish 6416 
        else:
6417 
          iprot.skip(ftype)
6418 
      else:
6419 
        iprot.skip(ftype)
6420 
      iprot.readFieldEnd()
6421 
    iprot.readStructEnd()
6422 
 
6423 
  def write(self, oprot):
6424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6426 
      return
559 chandransh 6427 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6428 
    if self.success is not None:
94 ashish 6429 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6430 
      self.success.write(oprot)
6431 
      oprot.writeFieldEnd()
3431 rajveer 6432 
    if self.auex is not None:
559 chandransh 6433 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6434 
      self.auex.write(oprot)
94 ashish 6435 
      oprot.writeFieldEnd()
6436 
    oprot.writeFieldStop()
6437 
    oprot.writeStructEnd()
6438 
 
3431 rajveer 6439 
  def validate(self):
6440 
    return
6441 
 
6442 
 
94 ashish 6443 
  def __repr__(self):
6444 
    L = ['%s=%r' % (key, value)
6445 
      for key, value in self.__dict__.iteritems()]
6446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6447 
 
6448 
  def __eq__(self, other):
6449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6450 
 
6451 
  def __ne__(self, other):
6452 
    return not (self == other)
6453 
 
559 chandransh 6454 
class userExists_args:
122 ashish 6455 
  """
6456 
  Attributes:
559 chandransh 6457 
   - email
122 ashish 6458 
  """
6459 
 
6460 
  thrift_spec = (
6461 
    None, # 0
559 chandransh 6462 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6463 
  )
6464 
 
559 chandransh 6465 
  def __init__(self, email=None,):
6466 
    self.email = email
122 ashish 6467 
 
6468 
  def read(self, iprot):
6469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6471 
      return
6472 
    iprot.readStructBegin()
6473 
    while True:
6474 
      (fname, ftype, fid) = iprot.readFieldBegin()
6475 
      if ftype == TType.STOP:
6476 
        break
6477 
      if fid == 1:
6478 
        if ftype == TType.STRING:
559 chandransh 6479 
          self.email = iprot.readString();
122 ashish 6480 
        else:
6481 
          iprot.skip(ftype)
559 chandransh 6482 
      else:
6483 
        iprot.skip(ftype)
6484 
      iprot.readFieldEnd()
6485 
    iprot.readStructEnd()
6486 
 
6487 
  def write(self, oprot):
6488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6490 
      return
6491 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6492 
    if self.email is not None:
559 chandransh 6493 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6494 
      oprot.writeString(self.email)
6495 
      oprot.writeFieldEnd()
6496 
    oprot.writeFieldStop()
6497 
    oprot.writeStructEnd()
6498 
 
3431 rajveer 6499 
  def validate(self):
6500 
    return
6501 
 
6502 
 
559 chandransh 6503 
  def __repr__(self):
6504 
    L = ['%s=%r' % (key, value)
6505 
      for key, value in self.__dict__.iteritems()]
6506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6507 
 
6508 
  def __eq__(self, other):
6509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6510 
 
6511 
  def __ne__(self, other):
6512 
    return not (self == other)
6513 
 
6514 
class userExists_result:
6515 
  """
6516 
  Attributes:
6517 
   - success
6518 
   - ucx
6519 
  """
6520 
 
6521 
  thrift_spec = (
6522 
    (0, TType.BOOL, 'success', None, None, ), # 0
6523 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6524 
  )
6525 
 
6526 
  def __init__(self, success=None, ucx=None,):
6527 
    self.success = success
6528 
    self.ucx = ucx
6529 
 
6530 
  def read(self, iprot):
6531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6533 
      return
6534 
    iprot.readStructBegin()
6535 
    while True:
6536 
      (fname, ftype, fid) = iprot.readFieldBegin()
6537 
      if ftype == TType.STOP:
6538 
        break
6539 
      if fid == 0:
6540 
        if ftype == TType.BOOL:
6541 
          self.success = iprot.readBool();
6542 
        else:
6543 
          iprot.skip(ftype)
6544 
      elif fid == 1:
6545 
        if ftype == TType.STRUCT:
6546 
          self.ucx = UserContextException()
6547 
          self.ucx.read(iprot)
6548 
        else:
6549 
          iprot.skip(ftype)
6550 
      else:
6551 
        iprot.skip(ftype)
6552 
      iprot.readFieldEnd()
6553 
    iprot.readStructEnd()
6554 
 
6555 
  def write(self, oprot):
6556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6558 
      return
6559 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6560 
    if self.success is not None:
559 chandransh 6561 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6562 
      oprot.writeBool(self.success)
6563 
      oprot.writeFieldEnd()
3431 rajveer 6564 
    if self.ucx is not None:
559 chandransh 6565 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6566 
      self.ucx.write(oprot)
6567 
      oprot.writeFieldEnd()
6568 
    oprot.writeFieldStop()
6569 
    oprot.writeStructEnd()
6570 
 
3431 rajveer 6571 
  def validate(self):
6572 
    return
6573 
 
6574 
 
559 chandransh 6575 
  def __repr__(self):
6576 
    L = ['%s=%r' % (key, value)
6577 
      for key, value in self.__dict__.iteritems()]
6578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6579 
 
6580 
  def __eq__(self, other):
6581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6582 
 
6583 
  def __ne__(self, other):
6584 
    return not (self == other)
6585 
 
6586 
class addAddressForUser_args:
6587 
  """
6588 
  Attributes:
6589 
   - userId
6590 
   - address
6591 
   - setDefault
6592 
  """
6593 
 
6594 
  thrift_spec = (
6595 
    None, # 0
6596 
    (1, TType.I64, 'userId', None, None, ), # 1
6597 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6598 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6599 
  )
6600 
 
567 rajveer 6601 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6602 
    self.userId = userId
6603 
    self.address = address
6604 
    self.setDefault = setDefault
6605 
 
6606 
  def read(self, iprot):
6607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6609 
      return
6610 
    iprot.readStructBegin()
6611 
    while True:
6612 
      (fname, ftype, fid) = iprot.readFieldBegin()
6613 
      if ftype == TType.STOP:
6614 
        break
6615 
      if fid == 1:
6616 
        if ftype == TType.I64:
6617 
          self.userId = iprot.readI64();
6618 
        else:
6619 
          iprot.skip(ftype)
122 ashish 6620 
      elif fid == 2:
559 chandransh 6621 
        if ftype == TType.STRUCT:
6622 
          self.address = Address()
6623 
          self.address.read(iprot)
122 ashish 6624 
        else:
6625 
          iprot.skip(ftype)
6626 
      elif fid == 3:
6627 
        if ftype == TType.BOOL:
559 chandransh 6628 
          self.setDefault = iprot.readBool();
122 ashish 6629 
        else:
6630 
          iprot.skip(ftype)
6631 
      else:
6632 
        iprot.skip(ftype)
6633 
      iprot.readFieldEnd()
6634 
    iprot.readStructEnd()
6635 
 
6636 
  def write(self, oprot):
6637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6639 
      return
559 chandransh 6640 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6641 
    if self.userId is not None:
559 chandransh 6642 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6643 
      oprot.writeI64(self.userId)
122 ashish 6644 
      oprot.writeFieldEnd()
3431 rajveer 6645 
    if self.address is not None:
559 chandransh 6646 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6647 
      self.address.write(oprot)
122 ashish 6648 
      oprot.writeFieldEnd()
3431 rajveer 6649 
    if self.setDefault is not None:
567 rajveer 6650 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6651 
      oprot.writeBool(self.setDefault)
6652 
      oprot.writeFieldEnd()
122 ashish 6653 
    oprot.writeFieldStop()
6654 
    oprot.writeStructEnd()
6655 
 
3431 rajveer 6656 
  def validate(self):
6657 
    return
6658 
 
6659 
 
122 ashish 6660 
  def __repr__(self):
6661 
    L = ['%s=%r' % (key, value)
6662 
      for key, value in self.__dict__.iteritems()]
6663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6664 
 
6665 
  def __eq__(self, other):
6666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6667 
 
6668 
  def __ne__(self, other):
6669 
    return not (self == other)
6670 
 
559 chandransh 6671 
class addAddressForUser_result:
122 ashish 6672 
  """
6673 
  Attributes:
6674 
   - success
559 chandransh 6675 
   - ucx
122 ashish 6676 
  """
6677 
 
6678 
  thrift_spec = (
567 rajveer 6679 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6680 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6681 
  )
6682 
 
559 chandransh 6683 
  def __init__(self, success=None, ucx=None,):
122 ashish 6684 
    self.success = success
559 chandransh 6685 
    self.ucx = ucx
122 ashish 6686 
 
6687 
  def read(self, iprot):
6688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6690 
      return
6691 
    iprot.readStructBegin()
6692 
    while True:
6693 
      (fname, ftype, fid) = iprot.readFieldBegin()
6694 
      if ftype == TType.STOP:
6695 
        break
6696 
      if fid == 0:
567 rajveer 6697 
        if ftype == TType.I64:
6698 
          self.success = iprot.readI64();
122 ashish 6699 
        else:
6700 
          iprot.skip(ftype)
6701 
      elif fid == 1:
6702 
        if ftype == TType.STRUCT:
559 chandransh 6703 
          self.ucx = UserContextException()
6704 
          self.ucx.read(iprot)
122 ashish 6705 
        else:
6706 
          iprot.skip(ftype)
6707 
      else:
6708 
        iprot.skip(ftype)
6709 
      iprot.readFieldEnd()
6710 
    iprot.readStructEnd()
6711 
 
6712 
  def write(self, oprot):
6713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6715 
      return
559 chandransh 6716 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6717 
    if self.success is not None:
567 rajveer 6718 
      oprot.writeFieldBegin('success', TType.I64, 0)
6719 
      oprot.writeI64(self.success)
122 ashish 6720 
      oprot.writeFieldEnd()
3431 rajveer 6721 
    if self.ucx is not None:
559 chandransh 6722 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6723 
      self.ucx.write(oprot)
122 ashish 6724 
      oprot.writeFieldEnd()
6725 
    oprot.writeFieldStop()
6726 
    oprot.writeStructEnd()
6727 
 
3431 rajveer 6728 
  def validate(self):
6729 
    return
6730 
 
6731 
 
122 ashish 6732 
  def __repr__(self):
6733 
    L = ['%s=%r' % (key, value)
6734 
      for key, value in self.__dict__.iteritems()]
6735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6736 
 
6737 
  def __eq__(self, other):
6738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6739 
 
6740 
  def __ne__(self, other):
6741 
    return not (self == other)
6742 
 
559 chandransh 6743 
class removeAddressForUser_args:
94 ashish 6744 
  """
6745 
  Attributes:
559 chandransh 6746 
   - userid
6747 
   - addressId
94 ashish 6748 
  """
6749 
 
6750 
  thrift_spec = (
6751 
    None, # 0
559 chandransh 6752 
    (1, TType.I64, 'userid', None, None, ), # 1
6753 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6754 
  )
6755 
 
559 chandransh 6756 
  def __init__(self, userid=None, addressId=None,):
6757 
    self.userid = userid
6758 
    self.addressId = addressId
94 ashish 6759 
 
6760 
  def read(self, iprot):
6761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6763 
      return
6764 
    iprot.readStructBegin()
6765 
    while True:
6766 
      (fname, ftype, fid) = iprot.readFieldBegin()
6767 
      if ftype == TType.STOP:
6768 
        break
6769 
      if fid == 1:
559 chandransh 6770 
        if ftype == TType.I64:
6771 
          self.userid = iprot.readI64();
94 ashish 6772 
        else:
6773 
          iprot.skip(ftype)
559 chandransh 6774 
      elif fid == 2:
6775 
        if ftype == TType.I64:
6776 
          self.addressId = iprot.readI64();
6777 
        else:
6778 
          iprot.skip(ftype)
94 ashish 6779 
      else:
6780 
        iprot.skip(ftype)
6781 
      iprot.readFieldEnd()
6782 
    iprot.readStructEnd()
6783 
 
6784 
  def write(self, oprot):
6785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6787 
      return
559 chandransh 6788 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6789 
    if self.userid is not None:
559 chandransh 6790 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6791 
      oprot.writeI64(self.userid)
94 ashish 6792 
      oprot.writeFieldEnd()
3431 rajveer 6793 
    if self.addressId is not None:
559 chandransh 6794 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6795 
      oprot.writeI64(self.addressId)
6796 
      oprot.writeFieldEnd()
94 ashish 6797 
    oprot.writeFieldStop()
6798 
    oprot.writeStructEnd()
6799 
 
3431 rajveer 6800 
  def validate(self):
6801 
    return
6802 
 
6803 
 
94 ashish 6804 
  def __repr__(self):
6805 
    L = ['%s=%r' % (key, value)
6806 
      for key, value in self.__dict__.iteritems()]
6807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6808 
 
6809 
  def __eq__(self, other):
6810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6811 
 
6812 
  def __ne__(self, other):
6813 
    return not (self == other)
6814 
 
559 chandransh 6815 
class removeAddressForUser_result:
94 ashish 6816 
  """
6817 
  Attributes:
6818 
   - success
6819 
   - ucx
6820 
  """
6821 
 
6822 
  thrift_spec = (
6823 
    (0, TType.BOOL, 'success', None, None, ), # 0
6824 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6825 
  )
6826 
 
6827 
  def __init__(self, success=None, ucx=None,):
6828 
    self.success = success
6829 
    self.ucx = ucx
6830 
 
6831 
  def read(self, iprot):
6832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6834 
      return
6835 
    iprot.readStructBegin()
6836 
    while True:
6837 
      (fname, ftype, fid) = iprot.readFieldBegin()
6838 
      if ftype == TType.STOP:
6839 
        break
6840 
      if fid == 0:
6841 
        if ftype == TType.BOOL:
6842 
          self.success = iprot.readBool();
6843 
        else:
6844 
          iprot.skip(ftype)
6845 
      elif fid == 1:
6846 
        if ftype == TType.STRUCT:
6847 
          self.ucx = UserContextException()
6848 
          self.ucx.read(iprot)
6849 
        else:
6850 
          iprot.skip(ftype)
6851 
      else:
6852 
        iprot.skip(ftype)
6853 
      iprot.readFieldEnd()
6854 
    iprot.readStructEnd()
6855 
 
6856 
  def write(self, oprot):
6857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6859 
      return
559 chandransh 6860 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6861 
    if self.success is not None:
94 ashish 6862 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6863 
      oprot.writeBool(self.success)
6864 
      oprot.writeFieldEnd()
3431 rajveer 6865 
    if self.ucx is not None:
94 ashish 6866 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6867 
      self.ucx.write(oprot)
6868 
      oprot.writeFieldEnd()
6869 
    oprot.writeFieldStop()
6870 
    oprot.writeStructEnd()
6871 
 
3431 rajveer 6872 
  def validate(self):
6873 
    return
6874 
 
6875 
 
94 ashish 6876 
  def __repr__(self):
6877 
    L = ['%s=%r' % (key, value)
6878 
      for key, value in self.__dict__.iteritems()]
6879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6880 
 
6881 
  def __eq__(self, other):
6882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6883 
 
6884 
  def __ne__(self, other):
6885 
    return not (self == other)
6886 
 
22358 ashik.ali 6887 
class updateAddress_args:
6888 
  """
6889 
  Attributes:
6890 
   - address
6891 
  """
6892 
 
6893 
  thrift_spec = (
6894 
    None, # 0
6895 
    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
6896 
  )
6897 
 
6898 
  def __init__(self, address=None,):
6899 
    self.address = address
6900 
 
6901 
  def read(self, iprot):
6902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6904 
      return
6905 
    iprot.readStructBegin()
6906 
    while True:
6907 
      (fname, ftype, fid) = iprot.readFieldBegin()
6908 
      if ftype == TType.STOP:
6909 
        break
6910 
      if fid == 1:
6911 
        if ftype == TType.STRUCT:
6912 
          self.address = Address()
6913 
          self.address.read(iprot)
6914 
        else:
6915 
          iprot.skip(ftype)
6916 
      else:
6917 
        iprot.skip(ftype)
6918 
      iprot.readFieldEnd()
6919 
    iprot.readStructEnd()
6920 
 
6921 
  def write(self, oprot):
6922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6924 
      return
6925 
    oprot.writeStructBegin('updateAddress_args')
6926 
    if self.address is not None:
6927 
      oprot.writeFieldBegin('address', TType.STRUCT, 1)
6928 
      self.address.write(oprot)
6929 
      oprot.writeFieldEnd()
6930 
    oprot.writeFieldStop()
6931 
    oprot.writeStructEnd()
6932 
 
6933 
  def validate(self):
6934 
    return
6935 
 
6936 
 
6937 
  def __repr__(self):
6938 
    L = ['%s=%r' % (key, value)
6939 
      for key, value in self.__dict__.iteritems()]
6940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6941 
 
6942 
  def __eq__(self, other):
6943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6944 
 
6945 
  def __ne__(self, other):
6946 
    return not (self == other)
6947 
 
6948 
class updateAddress_result:
6949 
  """
6950 
  Attributes:
6951 
   - success
6952 
   - ucx
6953 
  """
6954 
 
6955 
  thrift_spec = (
6956 
    (0, TType.BOOL, 'success', None, None, ), # 0
6957 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6958 
  )
6959 
 
6960 
  def __init__(self, success=None, ucx=None,):
6961 
    self.success = success
6962 
    self.ucx = ucx
6963 
 
6964 
  def read(self, iprot):
6965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6967 
      return
6968 
    iprot.readStructBegin()
6969 
    while True:
6970 
      (fname, ftype, fid) = iprot.readFieldBegin()
6971 
      if ftype == TType.STOP:
6972 
        break
6973 
      if fid == 0:
6974 
        if ftype == TType.BOOL:
6975 
          self.success = iprot.readBool();
6976 
        else:
6977 
          iprot.skip(ftype)
6978 
      elif fid == 1:
6979 
        if ftype == TType.STRUCT:
6980 
          self.ucx = UserContextException()
6981 
          self.ucx.read(iprot)
6982 
        else:
6983 
          iprot.skip(ftype)
6984 
      else:
6985 
        iprot.skip(ftype)
6986 
      iprot.readFieldEnd()
6987 
    iprot.readStructEnd()
6988 
 
6989 
  def write(self, oprot):
6990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6992 
      return
6993 
    oprot.writeStructBegin('updateAddress_result')
6994 
    if self.success is not None:
6995 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6996 
      oprot.writeBool(self.success)
6997 
      oprot.writeFieldEnd()
6998 
    if self.ucx is not None:
6999 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7000 
      self.ucx.write(oprot)
7001 
      oprot.writeFieldEnd()
7002 
    oprot.writeFieldStop()
7003 
    oprot.writeStructEnd()
7004 
 
7005 
  def validate(self):
7006 
    return
7007 
 
7008 
 
7009 
  def __repr__(self):
7010 
    L = ['%s=%r' % (key, value)
7011 
      for key, value in self.__dict__.iteritems()]
7012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7013 
 
7014 
  def __eq__(self, other):
7015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7016 
 
7017 
  def __ne__(self, other):
7018 
    return not (self == other)
7019 
 
22364 ashik.ali 7020 
class updateCounter_args:
7021 
  """
7022 
  Attributes:
7023 
   - counter
7024 
  """
7025 
 
7026 
  thrift_spec = (
7027 
    None, # 0
7028 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
7029 
  )
7030 
 
7031 
  def __init__(self, counter=None,):
7032 
    self.counter = counter
7033 
 
7034 
  def read(self, iprot):
7035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7037 
      return
7038 
    iprot.readStructBegin()
7039 
    while True:
7040 
      (fname, ftype, fid) = iprot.readFieldBegin()
7041 
      if ftype == TType.STOP:
7042 
        break
7043 
      if fid == 1:
7044 
        if ftype == TType.STRUCT:
7045 
          self.counter = Counter()
7046 
          self.counter.read(iprot)
7047 
        else:
7048 
          iprot.skip(ftype)
7049 
      else:
7050 
        iprot.skip(ftype)
7051 
      iprot.readFieldEnd()
7052 
    iprot.readStructEnd()
7053 
 
7054 
  def write(self, oprot):
7055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7057 
      return
7058 
    oprot.writeStructBegin('updateCounter_args')
7059 
    if self.counter is not None:
7060 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
7061 
      self.counter.write(oprot)
7062 
      oprot.writeFieldEnd()
7063 
    oprot.writeFieldStop()
7064 
    oprot.writeStructEnd()
7065 
 
7066 
  def validate(self):
7067 
    return
7068 
 
7069 
 
7070 
  def __repr__(self):
7071 
    L = ['%s=%r' % (key, value)
7072 
      for key, value in self.__dict__.iteritems()]
7073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7074 
 
7075 
  def __eq__(self, other):
7076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7077 
 
7078 
  def __ne__(self, other):
7079 
    return not (self == other)
7080 
 
7081 
class updateCounter_result:
7082 
  """
7083 
  Attributes:
7084 
   - success
7085 
   - ucx
7086 
  """
7087 
 
7088 
  thrift_spec = (
7089 
    (0, TType.BOOL, 'success', None, None, ), # 0
7090 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7091 
  )
7092 
 
7093 
  def __init__(self, success=None, ucx=None,):
7094 
    self.success = success
7095 
    self.ucx = ucx
7096 
 
7097 
  def read(self, iprot):
7098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7100 
      return
7101 
    iprot.readStructBegin()
7102 
    while True:
7103 
      (fname, ftype, fid) = iprot.readFieldBegin()
7104 
      if ftype == TType.STOP:
7105 
        break
7106 
      if fid == 0:
7107 
        if ftype == TType.BOOL:
7108 
          self.success = iprot.readBool();
7109 
        else:
7110 
          iprot.skip(ftype)
7111 
      elif fid == 1:
7112 
        if ftype == TType.STRUCT:
7113 
          self.ucx = UserContextException()
7114 
          self.ucx.read(iprot)
7115 
        else:
7116 
          iprot.skip(ftype)
7117 
      else:
7118 
        iprot.skip(ftype)
7119 
      iprot.readFieldEnd()
7120 
    iprot.readStructEnd()
7121 
 
7122 
  def write(self, oprot):
7123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7125 
      return
7126 
    oprot.writeStructBegin('updateCounter_result')
7127 
    if self.success is not None:
7128 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7129 
      oprot.writeBool(self.success)
7130 
      oprot.writeFieldEnd()
7131 
    if self.ucx is not None:
7132 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7133 
      self.ucx.write(oprot)
7134 
      oprot.writeFieldEnd()
7135 
    oprot.writeFieldStop()
7136 
    oprot.writeStructEnd()
7137 
 
7138 
  def validate(self):
7139 
    return
7140 
 
7141 
 
7142 
  def __repr__(self):
7143 
    L = ['%s=%r' % (key, value)
7144 
      for key, value in self.__dict__.iteritems()]
7145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7146 
 
7147 
  def __eq__(self, other):
7148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7149 
 
7150 
  def __ne__(self, other):
7151 
    return not (self == other)
7152 
 
559 chandransh 7153 
class setUserAsLoggedIn_args:
94 ashish 7154 
  """
7155 
  Attributes:
559 chandransh 7156 
   - userId
94 ashish 7157 
   - timestamp
7158 
  """
7159 
 
7160 
  thrift_spec = (
7161 
    None, # 0
559 chandransh 7162 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 7163 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7164 
  )
7165 
 
559 chandransh 7166 
  def __init__(self, userId=None, timestamp=None,):
7167 
    self.userId = userId
94 ashish 7168 
    self.timestamp = timestamp
7169 
 
7170 
  def read(self, iprot):
7171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7173 
      return
7174 
    iprot.readStructBegin()
7175 
    while True:
7176 
      (fname, ftype, fid) = iprot.readFieldBegin()
7177 
      if ftype == TType.STOP:
7178 
        break
7179 
      if fid == 1:
559 chandransh 7180 
        if ftype == TType.I64:
7181 
          self.userId = iprot.readI64();
94 ashish 7182 
        else:
7183 
          iprot.skip(ftype)
7184 
      elif fid == 2:
7185 
        if ftype == TType.I64:
7186 
          self.timestamp = iprot.readI64();
7187 
        else:
7188 
          iprot.skip(ftype)
7189 
      else:
7190 
        iprot.skip(ftype)
7191 
      iprot.readFieldEnd()
7192 
    iprot.readStructEnd()
7193 
 
7194 
  def write(self, oprot):
7195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7197 
      return
559 chandransh 7198 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 7199 
    if self.userId is not None:
559 chandransh 7200 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7201 
      oprot.writeI64(self.userId)
94 ashish 7202 
      oprot.writeFieldEnd()
3431 rajveer 7203 
    if self.timestamp is not None:
94 ashish 7204 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7205 
      oprot.writeI64(self.timestamp)
7206 
      oprot.writeFieldEnd()
7207 
    oprot.writeFieldStop()
7208 
    oprot.writeStructEnd()
7209 
 
3431 rajveer 7210 
  def validate(self):
7211 
    return
7212 
 
7213 
 
94 ashish 7214 
  def __repr__(self):
7215 
    L = ['%s=%r' % (key, value)
7216 
      for key, value in self.__dict__.iteritems()]
7217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7218 
 
7219 
  def __eq__(self, other):
7220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7221 
 
7222 
  def __ne__(self, other):
7223 
    return not (self == other)
7224 
 
559 chandransh 7225 
class setUserAsLoggedIn_result:
94 ashish 7226 
  """
7227 
  Attributes:
7228 
   - success
7229 
   - ucx
7230 
  """
7231 
 
7232 
  thrift_spec = (
7233 
    (0, TType.BOOL, 'success', None, None, ), # 0
7234 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7235 
  )
7236 
 
7237 
  def __init__(self, success=None, ucx=None,):
7238 
    self.success = success
7239 
    self.ucx = ucx
7240 
 
7241 
  def read(self, iprot):
7242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7244 
      return
7245 
    iprot.readStructBegin()
7246 
    while True:
7247 
      (fname, ftype, fid) = iprot.readFieldBegin()
7248 
      if ftype == TType.STOP:
7249 
        break
7250 
      if fid == 0:
7251 
        if ftype == TType.BOOL:
7252 
          self.success = iprot.readBool();
7253 
        else:
7254 
          iprot.skip(ftype)
7255 
      elif fid == 1:
7256 
        if ftype == TType.STRUCT:
7257 
          self.ucx = UserContextException()
7258 
          self.ucx.read(iprot)
7259 
        else:
7260 
          iprot.skip(ftype)
7261 
      else:
7262 
        iprot.skip(ftype)
7263 
      iprot.readFieldEnd()
7264 
    iprot.readStructEnd()
7265 
 
7266 
  def write(self, oprot):
7267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7269 
      return
559 chandransh 7270 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 7271 
    if self.success is not None:
94 ashish 7272 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7273 
      oprot.writeBool(self.success)
7274 
      oprot.writeFieldEnd()
3431 rajveer 7275 
    if self.ucx is not None:
94 ashish 7276 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7277 
      self.ucx.write(oprot)
7278 
      oprot.writeFieldEnd()
7279 
    oprot.writeFieldStop()
7280 
    oprot.writeStructEnd()
7281 
 
3431 rajveer 7282 
  def validate(self):
7283 
    return
7284 
 
7285 
 
94 ashish 7286 
  def __repr__(self):
7287 
    L = ['%s=%r' % (key, value)
7288 
      for key, value in self.__dict__.iteritems()]
7289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7290 
 
7291 
  def __eq__(self, other):
7292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7293 
 
7294 
  def __ne__(self, other):
7295 
    return not (self == other)
7296 
 
559 chandransh 7297 
class setUserAsLoggedOut_args:
94 ashish 7298 
  """
7299 
  Attributes:
7300 
   - userid
7301 
   - timestamp
7302 
  """
7303 
 
7304 
  thrift_spec = (
7305 
    None, # 0
559 chandransh 7306 
    (1, TType.I64, 'userid', None, None, ), # 1
7307 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 7308 
  )
7309 
 
559 chandransh 7310 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 7311 
    self.userid = userid
7312 
    self.timestamp = timestamp
7313 
 
7314 
  def read(self, iprot):
7315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7317 
      return
7318 
    iprot.readStructBegin()
7319 
    while True:
7320 
      (fname, ftype, fid) = iprot.readFieldBegin()
7321 
      if ftype == TType.STOP:
7322 
        break
7323 
      if fid == 1:
7324 
        if ftype == TType.I64:
7325 
          self.userid = iprot.readI64();
7326 
        else:
7327 
          iprot.skip(ftype)
559 chandransh 7328 
      elif fid == 2:
94 ashish 7329 
        if ftype == TType.I64:
7330 
          self.timestamp = iprot.readI64();
7331 
        else:
7332 
          iprot.skip(ftype)
7333 
      else:
7334 
        iprot.skip(ftype)
7335 
      iprot.readFieldEnd()
7336 
    iprot.readStructEnd()
7337 
 
7338 
  def write(self, oprot):
7339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7341 
      return
559 chandransh 7342 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 7343 
    if self.userid is not None:
559 chandransh 7344 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 7345 
      oprot.writeI64(self.userid)
7346 
      oprot.writeFieldEnd()
3431 rajveer 7347 
    if self.timestamp is not None:
559 chandransh 7348 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 7349 
      oprot.writeI64(self.timestamp)
7350 
      oprot.writeFieldEnd()
7351 
    oprot.writeFieldStop()
7352 
    oprot.writeStructEnd()
7353 
 
3431 rajveer 7354 
  def validate(self):
7355 
    return
7356 
 
7357 
 
94 ashish 7358 
  def __repr__(self):
7359 
    L = ['%s=%r' % (key, value)
7360 
      for key, value in self.__dict__.iteritems()]
7361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7362 
 
7363 
  def __eq__(self, other):
7364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7365 
 
7366 
  def __ne__(self, other):
7367 
    return not (self == other)
7368 
 
559 chandransh 7369 
class setUserAsLoggedOut_result:
94 ashish 7370 
  """
7371 
  Attributes:
7372 
   - success
7373 
   - ucx
7374 
  """
7375 
 
7376 
  thrift_spec = (
7377 
    (0, TType.BOOL, 'success', None, None, ), # 0
7378 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7379 
  )
7380 
 
7381 
  def __init__(self, success=None, ucx=None,):
7382 
    self.success = success
7383 
    self.ucx = ucx
7384 
 
7385 
  def read(self, iprot):
7386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7388 
      return
7389 
    iprot.readStructBegin()
7390 
    while True:
7391 
      (fname, ftype, fid) = iprot.readFieldBegin()
7392 
      if ftype == TType.STOP:
7393 
        break
7394 
      if fid == 0:
7395 
        if ftype == TType.BOOL:
7396 
          self.success = iprot.readBool();
7397 
        else:
7398 
          iprot.skip(ftype)
7399 
      elif fid == 1:
7400 
        if ftype == TType.STRUCT:
7401 
          self.ucx = UserContextException()
7402 
          self.ucx.read(iprot)
7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      else:
7406 
        iprot.skip(ftype)
7407 
      iprot.readFieldEnd()
7408 
    iprot.readStructEnd()
7409 
 
7410 
  def write(self, oprot):
7411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7413 
      return
559 chandransh 7414 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 7415 
    if self.success is not None:
94 ashish 7416 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7417 
      oprot.writeBool(self.success)
7418 
      oprot.writeFieldEnd()
3431 rajveer 7419 
    if self.ucx is not None:
94 ashish 7420 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7421 
      self.ucx.write(oprot)
7422 
      oprot.writeFieldEnd()
7423 
    oprot.writeFieldStop()
7424 
    oprot.writeStructEnd()
7425 
 
3431 rajveer 7426 
  def validate(self):
7427 
    return
7428 
 
7429 
 
94 ashish 7430 
  def __repr__(self):
7431 
    L = ['%s=%r' % (key, value)
7432 
      for key, value in self.__dict__.iteritems()]
7433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7434 
 
7435 
  def __eq__(self, other):
7436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7437 
 
7438 
  def __ne__(self, other):
7439 
    return not (self == other)
7440 
 
559 chandransh 7441 
class setDefaultAddress_args:
94 ashish 7442 
  """
7443 
  Attributes:
7444 
   - userid
7445 
   - addressId
7446 
  """
7447 
 
7448 
  thrift_spec = (
7449 
    None, # 0
7450 
    (1, TType.I64, 'userid', None, None, ), # 1
7451 
    (2, TType.I64, 'addressId', None, None, ), # 2
7452 
  )
7453 
 
7454 
  def __init__(self, userid=None, addressId=None,):
7455 
    self.userid = userid
7456 
    self.addressId = addressId
7457 
 
7458 
  def read(self, iprot):
7459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7461 
      return
7462 
    iprot.readStructBegin()
7463 
    while True:
7464 
      (fname, ftype, fid) = iprot.readFieldBegin()
7465 
      if ftype == TType.STOP:
7466 
        break
7467 
      if fid == 1:
7468 
        if ftype == TType.I64:
7469 
          self.userid = iprot.readI64();
7470 
        else:
7471 
          iprot.skip(ftype)
7472 
      elif fid == 2:
7473 
        if ftype == TType.I64:
7474 
          self.addressId = iprot.readI64();
7475 
        else:
7476 
          iprot.skip(ftype)
7477 
      else:
7478 
        iprot.skip(ftype)
7479 
      iprot.readFieldEnd()
7480 
    iprot.readStructEnd()
7481 
 
7482 
  def write(self, oprot):
7483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7485 
      return
559 chandransh 7486 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7487 
    if self.userid is not None:
94 ashish 7488 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7489 
      oprot.writeI64(self.userid)
7490 
      oprot.writeFieldEnd()
3431 rajveer 7491 
    if self.addressId is not None:
94 ashish 7492 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7493 
      oprot.writeI64(self.addressId)
7494 
      oprot.writeFieldEnd()
7495 
    oprot.writeFieldStop()
7496 
    oprot.writeStructEnd()
7497 
 
3431 rajveer 7498 
  def validate(self):
7499 
    return
7500 
 
7501 
 
94 ashish 7502 
  def __repr__(self):
7503 
    L = ['%s=%r' % (key, value)
7504 
      for key, value in self.__dict__.iteritems()]
7505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7506 
 
7507 
  def __eq__(self, other):
7508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7509 
 
7510 
  def __ne__(self, other):
7511 
    return not (self == other)
7512 
 
559 chandransh 7513 
class setDefaultAddress_result:
94 ashish 7514 
  """
7515 
  Attributes:
7516 
   - success
7517 
   - ucx
7518 
  """
7519 
 
7520 
  thrift_spec = (
7521 
    (0, TType.BOOL, 'success', None, None, ), # 0
7522 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7523 
  )
7524 
 
7525 
  def __init__(self, success=None, ucx=None,):
7526 
    self.success = success
7527 
    self.ucx = ucx
7528 
 
7529 
  def read(self, iprot):
7530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7532 
      return
7533 
    iprot.readStructBegin()
7534 
    while True:
7535 
      (fname, ftype, fid) = iprot.readFieldBegin()
7536 
      if ftype == TType.STOP:
7537 
        break
7538 
      if fid == 0:
7539 
        if ftype == TType.BOOL:
7540 
          self.success = iprot.readBool();
7541 
        else:
7542 
          iprot.skip(ftype)
7543 
      elif fid == 1:
7544 
        if ftype == TType.STRUCT:
7545 
          self.ucx = UserContextException()
7546 
          self.ucx.read(iprot)
7547 
        else:
7548 
          iprot.skip(ftype)
7549 
      else:
7550 
        iprot.skip(ftype)
7551 
      iprot.readFieldEnd()
7552 
    iprot.readStructEnd()
7553 
 
7554 
  def write(self, oprot):
7555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7557 
      return
559 chandransh 7558 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7559 
    if self.success is not None:
94 ashish 7560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7561 
      oprot.writeBool(self.success)
7562 
      oprot.writeFieldEnd()
3431 rajveer 7563 
    if self.ucx is not None:
94 ashish 7564 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7565 
      self.ucx.write(oprot)
7566 
      oprot.writeFieldEnd()
7567 
    oprot.writeFieldStop()
7568 
    oprot.writeStructEnd()
7569 
 
3431 rajveer 7570 
  def validate(self):
7571 
    return
7572 
 
7573 
 
94 ashish 7574 
  def __repr__(self):
7575 
    L = ['%s=%r' % (key, value)
7576 
      for key, value in self.__dict__.iteritems()]
7577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7578 
 
7579 
  def __eq__(self, other):
7580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7581 
 
7582 
  def __ne__(self, other):
7583 
    return not (self == other)
7584 
 
559 chandransh 7585 
class updatePassword_args:
94 ashish 7586 
  """
7587 
  Attributes:
559 chandransh 7588 
   - userid
594 rajveer 7589 
   - oldPassword
7590 
   - newPassword
94 ashish 7591 
  """
7592 
 
7593 
  thrift_spec = (
7594 
    None, # 0
559 chandransh 7595 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7596 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7597 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7598 
  )
7599 
 
594 rajveer 7600 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7601 
    self.userid = userid
594 rajveer 7602 
    self.oldPassword = oldPassword
7603 
    self.newPassword = newPassword
94 ashish 7604 
 
7605 
  def read(self, iprot):
7606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7608 
      return
7609 
    iprot.readStructBegin()
7610 
    while True:
7611 
      (fname, ftype, fid) = iprot.readFieldBegin()
7612 
      if ftype == TType.STOP:
7613 
        break
7614 
      if fid == 1:
7615 
        if ftype == TType.I64:
559 chandransh 7616 
          self.userid = iprot.readI64();
94 ashish 7617 
        else:
7618 
          iprot.skip(ftype)
7619 
      elif fid == 2:
559 chandransh 7620 
        if ftype == TType.STRING:
594 rajveer 7621 
          self.oldPassword = iprot.readString();
94 ashish 7622 
        else:
7623 
          iprot.skip(ftype)
594 rajveer 7624 
      elif fid == 3:
7625 
        if ftype == TType.STRING:
7626 
          self.newPassword = iprot.readString();
7627 
        else:
7628 
          iprot.skip(ftype)
94 ashish 7629 
      else:
7630 
        iprot.skip(ftype)
7631 
      iprot.readFieldEnd()
7632 
    iprot.readStructEnd()
7633 
 
7634 
  def write(self, oprot):
7635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7637 
      return
559 chandransh 7638 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7639 
    if self.userid is not None:
559 chandransh 7640 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7641 
      oprot.writeI64(self.userid)
94 ashish 7642 
      oprot.writeFieldEnd()
3431 rajveer 7643 
    if self.oldPassword is not None:
594 rajveer 7644 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7645 
      oprot.writeString(self.oldPassword)
94 ashish 7646 
      oprot.writeFieldEnd()
3431 rajveer 7647 
    if self.newPassword is not None:
594 rajveer 7648 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7649 
      oprot.writeString(self.newPassword)
7650 
      oprot.writeFieldEnd()
94 ashish 7651 
    oprot.writeFieldStop()
7652 
    oprot.writeStructEnd()
7653 
 
3431 rajveer 7654 
  def validate(self):
7655 
    return
7656 
 
7657 
 
94 ashish 7658 
  def __repr__(self):
7659 
    L = ['%s=%r' % (key, value)
7660 
      for key, value in self.__dict__.iteritems()]
7661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7662 
 
7663 
  def __eq__(self, other):
7664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7665 
 
7666 
  def __ne__(self, other):
7667 
    return not (self == other)
7668 
 
559 chandransh 7669 
class updatePassword_result:
94 ashish 7670 
  """
7671 
  Attributes:
7672 
   - success
7673 
   - ucx
7674 
  """
7675 
 
7676 
  thrift_spec = (
7677 
    (0, TType.BOOL, 'success', None, None, ), # 0
7678 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7679 
  )
7680 
 
7681 
  def __init__(self, success=None, ucx=None,):
7682 
    self.success = success
7683 
    self.ucx = ucx
7684 
 
7685 
  def read(self, iprot):
7686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7688 
      return
7689 
    iprot.readStructBegin()
7690 
    while True:
7691 
      (fname, ftype, fid) = iprot.readFieldBegin()
7692 
      if ftype == TType.STOP:
7693 
        break
7694 
      if fid == 0:
7695 
        if ftype == TType.BOOL:
7696 
          self.success = iprot.readBool();
7697 
        else:
7698 
          iprot.skip(ftype)
7699 
      elif fid == 1:
7700 
        if ftype == TType.STRUCT:
7701 
          self.ucx = UserContextException()
7702 
          self.ucx.read(iprot)
7703 
        else:
7704 
          iprot.skip(ftype)
7705 
      else:
7706 
        iprot.skip(ftype)
7707 
      iprot.readFieldEnd()
7708 
    iprot.readStructEnd()
7709 
 
7710 
  def write(self, oprot):
7711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7713 
      return
559 chandransh 7714 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7715 
    if self.success is not None:
94 ashish 7716 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7717 
      oprot.writeBool(self.success)
7718 
      oprot.writeFieldEnd()
3431 rajveer 7719 
    if self.ucx is not None:
94 ashish 7720 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7721 
      self.ucx.write(oprot)
7722 
      oprot.writeFieldEnd()
7723 
    oprot.writeFieldStop()
7724 
    oprot.writeStructEnd()
7725 
 
3431 rajveer 7726 
  def validate(self):
7727 
    return
7728 
 
7729 
 
94 ashish 7730 
  def __repr__(self):
7731 
    L = ['%s=%r' % (key, value)
7732 
      for key, value in self.__dict__.iteritems()]
7733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7734 
 
7735 
  def __eq__(self, other):
7736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7737 
 
7738 
  def __ne__(self, other):
7739 
    return not (self == other)
7740 
 
581 rajveer 7741 
class forgotPassword_args:
7742 
  """
7743 
  Attributes:
7744 
   - email
884 rajveer 7745 
   - newPassword
581 rajveer 7746 
  """
7747 
 
7748 
  thrift_spec = (
7749 
    None, # 0
7750 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7751 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7752 
  )
7753 
 
884 rajveer 7754 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7755 
    self.email = email
884 rajveer 7756 
    self.newPassword = newPassword
581 rajveer 7757 
 
7758 
  def read(self, iprot):
7759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7761 
      return
7762 
    iprot.readStructBegin()
7763 
    while True:
7764 
      (fname, ftype, fid) = iprot.readFieldBegin()
7765 
      if ftype == TType.STOP:
7766 
        break
7767 
      if fid == 1:
7768 
        if ftype == TType.STRING:
7769 
          self.email = iprot.readString();
7770 
        else:
7771 
          iprot.skip(ftype)
884 rajveer 7772 
      elif fid == 2:
7773 
        if ftype == TType.STRING:
7774 
          self.newPassword = iprot.readString();
7775 
        else:
7776 
          iprot.skip(ftype)
581 rajveer 7777 
      else:
7778 
        iprot.skip(ftype)
7779 
      iprot.readFieldEnd()
7780 
    iprot.readStructEnd()
7781 
 
7782 
  def write(self, oprot):
7783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7785 
      return
7786 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7787 
    if self.email is not None:
581 rajveer 7788 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7789 
      oprot.writeString(self.email)
7790 
      oprot.writeFieldEnd()
3431 rajveer 7791 
    if self.newPassword is not None:
884 rajveer 7792 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7793 
      oprot.writeString(self.newPassword)
7794 
      oprot.writeFieldEnd()
581 rajveer 7795 
    oprot.writeFieldStop()
7796 
    oprot.writeStructEnd()
7797 
 
3431 rajveer 7798 
  def validate(self):
7799 
    return
7800 
 
7801 
 
581 rajveer 7802 
  def __repr__(self):
7803 
    L = ['%s=%r' % (key, value)
7804 
      for key, value in self.__dict__.iteritems()]
7805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7806 
 
7807 
  def __eq__(self, other):
7808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7809 
 
7810 
  def __ne__(self, other):
7811 
    return not (self == other)
7812 
 
7813 
class forgotPassword_result:
7814 
  """
7815 
  Attributes:
7816 
   - success
7817 
   - ucx
7818 
  """
7819 
 
7820 
  thrift_spec = (
7821 
    (0, TType.BOOL, 'success', None, None, ), # 0
7822 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7823 
  )
7824 
 
7825 
  def __init__(self, success=None, ucx=None,):
7826 
    self.success = success
7827 
    self.ucx = ucx
7828 
 
7829 
  def read(self, iprot):
7830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7832 
      return
7833 
    iprot.readStructBegin()
7834 
    while True:
7835 
      (fname, ftype, fid) = iprot.readFieldBegin()
7836 
      if ftype == TType.STOP:
7837 
        break
7838 
      if fid == 0:
7839 
        if ftype == TType.BOOL:
7840 
          self.success = iprot.readBool();
7841 
        else:
7842 
          iprot.skip(ftype)
7843 
      elif fid == 1:
7844 
        if ftype == TType.STRUCT:
7845 
          self.ucx = UserContextException()
7846 
          self.ucx.read(iprot)
7847 
        else:
7848 
          iprot.skip(ftype)
7849 
      else:
7850 
        iprot.skip(ftype)
7851 
      iprot.readFieldEnd()
7852 
    iprot.readStructEnd()
7853 
 
7854 
  def write(self, oprot):
7855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7857 
      return
7858 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7859 
    if self.success is not None:
581 rajveer 7860 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7861 
      oprot.writeBool(self.success)
7862 
      oprot.writeFieldEnd()
3431 rajveer 7863 
    if self.ucx is not None:
581 rajveer 7864 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7865 
      self.ucx.write(oprot)
7866 
      oprot.writeFieldEnd()
7867 
    oprot.writeFieldStop()
7868 
    oprot.writeStructEnd()
7869 
 
3431 rajveer 7870 
  def validate(self):
7871 
    return
7872 
 
7873 
 
581 rajveer 7874 
  def __repr__(self):
7875 
    L = ['%s=%r' % (key, value)
7876 
      for key, value in self.__dict__.iteritems()]
7877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7878 
 
7879 
  def __eq__(self, other):
7880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7881 
 
7882 
  def __ne__(self, other):
7883 
    return not (self == other)
7884 
 
594 rajveer 7885 
class getAllAddressesForUser_args:
7886 
  """
7887 
  Attributes:
7888 
   - userId
7889 
  """
7890 
 
7891 
  thrift_spec = (
7892 
    None, # 0
7893 
    (1, TType.I64, 'userId', None, None, ), # 1
7894 
  )
7895 
 
7896 
  def __init__(self, userId=None,):
7897 
    self.userId = userId
7898 
 
7899 
  def read(self, iprot):
7900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7902 
      return
7903 
    iprot.readStructBegin()
7904 
    while True:
7905 
      (fname, ftype, fid) = iprot.readFieldBegin()
7906 
      if ftype == TType.STOP:
7907 
        break
7908 
      if fid == 1:
7909 
        if ftype == TType.I64:
7910 
          self.userId = iprot.readI64();
7911 
        else:
7912 
          iprot.skip(ftype)
7913 
      else:
7914 
        iprot.skip(ftype)
7915 
      iprot.readFieldEnd()
7916 
    iprot.readStructEnd()
7917 
 
7918 
  def write(self, oprot):
7919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7921 
      return
7922 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7923 
    if self.userId is not None:
594 rajveer 7924 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7925 
      oprot.writeI64(self.userId)
7926 
      oprot.writeFieldEnd()
7927 
    oprot.writeFieldStop()
7928 
    oprot.writeStructEnd()
7929 
 
3431 rajveer 7930 
  def validate(self):
7931 
    return
7932 
 
7933 
 
594 rajveer 7934 
  def __repr__(self):
7935 
    L = ['%s=%r' % (key, value)
7936 
      for key, value in self.__dict__.iteritems()]
7937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7938 
 
7939 
  def __eq__(self, other):
7940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7941 
 
7942 
  def __ne__(self, other):
7943 
    return not (self == other)
7944 
 
7945 
class getAllAddressesForUser_result:
7946 
  """
7947 
  Attributes:
7948 
   - success
7949 
   - ucx
7950 
  """
7951 
 
7952 
  thrift_spec = (
7953 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7954 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7955 
  )
7956 
 
7957 
  def __init__(self, success=None, ucx=None,):
7958 
    self.success = success
7959 
    self.ucx = ucx
7960 
 
7961 
  def read(self, iprot):
7962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7964 
      return
7965 
    iprot.readStructBegin()
7966 
    while True:
7967 
      (fname, ftype, fid) = iprot.readFieldBegin()
7968 
      if ftype == TType.STOP:
7969 
        break
7970 
      if fid == 0:
7971 
        if ftype == TType.LIST:
7972 
          self.success = []
11592 amit.gupta 7973 
          (_etype100, _size97) = iprot.readListBegin()
7974 
          for _i101 in xrange(_size97):
7975 
            _elem102 = Address()
7976 
            _elem102.read(iprot)
7977 
            self.success.append(_elem102)
594 rajveer 7978 
          iprot.readListEnd()
7979 
        else:
7980 
          iprot.skip(ftype)
7981 
      elif fid == 1:
7982 
        if ftype == TType.STRUCT:
7983 
          self.ucx = UserContextException()
7984 
          self.ucx.read(iprot)
7985 
        else:
7986 
          iprot.skip(ftype)
7987 
      else:
7988 
        iprot.skip(ftype)
7989 
      iprot.readFieldEnd()
7990 
    iprot.readStructEnd()
7991 
 
7992 
  def write(self, oprot):
7993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7995 
      return
7996 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7997 
    if self.success is not None:
594 rajveer 7998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8000 
      for iter103 in self.success:
8001 
        iter103.write(oprot)
594 rajveer 8002 
      oprot.writeListEnd()
8003 
      oprot.writeFieldEnd()
3431 rajveer 8004 
    if self.ucx is not None:
594 rajveer 8005 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8006 
      self.ucx.write(oprot)
8007 
      oprot.writeFieldEnd()
8008 
    oprot.writeFieldStop()
8009 
    oprot.writeStructEnd()
8010 
 
3431 rajveer 8011 
  def validate(self):
8012 
    return
8013 
 
8014 
 
594 rajveer 8015 
  def __repr__(self):
8016 
    L = ['%s=%r' % (key, value)
8017 
      for key, value in self.__dict__.iteritems()]
8018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8019 
 
8020 
  def __eq__(self, other):
8021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8022 
 
8023 
  def __ne__(self, other):
8024 
    return not (self == other)
8025 
 
1894 vikas 8026 
class getAddressById_args:
8027 
  """
8028 
  Attributes:
8029 
   - addressId
8030 
  """
8031 
 
8032 
  thrift_spec = (
8033 
    None, # 0
8034 
    (1, TType.I64, 'addressId', None, None, ), # 1
8035 
  )
8036 
 
8037 
  def __init__(self, addressId=None,):
8038 
    self.addressId = addressId
8039 
 
8040 
  def read(self, iprot):
8041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8043 
      return
8044 
    iprot.readStructBegin()
8045 
    while True:
8046 
      (fname, ftype, fid) = iprot.readFieldBegin()
8047 
      if ftype == TType.STOP:
8048 
        break
8049 
      if fid == 1:
8050 
        if ftype == TType.I64:
8051 
          self.addressId = iprot.readI64();
8052 
        else:
8053 
          iprot.skip(ftype)
8054 
      else:
8055 
        iprot.skip(ftype)
8056 
      iprot.readFieldEnd()
8057 
    iprot.readStructEnd()
8058 
 
8059 
  def write(self, oprot):
8060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8062 
      return
8063 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 8064 
    if self.addressId is not None:
1894 vikas 8065 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
8066 
      oprot.writeI64(self.addressId)
8067 
      oprot.writeFieldEnd()
8068 
    oprot.writeFieldStop()
8069 
    oprot.writeStructEnd()
8070 
 
3431 rajveer 8071 
  def validate(self):
8072 
    return
8073 
 
8074 
 
1894 vikas 8075 
  def __repr__(self):
8076 
    L = ['%s=%r' % (key, value)
8077 
      for key, value in self.__dict__.iteritems()]
8078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8079 
 
8080 
  def __eq__(self, other):
8081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8082 
 
8083 
  def __ne__(self, other):
8084 
    return not (self == other)
8085 
 
8086 
class getAddressById_result:
8087 
  """
8088 
  Attributes:
8089 
   - success
8090 
   - ucx
8091 
  """
8092 
 
8093 
  thrift_spec = (
8094 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
8095 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8096 
  )
8097 
 
8098 
  def __init__(self, success=None, ucx=None,):
8099 
    self.success = success
8100 
    self.ucx = ucx
8101 
 
8102 
  def read(self, iprot):
8103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8105 
      return
8106 
    iprot.readStructBegin()
8107 
    while True:
8108 
      (fname, ftype, fid) = iprot.readFieldBegin()
8109 
      if ftype == TType.STOP:
8110 
        break
8111 
      if fid == 0:
8112 
        if ftype == TType.STRUCT:
8113 
          self.success = Address()
8114 
          self.success.read(iprot)
8115 
        else:
8116 
          iprot.skip(ftype)
8117 
      elif fid == 1:
8118 
        if ftype == TType.STRUCT:
8119 
          self.ucx = UserContextException()
8120 
          self.ucx.read(iprot)
8121 
        else:
8122 
          iprot.skip(ftype)
8123 
      else:
8124 
        iprot.skip(ftype)
8125 
      iprot.readFieldEnd()
8126 
    iprot.readStructEnd()
8127 
 
8128 
  def write(self, oprot):
8129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8131 
      return
8132 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 8133 
    if self.success is not None:
1894 vikas 8134 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8135 
      self.success.write(oprot)
8136 
      oprot.writeFieldEnd()
3431 rajveer 8137 
    if self.ucx is not None:
1894 vikas 8138 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8139 
      self.ucx.write(oprot)
8140 
      oprot.writeFieldEnd()
8141 
    oprot.writeFieldStop()
8142 
    oprot.writeStructEnd()
8143 
 
3431 rajveer 8144 
  def validate(self):
8145 
    return
8146 
 
8147 
 
1894 vikas 8148 
  def __repr__(self):
8149 
    L = ['%s=%r' % (key, value)
8150 
      for key, value in self.__dict__.iteritems()]
8151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8152 
 
8153 
  def __eq__(self, other):
8154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8155 
 
8156 
  def __ne__(self, other):
8157 
    return not (self == other)
8158 
 
594 rajveer 8159 
class getDefaultAddressId_args:
8160 
  """
8161 
  Attributes:
8162 
   - userId
8163 
  """
8164 
 
8165 
  thrift_spec = (
8166 
    None, # 0
8167 
    (1, TType.I64, 'userId', None, None, ), # 1
8168 
  )
8169 
 
8170 
  def __init__(self, userId=None,):
8171 
    self.userId = userId
8172 
 
8173 
  def read(self, iprot):
8174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8176 
      return
8177 
    iprot.readStructBegin()
8178 
    while True:
8179 
      (fname, ftype, fid) = iprot.readFieldBegin()
8180 
      if ftype == TType.STOP:
8181 
        break
8182 
      if fid == 1:
8183 
        if ftype == TType.I64:
8184 
          self.userId = iprot.readI64();
8185 
        else:
8186 
          iprot.skip(ftype)
8187 
      else:
8188 
        iprot.skip(ftype)
8189 
      iprot.readFieldEnd()
8190 
    iprot.readStructEnd()
8191 
 
8192 
  def write(self, oprot):
8193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8195 
      return
8196 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 8197 
    if self.userId is not None:
594 rajveer 8198 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8199 
      oprot.writeI64(self.userId)
8200 
      oprot.writeFieldEnd()
8201 
    oprot.writeFieldStop()
8202 
    oprot.writeStructEnd()
8203 
 
3431 rajveer 8204 
  def validate(self):
8205 
    return
8206 
 
8207 
 
594 rajveer 8208 
  def __repr__(self):
8209 
    L = ['%s=%r' % (key, value)
8210 
      for key, value in self.__dict__.iteritems()]
8211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8212 
 
8213 
  def __eq__(self, other):
8214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8215 
 
8216 
  def __ne__(self, other):
8217 
    return not (self == other)
8218 
 
8219 
class getDefaultAddressId_result:
8220 
  """
8221 
  Attributes:
8222 
   - success
8223 
   - ucx
8224 
  """
8225 
 
8226 
  thrift_spec = (
8227 
    (0, TType.I64, 'success', None, None, ), # 0
8228 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8229 
  )
8230 
 
8231 
  def __init__(self, success=None, ucx=None,):
8232 
    self.success = success
8233 
    self.ucx = ucx
8234 
 
8235 
  def read(self, iprot):
8236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8238 
      return
8239 
    iprot.readStructBegin()
8240 
    while True:
8241 
      (fname, ftype, fid) = iprot.readFieldBegin()
8242 
      if ftype == TType.STOP:
8243 
        break
8244 
      if fid == 0:
8245 
        if ftype == TType.I64:
8246 
          self.success = iprot.readI64();
8247 
        else:
8248 
          iprot.skip(ftype)
8249 
      elif fid == 1:
8250 
        if ftype == TType.STRUCT:
8251 
          self.ucx = UserContextException()
8252 
          self.ucx.read(iprot)
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
8264 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 8265 
    if self.success is not None:
594 rajveer 8266 
      oprot.writeFieldBegin('success', TType.I64, 0)
8267 
      oprot.writeI64(self.success)
8268 
      oprot.writeFieldEnd()
3431 rajveer 8269 
    if self.ucx is not None:
594 rajveer 8270 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8271 
      self.ucx.write(oprot)
8272 
      oprot.writeFieldEnd()
8273 
    oprot.writeFieldStop()
8274 
    oprot.writeStructEnd()
8275 
 
3431 rajveer 8276 
  def validate(self):
8277 
    return
8278 
 
8279 
 
594 rajveer 8280 
  def __repr__(self):
8281 
    L = ['%s=%r' % (key, value)
8282 
      for key, value in self.__dict__.iteritems()]
8283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8284 
 
8285 
  def __eq__(self, other):
8286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8287 
 
8288 
  def __ne__(self, other):
8289 
    return not (self == other)
8290 
 
785 rajveer 8291 
class getDefaultPincode_args:
8292 
  """
8293 
  Attributes:
8294 
   - userId
8295 
  """
8296 
 
8297 
  thrift_spec = (
8298 
    None, # 0
8299 
    (1, TType.I64, 'userId', None, None, ), # 1
8300 
  )
8301 
 
8302 
  def __init__(self, userId=None,):
8303 
    self.userId = userId
8304 
 
8305 
  def read(self, iprot):
8306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8308 
      return
8309 
    iprot.readStructBegin()
8310 
    while True:
8311 
      (fname, ftype, fid) = iprot.readFieldBegin()
8312 
      if ftype == TType.STOP:
8313 
        break
8314 
      if fid == 1:
8315 
        if ftype == TType.I64:
8316 
          self.userId = iprot.readI64();
8317 
        else:
8318 
          iprot.skip(ftype)
8319 
      else:
8320 
        iprot.skip(ftype)
8321 
      iprot.readFieldEnd()
8322 
    iprot.readStructEnd()
8323 
 
8324 
  def write(self, oprot):
8325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8327 
      return
8328 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 8329 
    if self.userId is not None:
785 rajveer 8330 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8331 
      oprot.writeI64(self.userId)
8332 
      oprot.writeFieldEnd()
8333 
    oprot.writeFieldStop()
8334 
    oprot.writeStructEnd()
8335 
 
3431 rajveer 8336 
  def validate(self):
8337 
    return
8338 
 
8339 
 
785 rajveer 8340 
  def __repr__(self):
8341 
    L = ['%s=%r' % (key, value)
8342 
      for key, value in self.__dict__.iteritems()]
8343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8344 
 
8345 
  def __eq__(self, other):
8346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8347 
 
8348 
  def __ne__(self, other):
8349 
    return not (self == other)
8350 
 
8351 
class getDefaultPincode_result:
8352 
  """
8353 
  Attributes:
8354 
   - success
8355 
   - ucx
8356 
  """
8357 
 
8358 
  thrift_spec = (
8359 
    (0, TType.STRING, 'success', None, None, ), # 0
8360 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8361 
  )
8362 
 
8363 
  def __init__(self, success=None, ucx=None,):
8364 
    self.success = success
8365 
    self.ucx = ucx
8366 
 
8367 
  def read(self, iprot):
8368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8370 
      return
8371 
    iprot.readStructBegin()
8372 
    while True:
8373 
      (fname, ftype, fid) = iprot.readFieldBegin()
8374 
      if ftype == TType.STOP:
8375 
        break
8376 
      if fid == 0:
8377 
        if ftype == TType.STRING:
8378 
          self.success = iprot.readString();
8379 
        else:
8380 
          iprot.skip(ftype)
8381 
      elif fid == 1:
8382 
        if ftype == TType.STRUCT:
8383 
          self.ucx = UserContextException()
8384 
          self.ucx.read(iprot)
8385 
        else:
8386 
          iprot.skip(ftype)
8387 
      else:
8388 
        iprot.skip(ftype)
8389 
      iprot.readFieldEnd()
8390 
    iprot.readStructEnd()
8391 
 
8392 
  def write(self, oprot):
8393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8395 
      return
8396 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 8397 
    if self.success is not None:
785 rajveer 8398 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8399 
      oprot.writeString(self.success)
8400 
      oprot.writeFieldEnd()
3431 rajveer 8401 
    if self.ucx is not None:
785 rajveer 8402 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8403 
      self.ucx.write(oprot)
8404 
      oprot.writeFieldEnd()
8405 
    oprot.writeFieldStop()
8406 
    oprot.writeStructEnd()
8407 
 
3431 rajveer 8408 
  def validate(self):
8409 
    return
8410 
 
8411 
 
785 rajveer 8412 
  def __repr__(self):
8413 
    L = ['%s=%r' % (key, value)
8414 
      for key, value in self.__dict__.iteritems()]
8415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8416 
 
8417 
  def __eq__(self, other):
8418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8419 
 
8420 
  def __ne__(self, other):
8421 
    return not (self == other)
8422 
 
1274 varun.gupt 8423 
class saveUserCommunication_args:
8424 
  """
8425 
  Attributes:
8426 
   - userId
8427 
   - replyTo
8428 
   - communicationType
8429 
   - orderId
8430 
   - airwaybillNo
8431 
   - productName
8432 
   - subject
8433 
   - message
8434 
  """
8435 
 
8436 
  thrift_spec = (
8437 
    None, # 0
8438 
    (1, TType.I64, 'userId', None, None, ), # 1
8439 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
8440 
    (3, TType.I64, 'communicationType', None, None, ), # 3
8441 
    (4, TType.I64, 'orderId', None, None, ), # 4
8442 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
8443 
    (6, TType.STRING, 'productName', None, None, ), # 6
8444 
    (7, TType.STRING, 'subject', None, None, ), # 7
8445 
    (8, TType.STRING, 'message', None, None, ), # 8
8446 
  )
8447 
 
8448 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
8449 
    self.userId = userId
8450 
    self.replyTo = replyTo
8451 
    self.communicationType = communicationType
8452 
    self.orderId = orderId
8453 
    self.airwaybillNo = airwaybillNo
8454 
    self.productName = productName
8455 
    self.subject = subject
8456 
    self.message = message
8457 
 
8458 
  def read(self, iprot):
8459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8461 
      return
8462 
    iprot.readStructBegin()
8463 
    while True:
8464 
      (fname, ftype, fid) = iprot.readFieldBegin()
8465 
      if ftype == TType.STOP:
8466 
        break
8467 
      if fid == 1:
8468 
        if ftype == TType.I64:
8469 
          self.userId = iprot.readI64();
8470 
        else:
8471 
          iprot.skip(ftype)
8472 
      elif fid == 2:
8473 
        if ftype == TType.STRING:
8474 
          self.replyTo = iprot.readString();
8475 
        else:
8476 
          iprot.skip(ftype)
8477 
      elif fid == 3:
8478 
        if ftype == TType.I64:
8479 
          self.communicationType = iprot.readI64();
8480 
        else:
8481 
          iprot.skip(ftype)
8482 
      elif fid == 4:
8483 
        if ftype == TType.I64:
8484 
          self.orderId = iprot.readI64();
8485 
        else:
8486 
          iprot.skip(ftype)
8487 
      elif fid == 5:
8488 
        if ftype == TType.STRING:
8489 
          self.airwaybillNo = iprot.readString();
8490 
        else:
8491 
          iprot.skip(ftype)
8492 
      elif fid == 6:
8493 
        if ftype == TType.STRING:
8494 
          self.productName = iprot.readString();
8495 
        else:
8496 
          iprot.skip(ftype)
8497 
      elif fid == 7:
8498 
        if ftype == TType.STRING:
8499 
          self.subject = iprot.readString();
8500 
        else:
8501 
          iprot.skip(ftype)
8502 
      elif fid == 8:
8503 
        if ftype == TType.STRING:
8504 
          self.message = iprot.readString();
8505 
        else:
8506 
          iprot.skip(ftype)
8507 
      else:
8508 
        iprot.skip(ftype)
8509 
      iprot.readFieldEnd()
8510 
    iprot.readStructEnd()
8511 
 
8512 
  def write(self, oprot):
8513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8515 
      return
8516 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 8517 
    if self.userId is not None:
1274 varun.gupt 8518 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8519 
      oprot.writeI64(self.userId)
8520 
      oprot.writeFieldEnd()
3431 rajveer 8521 
    if self.replyTo is not None:
1274 varun.gupt 8522 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8523 
      oprot.writeString(self.replyTo)
8524 
      oprot.writeFieldEnd()
3431 rajveer 8525 
    if self.communicationType is not None:
1274 varun.gupt 8526 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8527 
      oprot.writeI64(self.communicationType)
8528 
      oprot.writeFieldEnd()
3431 rajveer 8529 
    if self.orderId is not None:
1274 varun.gupt 8530 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8531 
      oprot.writeI64(self.orderId)
8532 
      oprot.writeFieldEnd()
3431 rajveer 8533 
    if self.airwaybillNo is not None:
1274 varun.gupt 8534 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8535 
      oprot.writeString(self.airwaybillNo)
8536 
      oprot.writeFieldEnd()
3431 rajveer 8537 
    if self.productName is not None:
1274 varun.gupt 8538 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8539 
      oprot.writeString(self.productName)
8540 
      oprot.writeFieldEnd()
3431 rajveer 8541 
    if self.subject is not None:
1274 varun.gupt 8542 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8543 
      oprot.writeString(self.subject)
8544 
      oprot.writeFieldEnd()
3431 rajveer 8545 
    if self.message is not None:
1274 varun.gupt 8546 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8547 
      oprot.writeString(self.message)
8548 
      oprot.writeFieldEnd()
8549 
    oprot.writeFieldStop()
8550 
    oprot.writeStructEnd()
8551 
 
3431 rajveer 8552 
  def validate(self):
8553 
    return
8554 
 
8555 
 
1274 varun.gupt 8556 
  def __repr__(self):
8557 
    L = ['%s=%r' % (key, value)
8558 
      for key, value in self.__dict__.iteritems()]
8559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8560 
 
8561 
  def __eq__(self, other):
8562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8563 
 
8564 
  def __ne__(self, other):
8565 
    return not (self == other)
8566 
 
8567 
class saveUserCommunication_result:
8568 
  """
8569 
  Attributes:
8570 
   - success
8571 
   - ucx
8572 
  """
8573 
 
8574 
  thrift_spec = (
8575 
    (0, TType.BOOL, 'success', None, None, ), # 0
8576 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8577 
  )
8578 
 
8579 
  def __init__(self, success=None, ucx=None,):
8580 
    self.success = success
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 == 0:
8593 
        if ftype == TType.BOOL:
8594 
          self.success = iprot.readBool();
8595 
        else:
8596 
          iprot.skip(ftype)
8597 
      elif fid == 1:
8598 
        if ftype == TType.STRUCT:
8599 
          self.ucx = UserCommunicationException()
8600 
          self.ucx.read(iprot)
8601 
        else:
8602 
          iprot.skip(ftype)
8603 
      else:
8604 
        iprot.skip(ftype)
8605 
      iprot.readFieldEnd()
8606 
    iprot.readStructEnd()
8607 
 
8608 
  def write(self, oprot):
8609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8611 
      return
8612 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8613 
    if self.success is not None:
1274 varun.gupt 8614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8615 
      oprot.writeBool(self.success)
8616 
      oprot.writeFieldEnd()
3431 rajveer 8617 
    if self.ucx is not None:
1274 varun.gupt 8618 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8619 
      self.ucx.write(oprot)
8620 
      oprot.writeFieldEnd()
8621 
    oprot.writeFieldStop()
8622 
    oprot.writeStructEnd()
8623 
 
3431 rajveer 8624 
  def validate(self):
8625 
    return
8626 
 
8627 
 
1274 varun.gupt 8628 
  def __repr__(self):
8629 
    L = ['%s=%r' % (key, value)
8630 
      for key, value in self.__dict__.iteritems()]
8631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8632 
 
8633 
  def __eq__(self, other):
8634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8635 
 
8636 
  def __ne__(self, other):
8637 
    return not (self == other)
8638 
 
1590 varun.gupt 8639 
class getUserCommunicationById_args:
8640 
  """
8641 
  Attributes:
8642 
   - id
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    None, # 0
8647 
    (1, TType.I64, 'id', None, None, ), # 1
8648 
  )
8649 
 
8650 
  def __init__(self, id=None,):
8651 
    self.id = id
8652 
 
8653 
  def read(self, iprot):
8654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8656 
      return
8657 
    iprot.readStructBegin()
8658 
    while True:
8659 
      (fname, ftype, fid) = iprot.readFieldBegin()
8660 
      if ftype == TType.STOP:
8661 
        break
8662 
      if fid == 1:
8663 
        if ftype == TType.I64:
8664 
          self.id = iprot.readI64();
8665 
        else:
8666 
          iprot.skip(ftype)
8667 
      else:
8668 
        iprot.skip(ftype)
8669 
      iprot.readFieldEnd()
8670 
    iprot.readStructEnd()
8671 
 
8672 
  def write(self, oprot):
8673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8675 
      return
8676 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8677 
    if self.id is not None:
1590 varun.gupt 8678 
      oprot.writeFieldBegin('id', TType.I64, 1)
8679 
      oprot.writeI64(self.id)
8680 
      oprot.writeFieldEnd()
8681 
    oprot.writeFieldStop()
8682 
    oprot.writeStructEnd()
8683 
 
3431 rajveer 8684 
  def validate(self):
8685 
    return
8686 
 
8687 
 
1590 varun.gupt 8688 
  def __repr__(self):
8689 
    L = ['%s=%r' % (key, value)
8690 
      for key, value in self.__dict__.iteritems()]
8691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8692 
 
8693 
  def __eq__(self, other):
8694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8695 
 
8696 
  def __ne__(self, other):
8697 
    return not (self == other)
8698 
 
8699 
class getUserCommunicationById_result:
8700 
  """
8701 
  Attributes:
8702 
   - success
8703 
   - ucx
8704 
  """
8705 
 
8706 
  thrift_spec = (
8707 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8708 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8709 
  )
8710 
 
8711 
  def __init__(self, success=None, ucx=None,):
8712 
    self.success = success
8713 
    self.ucx = ucx
8714 
 
8715 
  def read(self, iprot):
8716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8718 
      return
8719 
    iprot.readStructBegin()
8720 
    while True:
8721 
      (fname, ftype, fid) = iprot.readFieldBegin()
8722 
      if ftype == TType.STOP:
8723 
        break
8724 
      if fid == 0:
8725 
        if ftype == TType.STRUCT:
8726 
          self.success = UserCommunication()
8727 
          self.success.read(iprot)
8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      elif fid == 1:
8731 
        if ftype == TType.STRUCT:
8732 
          self.ucx = UserCommunicationException()
8733 
          self.ucx.read(iprot)
8734 
        else:
8735 
          iprot.skip(ftype)
8736 
      else:
8737 
        iprot.skip(ftype)
8738 
      iprot.readFieldEnd()
8739 
    iprot.readStructEnd()
8740 
 
8741 
  def write(self, oprot):
8742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8744 
      return
8745 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8746 
    if self.success is not None:
1590 varun.gupt 8747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8748 
      self.success.write(oprot)
8749 
      oprot.writeFieldEnd()
3431 rajveer 8750 
    if self.ucx is not None:
1590 varun.gupt 8751 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8752 
      self.ucx.write(oprot)
8753 
      oprot.writeFieldEnd()
8754 
    oprot.writeFieldStop()
8755 
    oprot.writeStructEnd()
8756 
 
3431 rajveer 8757 
  def validate(self):
8758 
    return
8759 
 
8760 
 
1590 varun.gupt 8761 
  def __repr__(self):
8762 
    L = ['%s=%r' % (key, value)
8763 
      for key, value in self.__dict__.iteritems()]
8764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8765 
 
8766 
  def __eq__(self, other):
8767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8768 
 
8769 
  def __ne__(self, other):
8770 
    return not (self == other)
8771 
 
8772 
class getUserCommunicationByUser_args:
8773 
  """
8774 
  Attributes:
8775 
   - userId
8776 
  """
8777 
 
8778 
  thrift_spec = (
8779 
    None, # 0
8780 
    (1, TType.I64, 'userId', None, None, ), # 1
8781 
  )
8782 
 
8783 
  def __init__(self, userId=None,):
8784 
    self.userId = userId
8785 
 
8786 
  def read(self, iprot):
8787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8789 
      return
8790 
    iprot.readStructBegin()
8791 
    while True:
8792 
      (fname, ftype, fid) = iprot.readFieldBegin()
8793 
      if ftype == TType.STOP:
8794 
        break
8795 
      if fid == 1:
8796 
        if ftype == TType.I64:
8797 
          self.userId = iprot.readI64();
8798 
        else:
8799 
          iprot.skip(ftype)
8800 
      else:
8801 
        iprot.skip(ftype)
8802 
      iprot.readFieldEnd()
8803 
    iprot.readStructEnd()
8804 
 
8805 
  def write(self, oprot):
8806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8808 
      return
8809 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8810 
    if self.userId is not None:
1590 varun.gupt 8811 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8812 
      oprot.writeI64(self.userId)
8813 
      oprot.writeFieldEnd()
8814 
    oprot.writeFieldStop()
8815 
    oprot.writeStructEnd()
8816 
 
3431 rajveer 8817 
  def validate(self):
8818 
    return
8819 
 
8820 
 
1590 varun.gupt 8821 
  def __repr__(self):
8822 
    L = ['%s=%r' % (key, value)
8823 
      for key, value in self.__dict__.iteritems()]
8824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8825 
 
8826 
  def __eq__(self, other):
8827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8828 
 
8829 
  def __ne__(self, other):
8830 
    return not (self == other)
8831 
 
8832 
class getUserCommunicationByUser_result:
8833 
  """
8834 
  Attributes:
8835 
   - success
8836 
   - ucx
8837 
  """
8838 
 
8839 
  thrift_spec = (
8840 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8841 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8842 
  )
8843 
 
8844 
  def __init__(self, success=None, ucx=None,):
8845 
    self.success = success
8846 
    self.ucx = ucx
8847 
 
8848 
  def read(self, iprot):
8849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8851 
      return
8852 
    iprot.readStructBegin()
8853 
    while True:
8854 
      (fname, ftype, fid) = iprot.readFieldBegin()
8855 
      if ftype == TType.STOP:
8856 
        break
8857 
      if fid == 0:
8858 
        if ftype == TType.LIST:
8859 
          self.success = []
11592 amit.gupta 8860 
          (_etype107, _size104) = iprot.readListBegin()
8861 
          for _i108 in xrange(_size104):
8862 
            _elem109 = UserCommunication()
8863 
            _elem109.read(iprot)
8864 
            self.success.append(_elem109)
1590 varun.gupt 8865 
          iprot.readListEnd()
8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      elif fid == 1:
8869 
        if ftype == TType.STRUCT:
8870 
          self.ucx = UserCommunicationException()
8871 
          self.ucx.read(iprot)
8872 
        else:
8873 
          iprot.skip(ftype)
8874 
      else:
8875 
        iprot.skip(ftype)
8876 
      iprot.readFieldEnd()
8877 
    iprot.readStructEnd()
8878 
 
8879 
  def write(self, oprot):
8880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8882 
      return
8883 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8884 
    if self.success is not None:
1590 varun.gupt 8885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8887 
      for iter110 in self.success:
8888 
        iter110.write(oprot)
1590 varun.gupt 8889 
      oprot.writeListEnd()
8890 
      oprot.writeFieldEnd()
3431 rajveer 8891 
    if self.ucx is not None:
1590 varun.gupt 8892 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8893 
      self.ucx.write(oprot)
8894 
      oprot.writeFieldEnd()
8895 
    oprot.writeFieldStop()
8896 
    oprot.writeStructEnd()
8897 
 
3431 rajveer 8898 
  def validate(self):
8899 
    return
8900 
 
8901 
 
1590 varun.gupt 8902 
  def __repr__(self):
8903 
    L = ['%s=%r' % (key, value)
8904 
      for key, value in self.__dict__.iteritems()]
8905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8906 
 
8907 
  def __eq__(self, other):
8908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8909 
 
8910 
  def __ne__(self, other):
8911 
    return not (self == other)
8912 
 
8913 
class getAllUserCommunications_args:
8914 
 
8915 
  thrift_spec = (
8916 
  )
8917 
 
8918 
  def read(self, iprot):
8919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8921 
      return
8922 
    iprot.readStructBegin()
8923 
    while True:
8924 
      (fname, ftype, fid) = iprot.readFieldBegin()
8925 
      if ftype == TType.STOP:
8926 
        break
8927 
      else:
8928 
        iprot.skip(ftype)
8929 
      iprot.readFieldEnd()
8930 
    iprot.readStructEnd()
8931 
 
8932 
  def write(self, oprot):
8933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8935 
      return
8936 
    oprot.writeStructBegin('getAllUserCommunications_args')
8937 
    oprot.writeFieldStop()
8938 
    oprot.writeStructEnd()
8939 
 
3431 rajveer 8940 
  def validate(self):
8941 
    return
8942 
 
8943 
 
1590 varun.gupt 8944 
  def __repr__(self):
8945 
    L = ['%s=%r' % (key, value)
8946 
      for key, value in self.__dict__.iteritems()]
8947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8948 
 
8949 
  def __eq__(self, other):
8950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8951 
 
8952 
  def __ne__(self, other):
8953 
    return not (self == other)
8954 
 
8955 
class getAllUserCommunications_result:
8956 
  """
8957 
  Attributes:
8958 
   - success
8959 
   - ucx
8960 
  """
8961 
 
8962 
  thrift_spec = (
8963 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8964 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8965 
  )
8966 
 
8967 
  def __init__(self, success=None, ucx=None,):
8968 
    self.success = success
8969 
    self.ucx = ucx
8970 
 
8971 
  def read(self, iprot):
8972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8974 
      return
8975 
    iprot.readStructBegin()
8976 
    while True:
8977 
      (fname, ftype, fid) = iprot.readFieldBegin()
8978 
      if ftype == TType.STOP:
8979 
        break
8980 
      if fid == 0:
8981 
        if ftype == TType.LIST:
8982 
          self.success = []
11592 amit.gupta 8983 
          (_etype114, _size111) = iprot.readListBegin()
8984 
          for _i115 in xrange(_size111):
8985 
            _elem116 = UserCommunication()
8986 
            _elem116.read(iprot)
8987 
            self.success.append(_elem116)
1590 varun.gupt 8988 
          iprot.readListEnd()
8989 
        else:
8990 
          iprot.skip(ftype)
8991 
      elif fid == 1:
8992 
        if ftype == TType.STRUCT:
8993 
          self.ucx = UserCommunicationException()
8994 
          self.ucx.read(iprot)
8995 
        else:
8996 
          iprot.skip(ftype)
8997 
      else:
8998 
        iprot.skip(ftype)
8999 
      iprot.readFieldEnd()
9000 
    iprot.readStructEnd()
9001 
 
9002 
  def write(self, oprot):
9003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9005 
      return
9006 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 9007 
    if self.success is not None:
1590 varun.gupt 9008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9009 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9010 
      for iter117 in self.success:
9011 
        iter117.write(oprot)
1590 varun.gupt 9012 
      oprot.writeListEnd()
9013 
      oprot.writeFieldEnd()
3431 rajveer 9014 
    if self.ucx is not None:
1590 varun.gupt 9015 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
9016 
      self.ucx.write(oprot)
9017 
      oprot.writeFieldEnd()
9018 
    oprot.writeFieldStop()
9019 
    oprot.writeStructEnd()
9020 
 
3431 rajveer 9021 
  def validate(self):
9022 
    return
9023 
 
9024 
 
1590 varun.gupt 9025 
  def __repr__(self):
9026 
    L = ['%s=%r' % (key, value)
9027 
      for key, value in self.__dict__.iteritems()]
9028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9029 
 
9030 
  def __eq__(self, other):
9031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9032 
 
9033 
  def __ne__(self, other):
9034 
    return not (self == other)
9035 
 
5407 amar.kumar 9036 
class removeUserCommunication_args:
9037 
  """
9038 
  Attributes:
9039 
   - id
9040 
  """
9041 
 
9042 
  thrift_spec = (
9043 
    None, # 0
9044 
    (1, TType.I64, 'id', None, None, ), # 1
9045 
  )
9046 
 
9047 
  def __init__(self, id=None,):
9048 
    self.id = id
9049 
 
9050 
  def read(self, iprot):
9051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9053 
      return
9054 
    iprot.readStructBegin()
9055 
    while True:
9056 
      (fname, ftype, fid) = iprot.readFieldBegin()
9057 
      if ftype == TType.STOP:
9058 
        break
9059 
      if fid == 1:
9060 
        if ftype == TType.I64:
9061 
          self.id = iprot.readI64();
9062 
        else:
9063 
          iprot.skip(ftype)
9064 
      else:
9065 
        iprot.skip(ftype)
9066 
      iprot.readFieldEnd()
9067 
    iprot.readStructEnd()
9068 
 
9069 
  def write(self, oprot):
9070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9072 
      return
9073 
    oprot.writeStructBegin('removeUserCommunication_args')
9074 
    if self.id is not None:
9075 
      oprot.writeFieldBegin('id', TType.I64, 1)
9076 
      oprot.writeI64(self.id)
9077 
      oprot.writeFieldEnd()
9078 
    oprot.writeFieldStop()
9079 
    oprot.writeStructEnd()
9080 
 
9081 
  def validate(self):
9082 
    return
9083 
 
9084 
 
9085 
  def __repr__(self):
9086 
    L = ['%s=%r' % (key, value)
9087 
      for key, value in self.__dict__.iteritems()]
9088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9089 
 
9090 
  def __eq__(self, other):
9091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9092 
 
9093 
  def __ne__(self, other):
9094 
    return not (self == other)
9095 
 
9096 
class removeUserCommunication_result:
9097 
  """
9098 
  Attributes:
9099 
   - ucx
9100 
  """
9101 
 
9102 
  thrift_spec = (
9103 
    None, # 0
9104 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
9105 
  )
9106 
 
9107 
  def __init__(self, ucx=None,):
9108 
    self.ucx = ucx
9109 
 
9110 
  def read(self, iprot):
9111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9113 
      return
9114 
    iprot.readStructBegin()
9115 
    while True:
9116 
      (fname, ftype, fid) = iprot.readFieldBegin()
9117 
      if ftype == TType.STOP:
9118 
        break
9119 
      if fid == 1:
9120 
        if ftype == TType.STRUCT:
9121 
          self.ucx = UserCommunicationException()
9122 
          self.ucx.read(iprot)
9123 
        else:
9124 
          iprot.skip(ftype)
9125 
      else:
9126 
        iprot.skip(ftype)
9127 
      iprot.readFieldEnd()
9128 
    iprot.readStructEnd()
9129 
 
9130 
  def write(self, oprot):
9131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9133 
      return
9134 
    oprot.writeStructBegin('removeUserCommunication_result')
9135 
    if self.ucx is not None:
9136 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
9137 
      self.ucx.write(oprot)
9138 
      oprot.writeFieldEnd()
9139 
    oprot.writeFieldStop()
9140 
    oprot.writeStructEnd()
9141 
 
9142 
  def validate(self):
9143 
    return
9144 
 
9145 
 
9146 
  def __repr__(self):
9147 
    L = ['%s=%r' % (key, value)
9148 
      for key, value in self.__dict__.iteritems()]
9149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9150 
 
9151 
  def __eq__(self, other):
9152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9153 
 
9154 
  def __ne__(self, other):
9155 
    return not (self == other)
9156 
 
1845 vikas 9157 
class createMasterAffiliate_args:
9158 
  """
9159 
  Attributes:
9160 
   - name
1859 vikas 9161 
   - addedOn
1845 vikas 9162 
  """
9163 
 
9164 
  thrift_spec = (
9165 
    None, # 0
9166 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 9167 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 9168 
  )
9169 
 
1859 vikas 9170 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 9171 
    self.name = name
1859 vikas 9172 
    self.addedOn = addedOn
1845 vikas 9173 
 
9174 
  def read(self, iprot):
9175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9177 
      return
9178 
    iprot.readStructBegin()
9179 
    while True:
9180 
      (fname, ftype, fid) = iprot.readFieldBegin()
9181 
      if ftype == TType.STOP:
9182 
        break
9183 
      if fid == 1:
9184 
        if ftype == TType.STRING:
9185 
          self.name = iprot.readString();
9186 
        else:
9187 
          iprot.skip(ftype)
1859 vikas 9188 
      elif fid == 2:
9189 
        if ftype == TType.I64:
9190 
          self.addedOn = iprot.readI64();
9191 
        else:
9192 
          iprot.skip(ftype)
1845 vikas 9193 
      else:
9194 
        iprot.skip(ftype)
9195 
      iprot.readFieldEnd()
9196 
    iprot.readStructEnd()
9197 
 
9198 
  def write(self, oprot):
9199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9201 
      return
9202 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 9203 
    if self.name is not None:
1845 vikas 9204 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9205 
      oprot.writeString(self.name)
9206 
      oprot.writeFieldEnd()
3431 rajveer 9207 
    if self.addedOn is not None:
1859 vikas 9208 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
9209 
      oprot.writeI64(self.addedOn)
9210 
      oprot.writeFieldEnd()
1845 vikas 9211 
    oprot.writeFieldStop()
9212 
    oprot.writeStructEnd()
9213 
 
3431 rajveer 9214 
  def validate(self):
9215 
    return
9216 
 
9217 
 
1845 vikas 9218 
  def __repr__(self):
9219 
    L = ['%s=%r' % (key, value)
9220 
      for key, value in self.__dict__.iteritems()]
9221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9222 
 
9223 
  def __eq__(self, other):
9224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9225 
 
9226 
  def __ne__(self, other):
9227 
    return not (self == other)
9228 
 
9229 
class createMasterAffiliate_result:
9230 
  """
9231 
  Attributes:
9232 
   - success
9233 
   - utx
9234 
  """
9235 
 
9236 
  thrift_spec = (
9237 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9238 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9239 
  )
9240 
 
9241 
  def __init__(self, success=None, utx=None,):
9242 
    self.success = success
9243 
    self.utx = utx
9244 
 
9245 
  def read(self, iprot):
9246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9248 
      return
9249 
    iprot.readStructBegin()
9250 
    while True:
9251 
      (fname, ftype, fid) = iprot.readFieldBegin()
9252 
      if ftype == TType.STOP:
9253 
        break
9254 
      if fid == 0:
9255 
        if ftype == TType.STRUCT:
9256 
          self.success = MasterAffiliate()
9257 
          self.success.read(iprot)
9258 
        else:
9259 
          iprot.skip(ftype)
9260 
      elif fid == 1:
9261 
        if ftype == TType.STRUCT:
1996 vikas 9262 
          self.utx = UserAffiliateException()
1845 vikas 9263 
          self.utx.read(iprot)
9264 
        else:
9265 
          iprot.skip(ftype)
9266 
      else:
9267 
        iprot.skip(ftype)
9268 
      iprot.readFieldEnd()
9269 
    iprot.readStructEnd()
9270 
 
9271 
  def write(self, oprot):
9272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9274 
      return
9275 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 9276 
    if self.success is not None:
1845 vikas 9277 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9278 
      self.success.write(oprot)
9279 
      oprot.writeFieldEnd()
3431 rajveer 9280 
    if self.utx is not None:
1845 vikas 9281 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9282 
      self.utx.write(oprot)
9283 
      oprot.writeFieldEnd()
9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
1845 vikas 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
1899 vikas 9302 
class getAllMasterAffiliates_args:
9303 
 
9304 
  thrift_spec = (
9305 
  )
9306 
 
9307 
  def read(self, iprot):
9308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9310 
      return
9311 
    iprot.readStructBegin()
9312 
    while True:
9313 
      (fname, ftype, fid) = iprot.readFieldBegin()
9314 
      if ftype == TType.STOP:
9315 
        break
9316 
      else:
9317 
        iprot.skip(ftype)
9318 
      iprot.readFieldEnd()
9319 
    iprot.readStructEnd()
9320 
 
9321 
  def write(self, oprot):
9322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9324 
      return
9325 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
9326 
    oprot.writeFieldStop()
9327 
    oprot.writeStructEnd()
9328 
 
3431 rajveer 9329 
  def validate(self):
9330 
    return
9331 
 
9332 
 
1899 vikas 9333 
  def __repr__(self):
9334 
    L = ['%s=%r' % (key, value)
9335 
      for key, value in self.__dict__.iteritems()]
9336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9337 
 
9338 
  def __eq__(self, other):
9339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9340 
 
9341 
  def __ne__(self, other):
9342 
    return not (self == other)
9343 
 
9344 
class getAllMasterAffiliates_result:
9345 
  """
9346 
  Attributes:
9347 
   - success
9348 
   - utx
9349 
  """
9350 
 
9351 
  thrift_spec = (
9352 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 9353 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 9354 
  )
9355 
 
9356 
  def __init__(self, success=None, utx=None,):
9357 
    self.success = success
9358 
    self.utx = utx
9359 
 
9360 
  def read(self, iprot):
9361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9363 
      return
9364 
    iprot.readStructBegin()
9365 
    while True:
9366 
      (fname, ftype, fid) = iprot.readFieldBegin()
9367 
      if ftype == TType.STOP:
9368 
        break
9369 
      if fid == 0:
9370 
        if ftype == TType.LIST:
9371 
          self.success = []
11592 amit.gupta 9372 
          (_etype121, _size118) = iprot.readListBegin()
9373 
          for _i122 in xrange(_size118):
9374 
            _elem123 = MasterAffiliate()
9375 
            _elem123.read(iprot)
9376 
            self.success.append(_elem123)
1899 vikas 9377 
          iprot.readListEnd()
9378 
        else:
9379 
          iprot.skip(ftype)
9380 
      elif fid == 1:
9381 
        if ftype == TType.STRUCT:
1996 vikas 9382 
          self.utx = UserAffiliateException()
1899 vikas 9383 
          self.utx.read(iprot)
9384 
        else:
9385 
          iprot.skip(ftype)
9386 
      else:
9387 
        iprot.skip(ftype)
9388 
      iprot.readFieldEnd()
9389 
    iprot.readStructEnd()
9390 
 
9391 
  def write(self, oprot):
9392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9394 
      return
9395 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 9396 
    if self.success is not None:
1899 vikas 9397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9399 
      for iter124 in self.success:
9400 
        iter124.write(oprot)
1899 vikas 9401 
      oprot.writeListEnd()
9402 
      oprot.writeFieldEnd()
3431 rajveer 9403 
    if self.utx is not None:
1899 vikas 9404 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9405 
      self.utx.write(oprot)
9406 
      oprot.writeFieldEnd()
9407 
    oprot.writeFieldStop()
9408 
    oprot.writeStructEnd()
9409 
 
3431 rajveer 9410 
  def validate(self):
9411 
    return
9412 
 
9413 
 
1899 vikas 9414 
  def __repr__(self):
9415 
    L = ['%s=%r' % (key, value)
9416 
      for key, value in self.__dict__.iteritems()]
9417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9418 
 
9419 
  def __eq__(self, other):
9420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9421 
 
9422 
  def __ne__(self, other):
9423 
    return not (self == other)
9424 
 
1845 vikas 9425 
class getMasterAffiliateById_args:
9426 
  """
9427 
  Attributes:
9428 
   - id
9429 
  """
9430 
 
9431 
  thrift_spec = (
9432 
    None, # 0
9433 
    (1, TType.I64, 'id', None, None, ), # 1
9434 
  )
9435 
 
9436 
  def __init__(self, id=None,):
9437 
    self.id = id
9438 
 
9439 
  def read(self, iprot):
9440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9442 
      return
9443 
    iprot.readStructBegin()
9444 
    while True:
9445 
      (fname, ftype, fid) = iprot.readFieldBegin()
9446 
      if ftype == TType.STOP:
9447 
        break
9448 
      if fid == 1:
9449 
        if ftype == TType.I64:
9450 
          self.id = iprot.readI64();
9451 
        else:
9452 
          iprot.skip(ftype)
9453 
      else:
9454 
        iprot.skip(ftype)
9455 
      iprot.readFieldEnd()
9456 
    iprot.readStructEnd()
9457 
 
9458 
  def write(self, oprot):
9459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9461 
      return
9462 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 9463 
    if self.id is not None:
1845 vikas 9464 
      oprot.writeFieldBegin('id', TType.I64, 1)
9465 
      oprot.writeI64(self.id)
9466 
      oprot.writeFieldEnd()
9467 
    oprot.writeFieldStop()
9468 
    oprot.writeStructEnd()
9469 
 
3431 rajveer 9470 
  def validate(self):
9471 
    return
9472 
 
9473 
 
1845 vikas 9474 
  def __repr__(self):
9475 
    L = ['%s=%r' % (key, value)
9476 
      for key, value in self.__dict__.iteritems()]
9477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9478 
 
9479 
  def __eq__(self, other):
9480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9481 
 
9482 
  def __ne__(self, other):
9483 
    return not (self == other)
9484 
 
9485 
class getMasterAffiliateById_result:
9486 
  """
9487 
  Attributes:
9488 
   - success
9489 
   - utx
9490 
  """
9491 
 
9492 
  thrift_spec = (
9493 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9494 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9495 
  )
9496 
 
9497 
  def __init__(self, success=None, utx=None,):
9498 
    self.success = success
9499 
    self.utx = utx
9500 
 
9501 
  def read(self, iprot):
9502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9504 
      return
9505 
    iprot.readStructBegin()
9506 
    while True:
9507 
      (fname, ftype, fid) = iprot.readFieldBegin()
9508 
      if ftype == TType.STOP:
9509 
        break
9510 
      if fid == 0:
9511 
        if ftype == TType.STRUCT:
9512 
          self.success = MasterAffiliate()
9513 
          self.success.read(iprot)
9514 
        else:
9515 
          iprot.skip(ftype)
9516 
      elif fid == 1:
9517 
        if ftype == TType.STRUCT:
1996 vikas 9518 
          self.utx = UserAffiliateException()
1845 vikas 9519 
          self.utx.read(iprot)
9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      else:
9523 
        iprot.skip(ftype)
9524 
      iprot.readFieldEnd()
9525 
    iprot.readStructEnd()
9526 
 
9527 
  def write(self, oprot):
9528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9530 
      return
9531 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9532 
    if self.success is not None:
1845 vikas 9533 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9534 
      self.success.write(oprot)
9535 
      oprot.writeFieldEnd()
3431 rajveer 9536 
    if self.utx is not None:
1845 vikas 9537 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9538 
      self.utx.write(oprot)
9539 
      oprot.writeFieldEnd()
9540 
    oprot.writeFieldStop()
9541 
    oprot.writeStructEnd()
9542 
 
3431 rajveer 9543 
  def validate(self):
9544 
    return
9545 
 
9546 
 
1845 vikas 9547 
  def __repr__(self):
9548 
    L = ['%s=%r' % (key, value)
9549 
      for key, value in self.__dict__.iteritems()]
9550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9551 
 
9552 
  def __eq__(self, other):
9553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9554 
 
9555 
  def __ne__(self, other):
9556 
    return not (self == other)
9557 
 
9558 
class getMasterAffiliateByName_args:
9559 
  """
9560 
  Attributes:
9561 
   - name
9562 
  """
9563 
 
9564 
  thrift_spec = (
9565 
    None, # 0
9566 
    (1, TType.STRING, 'name', None, None, ), # 1
9567 
  )
9568 
 
9569 
  def __init__(self, name=None,):
9570 
    self.name = name
9571 
 
9572 
  def read(self, iprot):
9573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9575 
      return
9576 
    iprot.readStructBegin()
9577 
    while True:
9578 
      (fname, ftype, fid) = iprot.readFieldBegin()
9579 
      if ftype == TType.STOP:
9580 
        break
9581 
      if fid == 1:
9582 
        if ftype == TType.STRING:
9583 
          self.name = iprot.readString();
9584 
        else:
9585 
          iprot.skip(ftype)
9586 
      else:
9587 
        iprot.skip(ftype)
9588 
      iprot.readFieldEnd()
9589 
    iprot.readStructEnd()
9590 
 
9591 
  def write(self, oprot):
9592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9594 
      return
9595 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9596 
    if self.name is not None:
1845 vikas 9597 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9598 
      oprot.writeString(self.name)
9599 
      oprot.writeFieldEnd()
9600 
    oprot.writeFieldStop()
9601 
    oprot.writeStructEnd()
9602 
 
3431 rajveer 9603 
  def validate(self):
9604 
    return
9605 
 
9606 
 
1845 vikas 9607 
  def __repr__(self):
9608 
    L = ['%s=%r' % (key, value)
9609 
      for key, value in self.__dict__.iteritems()]
9610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9611 
 
9612 
  def __eq__(self, other):
9613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9614 
 
9615 
  def __ne__(self, other):
9616 
    return not (self == other)
9617 
 
9618 
class getMasterAffiliateByName_result:
9619 
  """
9620 
  Attributes:
9621 
   - success
9622 
   - utx
9623 
  """
9624 
 
9625 
  thrift_spec = (
9626 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9627 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9628 
  )
9629 
 
9630 
  def __init__(self, success=None, utx=None,):
9631 
    self.success = success
9632 
    self.utx = utx
9633 
 
9634 
  def read(self, iprot):
9635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9637 
      return
9638 
    iprot.readStructBegin()
9639 
    while True:
9640 
      (fname, ftype, fid) = iprot.readFieldBegin()
9641 
      if ftype == TType.STOP:
9642 
        break
9643 
      if fid == 0:
9644 
        if ftype == TType.STRUCT:
9645 
          self.success = MasterAffiliate()
9646 
          self.success.read(iprot)
9647 
        else:
9648 
          iprot.skip(ftype)
9649 
      elif fid == 1:
9650 
        if ftype == TType.STRUCT:
1996 vikas 9651 
          self.utx = UserAffiliateException()
1845 vikas 9652 
          self.utx.read(iprot)
9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      else:
9656 
        iprot.skip(ftype)
9657 
      iprot.readFieldEnd()
9658 
    iprot.readStructEnd()
9659 
 
9660 
  def write(self, oprot):
9661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9663 
      return
9664 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9665 
    if self.success is not None:
1845 vikas 9666 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9667 
      self.success.write(oprot)
9668 
      oprot.writeFieldEnd()
3431 rajveer 9669 
    if self.utx is not None:
1845 vikas 9670 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9671 
      self.utx.write(oprot)
9672 
      oprot.writeFieldEnd()
9673 
    oprot.writeFieldStop()
9674 
    oprot.writeStructEnd()
9675 
 
3431 rajveer 9676 
  def validate(self):
9677 
    return
9678 
 
9679 
 
1845 vikas 9680 
  def __repr__(self):
9681 
    L = ['%s=%r' % (key, value)
9682 
      for key, value in self.__dict__.iteritems()]
9683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9684 
 
9685 
  def __eq__(self, other):
9686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9687 
 
9688 
  def __ne__(self, other):
9689 
    return not (self == other)
9690 
 
9691 
class createAffiliate_args:
9692 
  """
9693 
  Attributes:
9694 
   - name
9695 
   - url
9696 
   - masterAffiliateId
1859 vikas 9697 
   - addedOn
1845 vikas 9698 
  """
9699 
 
9700 
  thrift_spec = (
9701 
    None, # 0
9702 
    (1, TType.STRING, 'name', None, None, ), # 1
9703 
    (2, TType.STRING, 'url', None, None, ), # 2
9704 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9705 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9706 
  )
9707 
 
1859 vikas 9708 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9709 
    self.name = name
9710 
    self.url = url
9711 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9712 
    self.addedOn = addedOn
1845 vikas 9713 
 
9714 
  def read(self, iprot):
9715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9717 
      return
9718 
    iprot.readStructBegin()
9719 
    while True:
9720 
      (fname, ftype, fid) = iprot.readFieldBegin()
9721 
      if ftype == TType.STOP:
9722 
        break
9723 
      if fid == 1:
9724 
        if ftype == TType.STRING:
9725 
          self.name = iprot.readString();
9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      elif fid == 2:
9729 
        if ftype == TType.STRING:
9730 
          self.url = iprot.readString();
9731 
        else:
9732 
          iprot.skip(ftype)
9733 
      elif fid == 3:
9734 
        if ftype == TType.I64:
9735 
          self.masterAffiliateId = iprot.readI64();
9736 
        else:
9737 
          iprot.skip(ftype)
1859 vikas 9738 
      elif fid == 4:
9739 
        if ftype == TType.I64:
9740 
          self.addedOn = iprot.readI64();
9741 
        else:
9742 
          iprot.skip(ftype)
1845 vikas 9743 
      else:
9744 
        iprot.skip(ftype)
9745 
      iprot.readFieldEnd()
9746 
    iprot.readStructEnd()
9747 
 
9748 
  def write(self, oprot):
9749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9751 
      return
9752 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9753 
    if self.name is not None:
1845 vikas 9754 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9755 
      oprot.writeString(self.name)
9756 
      oprot.writeFieldEnd()
3431 rajveer 9757 
    if self.url is not None:
1845 vikas 9758 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9759 
      oprot.writeString(self.url)
9760 
      oprot.writeFieldEnd()
3431 rajveer 9761 
    if self.masterAffiliateId is not None:
1845 vikas 9762 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9763 
      oprot.writeI64(self.masterAffiliateId)
9764 
      oprot.writeFieldEnd()
3431 rajveer 9765 
    if self.addedOn is not None:
1859 vikas 9766 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9767 
      oprot.writeI64(self.addedOn)
9768 
      oprot.writeFieldEnd()
1845 vikas 9769 
    oprot.writeFieldStop()
9770 
    oprot.writeStructEnd()
9771 
 
3431 rajveer 9772 
  def validate(self):
9773 
    return
9774 
 
9775 
 
1845 vikas 9776 
  def __repr__(self):
9777 
    L = ['%s=%r' % (key, value)
9778 
      for key, value in self.__dict__.iteritems()]
9779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9780 
 
9781 
  def __eq__(self, other):
9782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9783 
 
9784 
  def __ne__(self, other):
9785 
    return not (self == other)
9786 
 
9787 
class createAffiliate_result:
9788 
  """
9789 
  Attributes:
9790 
   - success
9791 
   - utx
9792 
  """
9793 
 
9794 
  thrift_spec = (
9795 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9796 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9797 
  )
9798 
 
9799 
  def __init__(self, success=None, utx=None,):
9800 
    self.success = success
9801 
    self.utx = utx
9802 
 
9803 
  def read(self, iprot):
9804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9806 
      return
9807 
    iprot.readStructBegin()
9808 
    while True:
9809 
      (fname, ftype, fid) = iprot.readFieldBegin()
9810 
      if ftype == TType.STOP:
9811 
        break
9812 
      if fid == 0:
9813 
        if ftype == TType.STRUCT:
9814 
          self.success = Affiliate()
9815 
          self.success.read(iprot)
9816 
        else:
9817 
          iprot.skip(ftype)
9818 
      elif fid == 1:
9819 
        if ftype == TType.STRUCT:
1996 vikas 9820 
          self.utx = UserAffiliateException()
1845 vikas 9821 
          self.utx.read(iprot)
9822 
        else:
9823 
          iprot.skip(ftype)
9824 
      else:
9825 
        iprot.skip(ftype)
9826 
      iprot.readFieldEnd()
9827 
    iprot.readStructEnd()
9828 
 
9829 
  def write(self, oprot):
9830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9832 
      return
9833 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9834 
    if self.success is not None:
1845 vikas 9835 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9836 
      self.success.write(oprot)
9837 
      oprot.writeFieldEnd()
3431 rajveer 9838 
    if self.utx is not None:
1845 vikas 9839 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9840 
      self.utx.write(oprot)
9841 
      oprot.writeFieldEnd()
9842 
    oprot.writeFieldStop()
9843 
    oprot.writeStructEnd()
9844 
 
3431 rajveer 9845 
  def validate(self):
9846 
    return
9847 
 
9848 
 
1845 vikas 9849 
  def __repr__(self):
9850 
    L = ['%s=%r' % (key, value)
9851 
      for key, value in self.__dict__.iteritems()]
9852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9853 
 
9854 
  def __eq__(self, other):
9855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9856 
 
9857 
  def __ne__(self, other):
9858 
    return not (self == other)
9859 
 
9860 
class getAffiliateById_args:
9861 
  """
9862 
  Attributes:
9863 
   - id
9864 
  """
9865 
 
9866 
  thrift_spec = (
9867 
    None, # 0
9868 
    (1, TType.I64, 'id', None, None, ), # 1
9869 
  )
9870 
 
9871 
  def __init__(self, id=None,):
9872 
    self.id = id
9873 
 
9874 
  def read(self, iprot):
9875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9877 
      return
9878 
    iprot.readStructBegin()
9879 
    while True:
9880 
      (fname, ftype, fid) = iprot.readFieldBegin()
9881 
      if ftype == TType.STOP:
9882 
        break
9883 
      if fid == 1:
9884 
        if ftype == TType.I64:
9885 
          self.id = iprot.readI64();
9886 
        else:
9887 
          iprot.skip(ftype)
9888 
      else:
9889 
        iprot.skip(ftype)
9890 
      iprot.readFieldEnd()
9891 
    iprot.readStructEnd()
9892 
 
9893 
  def write(self, oprot):
9894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9896 
      return
9897 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9898 
    if self.id is not None:
1845 vikas 9899 
      oprot.writeFieldBegin('id', TType.I64, 1)
9900 
      oprot.writeI64(self.id)
9901 
      oprot.writeFieldEnd()
9902 
    oprot.writeFieldStop()
9903 
    oprot.writeStructEnd()
9904 
 
3431 rajveer 9905 
  def validate(self):
9906 
    return
9907 
 
9908 
 
1845 vikas 9909 
  def __repr__(self):
9910 
    L = ['%s=%r' % (key, value)
9911 
      for key, value in self.__dict__.iteritems()]
9912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9913 
 
9914 
  def __eq__(self, other):
9915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9916 
 
9917 
  def __ne__(self, other):
9918 
    return not (self == other)
9919 
 
9920 
class getAffiliateById_result:
9921 
  """
9922 
  Attributes:
9923 
   - success
9924 
   - utx
9925 
  """
9926 
 
9927 
  thrift_spec = (
9928 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9929 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9930 
  )
9931 
 
9932 
  def __init__(self, success=None, utx=None,):
9933 
    self.success = success
9934 
    self.utx = utx
9935 
 
9936 
  def read(self, iprot):
9937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9939 
      return
9940 
    iprot.readStructBegin()
9941 
    while True:
9942 
      (fname, ftype, fid) = iprot.readFieldBegin()
9943 
      if ftype == TType.STOP:
9944 
        break
9945 
      if fid == 0:
9946 
        if ftype == TType.STRUCT:
9947 
          self.success = Affiliate()
9948 
          self.success.read(iprot)
9949 
        else:
9950 
          iprot.skip(ftype)
9951 
      elif fid == 1:
9952 
        if ftype == TType.STRUCT:
1996 vikas 9953 
          self.utx = UserAffiliateException()
1845 vikas 9954 
          self.utx.read(iprot)
9955 
        else:
9956 
          iprot.skip(ftype)
9957 
      else:
9958 
        iprot.skip(ftype)
9959 
      iprot.readFieldEnd()
9960 
    iprot.readStructEnd()
9961 
 
9962 
  def write(self, oprot):
9963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9965 
      return
9966 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9967 
    if self.success is not None:
1845 vikas 9968 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9969 
      self.success.write(oprot)
9970 
      oprot.writeFieldEnd()
3431 rajveer 9971 
    if self.utx is not None:
1845 vikas 9972 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9973 
      self.utx.write(oprot)
9974 
      oprot.writeFieldEnd()
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 getAffiliateByName_args:
9994 
  """
9995 
  Attributes:
9996 
   - name
9997 
  """
9998 
 
9999 
  thrift_spec = (
10000 
    None, # 0
10001 
    (1, TType.STRING, 'name', None, None, ), # 1
10002 
  )
10003 
 
10004 
  def __init__(self, name=None,):
10005 
    self.name = name
10006 
 
10007 
  def read(self, iprot):
10008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10010 
      return
10011 
    iprot.readStructBegin()
10012 
    while True:
10013 
      (fname, ftype, fid) = iprot.readFieldBegin()
10014 
      if ftype == TType.STOP:
10015 
        break
10016 
      if fid == 1:
10017 
        if ftype == TType.STRING:
10018 
          self.name = iprot.readString();
10019 
        else:
10020 
          iprot.skip(ftype)
10021 
      else:
10022 
        iprot.skip(ftype)
10023 
      iprot.readFieldEnd()
10024 
    iprot.readStructEnd()
10025 
 
10026 
  def write(self, oprot):
10027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10029 
      return
10030 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 10031 
    if self.name is not None:
1845 vikas 10032 
      oprot.writeFieldBegin('name', TType.STRING, 1)
10033 
      oprot.writeString(self.name)
10034 
      oprot.writeFieldEnd()
10035 
    oprot.writeFieldStop()
10036 
    oprot.writeStructEnd()
10037 
 
3431 rajveer 10038 
  def validate(self):
10039 
    return
10040 
 
10041 
 
1845 vikas 10042 
  def __repr__(self):
10043 
    L = ['%s=%r' % (key, value)
10044 
      for key, value in self.__dict__.iteritems()]
10045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10046 
 
10047 
  def __eq__(self, other):
10048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10049 
 
10050 
  def __ne__(self, other):
10051 
    return not (self == other)
10052 
 
10053 
class getAffiliateByName_result:
10054 
  """
10055 
  Attributes:
10056 
   - success
10057 
   - utx
10058 
  """
10059 
 
10060 
  thrift_spec = (
10061 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 10062 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10063 
  )
10064 
 
10065 
  def __init__(self, success=None, utx=None,):
10066 
    self.success = success
10067 
    self.utx = utx
10068 
 
10069 
  def read(self, iprot):
10070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10072 
      return
10073 
    iprot.readStructBegin()
10074 
    while True:
10075 
      (fname, ftype, fid) = iprot.readFieldBegin()
10076 
      if ftype == TType.STOP:
10077 
        break
10078 
      if fid == 0:
10079 
        if ftype == TType.STRUCT:
10080 
          self.success = Affiliate()
10081 
          self.success.read(iprot)
10082 
        else:
10083 
          iprot.skip(ftype)
10084 
      elif fid == 1:
10085 
        if ftype == TType.STRUCT:
1996 vikas 10086 
          self.utx = UserAffiliateException()
1845 vikas 10087 
          self.utx.read(iprot)
10088 
        else:
10089 
          iprot.skip(ftype)
10090 
      else:
10091 
        iprot.skip(ftype)
10092 
      iprot.readFieldEnd()
10093 
    iprot.readStructEnd()
10094 
 
10095 
  def write(self, oprot):
10096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10098 
      return
10099 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 10100 
    if self.success is not None:
1845 vikas 10101 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10102 
      self.success.write(oprot)
10103 
      oprot.writeFieldEnd()
3431 rajveer 10104 
    if self.utx is not None:
1845 vikas 10105 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10106 
      self.utx.write(oprot)
10107 
      oprot.writeFieldEnd()
10108 
    oprot.writeFieldStop()
10109 
    oprot.writeStructEnd()
10110 
 
3431 rajveer 10111 
  def validate(self):
10112 
    return
10113 
 
10114 
 
1845 vikas 10115 
  def __repr__(self):
10116 
    L = ['%s=%r' % (key, value)
10117 
      for key, value in self.__dict__.iteritems()]
10118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10119 
 
10120 
  def __eq__(self, other):
10121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10122 
 
10123 
  def __ne__(self, other):
10124 
    return not (self == other)
10125 
 
1996 vikas 10126 
class getTrackerById_args:
1845 vikas 10127 
  """
10128 
  Attributes:
10129 
   - id
10130 
  """
10131 
 
10132 
  thrift_spec = (
10133 
    None, # 0
10134 
    (1, TType.I64, 'id', None, None, ), # 1
10135 
  )
10136 
 
10137 
  def __init__(self, id=None,):
10138 
    self.id = id
10139 
 
10140 
  def read(self, iprot):
10141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10143 
      return
10144 
    iprot.readStructBegin()
10145 
    while True:
10146 
      (fname, ftype, fid) = iprot.readFieldBegin()
10147 
      if ftype == TType.STOP:
10148 
        break
10149 
      if fid == 1:
10150 
        if ftype == TType.I64:
10151 
          self.id = iprot.readI64();
10152 
        else:
10153 
          iprot.skip(ftype)
10154 
      else:
10155 
        iprot.skip(ftype)
10156 
      iprot.readFieldEnd()
10157 
    iprot.readStructEnd()
10158 
 
10159 
  def write(self, oprot):
10160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10162 
      return
1996 vikas 10163 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 10164 
    if self.id is not None:
1845 vikas 10165 
      oprot.writeFieldBegin('id', TType.I64, 1)
10166 
      oprot.writeI64(self.id)
10167 
      oprot.writeFieldEnd()
10168 
    oprot.writeFieldStop()
10169 
    oprot.writeStructEnd()
10170 
 
3431 rajveer 10171 
  def validate(self):
10172 
    return
10173 
 
10174 
 
1845 vikas 10175 
  def __repr__(self):
10176 
    L = ['%s=%r' % (key, value)
10177 
      for key, value in self.__dict__.iteritems()]
10178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10179 
 
10180 
  def __eq__(self, other):
10181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10182 
 
10183 
  def __ne__(self, other):
10184 
    return not (self == other)
10185 
 
10186 
class getTrackerById_result:
10187 
  """
10188 
  Attributes:
10189 
   - success
10190 
   - utx
10191 
  """
10192 
 
10193 
  thrift_spec = (
10194 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 10195 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10196 
  )
10197 
 
10198 
  def __init__(self, success=None, utx=None,):
10199 
    self.success = success
10200 
    self.utx = utx
10201 
 
10202 
  def read(self, iprot):
10203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10205 
      return
10206 
    iprot.readStructBegin()
10207 
    while True:
10208 
      (fname, ftype, fid) = iprot.readFieldBegin()
10209 
      if ftype == TType.STOP:
10210 
        break
10211 
      if fid == 0:
10212 
        if ftype == TType.STRUCT:
10213 
          self.success = Tracker()
10214 
          self.success.read(iprot)
10215 
        else:
10216 
          iprot.skip(ftype)
10217 
      elif fid == 1:
10218 
        if ftype == TType.STRUCT:
1996 vikas 10219 
          self.utx = UserAffiliateException()
1845 vikas 10220 
          self.utx.read(iprot)
10221 
        else:
10222 
          iprot.skip(ftype)
10223 
      else:
10224 
        iprot.skip(ftype)
10225 
      iprot.readFieldEnd()
10226 
    iprot.readStructEnd()
10227 
 
10228 
  def write(self, oprot):
10229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10231 
      return
10232 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 10233 
    if self.success is not None:
1845 vikas 10234 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10235 
      self.success.write(oprot)
10236 
      oprot.writeFieldEnd()
3431 rajveer 10237 
    if self.utx is not None:
1845 vikas 10238 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10239 
      self.utx.write(oprot)
10240 
      oprot.writeFieldEnd()
10241 
    oprot.writeFieldStop()
10242 
    oprot.writeStructEnd()
10243 
 
3431 rajveer 10244 
  def validate(self):
10245 
    return
10246 
 
10247 
 
1845 vikas 10248 
  def __repr__(self):
10249 
    L = ['%s=%r' % (key, value)
10250 
      for key, value in self.__dict__.iteritems()]
10251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10252 
 
10253 
  def __eq__(self, other):
10254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10255 
 
10256 
  def __ne__(self, other):
10257 
    return not (self == other)
10258 
 
1996 vikas 10259 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 10260 
  """
10261 
  Attributes:
1996 vikas 10262 
   - id
1845 vikas 10263 
  """
10264 
 
10265 
  thrift_spec = (
10266 
    None, # 0
1996 vikas 10267 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 10268 
  )
10269 
 
1996 vikas 10270 
  def __init__(self, id=None,):
10271 
    self.id = id
1845 vikas 10272 
 
10273 
  def read(self, iprot):
10274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10276 
      return
10277 
    iprot.readStructBegin()
10278 
    while True:
10279 
      (fname, ftype, fid) = iprot.readFieldBegin()
10280 
      if ftype == TType.STOP:
10281 
        break
10282 
      if fid == 1:
10283 
        if ftype == TType.I64:
1996 vikas 10284 
          self.id = iprot.readI64();
1845 vikas 10285 
        else:
10286 
          iprot.skip(ftype)
10287 
      else:
10288 
        iprot.skip(ftype)
10289 
      iprot.readFieldEnd()
10290 
    iprot.readStructEnd()
10291 
 
10292 
  def write(self, oprot):
10293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10295 
      return
1996 vikas 10296 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 10297 
    if self.id is not None:
1996 vikas 10298 
      oprot.writeFieldBegin('id', TType.I64, 1)
10299 
      oprot.writeI64(self.id)
1845 vikas 10300 
      oprot.writeFieldEnd()
10301 
    oprot.writeFieldStop()
10302 
    oprot.writeStructEnd()
10303 
 
3431 rajveer 10304 
  def validate(self):
10305 
    return
10306 
 
10307 
 
1845 vikas 10308 
  def __repr__(self):
10309 
    L = ['%s=%r' % (key, value)
10310 
      for key, value in self.__dict__.iteritems()]
10311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10312 
 
10313 
  def __eq__(self, other):
10314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10315 
 
10316 
  def __ne__(self, other):
10317 
    return not (self == other)
10318 
 
1996 vikas 10319 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 10320 
  """
10321 
  Attributes:
10322 
   - success
10323 
   - utx
10324 
  """
10325 
 
10326 
  thrift_spec = (
1996 vikas 10327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
10328 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10329 
  )
10330 
 
10331 
  def __init__(self, success=None, utx=None,):
10332 
    self.success = success
10333 
    self.utx = utx
10334 
 
10335 
  def read(self, iprot):
10336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10338 
      return
10339 
    iprot.readStructBegin()
10340 
    while True:
10341 
      (fname, ftype, fid) = iprot.readFieldBegin()
10342 
      if ftype == TType.STOP:
10343 
        break
10344 
      if fid == 0:
10345 
        if ftype == TType.LIST:
10346 
          self.success = []
11592 amit.gupta 10347 
          (_etype128, _size125) = iprot.readListBegin()
10348 
          for _i129 in xrange(_size125):
10349 
            _elem130 = Affiliate()
10350 
            _elem130.read(iprot)
10351 
            self.success.append(_elem130)
1845 vikas 10352 
          iprot.readListEnd()
10353 
        else:
10354 
          iprot.skip(ftype)
10355 
      elif fid == 1:
10356 
        if ftype == TType.STRUCT:
1996 vikas 10357 
          self.utx = UserAffiliateException()
1845 vikas 10358 
          self.utx.read(iprot)
10359 
        else:
10360 
          iprot.skip(ftype)
10361 
      else:
10362 
        iprot.skip(ftype)
10363 
      iprot.readFieldEnd()
10364 
    iprot.readStructEnd()
10365 
 
10366 
  def write(self, oprot):
10367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10369 
      return
1996 vikas 10370 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 10371 
    if self.success is not None:
1845 vikas 10372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10374 
      for iter131 in self.success:
10375 
        iter131.write(oprot)
1845 vikas 10376 
      oprot.writeListEnd()
10377 
      oprot.writeFieldEnd()
3431 rajveer 10378 
    if self.utx is not None:
1845 vikas 10379 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10380 
      self.utx.write(oprot)
10381 
      oprot.writeFieldEnd()
10382 
    oprot.writeFieldStop()
10383 
    oprot.writeStructEnd()
10384 
 
3431 rajveer 10385 
  def validate(self):
10386 
    return
10387 
 
10388 
 
1845 vikas 10389 
  def __repr__(self):
10390 
    L = ['%s=%r' % (key, value)
10391 
      for key, value in self.__dict__.iteritems()]
10392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10393 
 
10394 
  def __eq__(self, other):
10395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10396 
 
10397 
  def __ne__(self, other):
10398 
    return not (self == other)
10399 
 
10400 
class addTrackLog_args:
10401 
  """
10402 
  Attributes:
1996 vikas 10403 
   - affiliateId
1845 vikas 10404 
   - userId
10405 
   - event
10406 
   - url
10407 
   - data
1859 vikas 10408 
   - addedOn
1845 vikas 10409 
  """
10410 
 
10411 
  thrift_spec = (
10412 
    None, # 0
1996 vikas 10413 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 10414 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 10415 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 10416 
    (4, TType.STRING, 'url', None, None, ), # 4
10417 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 10418 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 10419 
  )
10420 
 
1996 vikas 10421 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
10422 
    self.affiliateId = affiliateId
1845 vikas 10423 
    self.userId = userId
10424 
    self.event = event
10425 
    self.url = url
10426 
    self.data = data
1859 vikas 10427 
    self.addedOn = addedOn
1845 vikas 10428 
 
10429 
  def read(self, iprot):
10430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10432 
      return
10433 
    iprot.readStructBegin()
10434 
    while True:
10435 
      (fname, ftype, fid) = iprot.readFieldBegin()
10436 
      if ftype == TType.STOP:
10437 
        break
10438 
      if fid == 1:
10439 
        if ftype == TType.I64:
1996 vikas 10440 
          self.affiliateId = iprot.readI64();
1845 vikas 10441 
        else:
10442 
          iprot.skip(ftype)
10443 
      elif fid == 2:
10444 
        if ftype == TType.I64:
10445 
          self.userId = iprot.readI64();
10446 
        else:
10447 
          iprot.skip(ftype)
10448 
      elif fid == 3:
3378 vikas 10449 
        if ftype == TType.I32:
10450 
          self.event = iprot.readI32();
1845 vikas 10451 
        else:
10452 
          iprot.skip(ftype)
10453 
      elif fid == 4:
10454 
        if ftype == TType.STRING:
10455 
          self.url = iprot.readString();
10456 
        else:
10457 
          iprot.skip(ftype)
10458 
      elif fid == 5:
10459 
        if ftype == TType.STRING:
10460 
          self.data = iprot.readString();
10461 
        else:
10462 
          iprot.skip(ftype)
1859 vikas 10463 
      elif fid == 6:
10464 
        if ftype == TType.I64:
10465 
          self.addedOn = iprot.readI64();
10466 
        else:
10467 
          iprot.skip(ftype)
1845 vikas 10468 
      else:
10469 
        iprot.skip(ftype)
10470 
      iprot.readFieldEnd()
10471 
    iprot.readStructEnd()
10472 
 
10473 
  def write(self, oprot):
10474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10476 
      return
10477 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10478 
    if self.affiliateId is not None:
1996 vikas 10479 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10480 
      oprot.writeI64(self.affiliateId)
1845 vikas 10481 
      oprot.writeFieldEnd()
3431 rajveer 10482 
    if self.userId is not None:
1845 vikas 10483 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10484 
      oprot.writeI64(self.userId)
10485 
      oprot.writeFieldEnd()
3431 rajveer 10486 
    if self.event is not None:
3378 vikas 10487 
      oprot.writeFieldBegin('event', TType.I32, 3)
10488 
      oprot.writeI32(self.event)
1845 vikas 10489 
      oprot.writeFieldEnd()
3431 rajveer 10490 
    if self.url is not None:
1845 vikas 10491 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10492 
      oprot.writeString(self.url)
10493 
      oprot.writeFieldEnd()
3431 rajveer 10494 
    if self.data is not None:
1845 vikas 10495 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10496 
      oprot.writeString(self.data)
10497 
      oprot.writeFieldEnd()
3431 rajveer 10498 
    if self.addedOn is not None:
1859 vikas 10499 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10500 
      oprot.writeI64(self.addedOn)
10501 
      oprot.writeFieldEnd()
1845 vikas 10502 
    oprot.writeFieldStop()
10503 
    oprot.writeStructEnd()
10504 
 
3431 rajveer 10505 
  def validate(self):
10506 
    return
10507 
 
10508 
 
1845 vikas 10509 
  def __repr__(self):
10510 
    L = ['%s=%r' % (key, value)
10511 
      for key, value in self.__dict__.iteritems()]
10512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10513 
 
10514 
  def __eq__(self, other):
10515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10516 
 
10517 
  def __ne__(self, other):
10518 
    return not (self == other)
10519 
 
10520 
class addTrackLog_result:
10521 
  """
10522 
  Attributes:
10523 
   - success
10524 
   - utx
10525 
  """
10526 
 
10527 
  thrift_spec = (
10528 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10529 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10530 
  )
10531 
 
10532 
  def __init__(self, success=None, utx=None,):
10533 
    self.success = success
10534 
    self.utx = utx
10535 
 
10536 
  def read(self, iprot):
10537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10539 
      return
10540 
    iprot.readStructBegin()
10541 
    while True:
10542 
      (fname, ftype, fid) = iprot.readFieldBegin()
10543 
      if ftype == TType.STOP:
10544 
        break
10545 
      if fid == 0:
10546 
        if ftype == TType.I64:
10547 
          self.success = iprot.readI64();
10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      elif fid == 1:
10551 
        if ftype == TType.STRUCT:
1996 vikas 10552 
          self.utx = UserAffiliateException()
1845 vikas 10553 
          self.utx.read(iprot)
10554 
        else:
10555 
          iprot.skip(ftype)
10556 
      else:
10557 
        iprot.skip(ftype)
10558 
      iprot.readFieldEnd()
10559 
    iprot.readStructEnd()
10560 
 
10561 
  def write(self, oprot):
10562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10564 
      return
10565 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10566 
    if self.success is not None:
1845 vikas 10567 
      oprot.writeFieldBegin('success', TType.I64, 0)
10568 
      oprot.writeI64(self.success)
10569 
      oprot.writeFieldEnd()
3431 rajveer 10570 
    if self.utx is not None:
1845 vikas 10571 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10572 
      self.utx.write(oprot)
10573 
      oprot.writeFieldEnd()
10574 
    oprot.writeFieldStop()
10575 
    oprot.writeStructEnd()
10576 
 
3431 rajveer 10577 
  def validate(self):
10578 
    return
10579 
 
10580 
 
1845 vikas 10581 
  def __repr__(self):
10582 
    L = ['%s=%r' % (key, value)
10583 
      for key, value in self.__dict__.iteritems()]
10584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10585 
 
10586 
  def __eq__(self, other):
10587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10588 
 
10589 
  def __ne__(self, other):
10590 
    return not (self == other)
10591 
 
10592 
class getTrackLogById_args:
10593 
  """
10594 
  Attributes:
10595 
   - id
10596 
  """
10597 
 
10598 
  thrift_spec = (
10599 
    None, # 0
10600 
    (1, TType.I64, 'id', None, None, ), # 1
10601 
  )
10602 
 
10603 
  def __init__(self, id=None,):
10604 
    self.id = id
10605 
 
10606 
  def read(self, iprot):
10607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10609 
      return
10610 
    iprot.readStructBegin()
10611 
    while True:
10612 
      (fname, ftype, fid) = iprot.readFieldBegin()
10613 
      if ftype == TType.STOP:
10614 
        break
10615 
      if fid == 1:
10616 
        if ftype == TType.I64:
10617 
          self.id = iprot.readI64();
10618 
        else:
10619 
          iprot.skip(ftype)
10620 
      else:
10621 
        iprot.skip(ftype)
10622 
      iprot.readFieldEnd()
10623 
    iprot.readStructEnd()
10624 
 
10625 
  def write(self, oprot):
10626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10628 
      return
10629 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10630 
    if self.id is not None:
1845 vikas 10631 
      oprot.writeFieldBegin('id', TType.I64, 1)
10632 
      oprot.writeI64(self.id)
10633 
      oprot.writeFieldEnd()
10634 
    oprot.writeFieldStop()
10635 
    oprot.writeStructEnd()
10636 
 
3431 rajveer 10637 
  def validate(self):
10638 
    return
10639 
 
10640 
 
1845 vikas 10641 
  def __repr__(self):
10642 
    L = ['%s=%r' % (key, value)
10643 
      for key, value in self.__dict__.iteritems()]
10644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10645 
 
10646 
  def __eq__(self, other):
10647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10648 
 
10649 
  def __ne__(self, other):
10650 
    return not (self == other)
10651 
 
10652 
class getTrackLogById_result:
10653 
  """
10654 
  Attributes:
10655 
   - success
10656 
   - utx
10657 
  """
10658 
 
10659 
  thrift_spec = (
10660 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10661 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10662 
  )
10663 
 
10664 
  def __init__(self, success=None, utx=None,):
10665 
    self.success = success
10666 
    self.utx = utx
10667 
 
10668 
  def read(self, iprot):
10669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10671 
      return
10672 
    iprot.readStructBegin()
10673 
    while True:
10674 
      (fname, ftype, fid) = iprot.readFieldBegin()
10675 
      if ftype == TType.STOP:
10676 
        break
10677 
      if fid == 0:
10678 
        if ftype == TType.STRUCT:
10679 
          self.success = TrackLog()
10680 
          self.success.read(iprot)
10681 
        else:
10682 
          iprot.skip(ftype)
10683 
      elif fid == 1:
10684 
        if ftype == TType.STRUCT:
1996 vikas 10685 
          self.utx = UserAffiliateException()
1845 vikas 10686 
          self.utx.read(iprot)
10687 
        else:
10688 
          iprot.skip(ftype)
10689 
      else:
10690 
        iprot.skip(ftype)
10691 
      iprot.readFieldEnd()
10692 
    iprot.readStructEnd()
10693 
 
10694 
  def write(self, oprot):
10695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10697 
      return
10698 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10699 
    if self.success is not None:
1845 vikas 10700 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10701 
      self.success.write(oprot)
10702 
      oprot.writeFieldEnd()
3431 rajveer 10703 
    if self.utx is not None:
1845 vikas 10704 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10705 
      self.utx.write(oprot)
10706 
      oprot.writeFieldEnd()
10707 
    oprot.writeFieldStop()
10708 
    oprot.writeStructEnd()
10709 
 
3431 rajveer 10710 
  def validate(self):
10711 
    return
10712 
 
10713 
 
1845 vikas 10714 
  def __repr__(self):
10715 
    L = ['%s=%r' % (key, value)
10716 
      for key, value in self.__dict__.iteritems()]
10717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10718 
 
10719 
  def __eq__(self, other):
10720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10721 
 
10722 
  def __ne__(self, other):
10723 
    return not (self == other)
10724 
 
1996 vikas 10725 
class getTrackLogsByAffiliate_args:
1845 vikas 10726 
  """
10727 
  Attributes:
1996 vikas 10728 
   - affiliateId
3293 vikas 10729 
   - startDate
10730 
   - endDate
1845 vikas 10731 
  """
10732 
 
10733 
  thrift_spec = (
10734 
    None, # 0
1996 vikas 10735 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10736 
    (2, TType.I64, 'startDate', None, None, ), # 2
10737 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10738 
  )
10739 
 
3293 vikas 10740 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10741 
    self.affiliateId = affiliateId
3293 vikas 10742 
    self.startDate = startDate
10743 
    self.endDate = endDate
1845 vikas 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 == 1:
10755 
        if ftype == TType.I64:
1996 vikas 10756 
          self.affiliateId = iprot.readI64();
1845 vikas 10757 
        else:
10758 
          iprot.skip(ftype)
3293 vikas 10759 
      elif fid == 2:
10760 
        if ftype == TType.I64:
10761 
          self.startDate = iprot.readI64();
10762 
        else:
10763 
          iprot.skip(ftype)
10764 
      elif fid == 3:
10765 
        if ftype == TType.I64:
10766 
          self.endDate = iprot.readI64();
10767 
        else:
10768 
          iprot.skip(ftype)
1845 vikas 10769 
      else:
10770 
        iprot.skip(ftype)
10771 
      iprot.readFieldEnd()
10772 
    iprot.readStructEnd()
10773 
 
10774 
  def write(self, oprot):
10775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10777 
      return
1996 vikas 10778 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10779 
    if self.affiliateId is not None:
1996 vikas 10780 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10781 
      oprot.writeI64(self.affiliateId)
1845 vikas 10782 
      oprot.writeFieldEnd()
3431 rajveer 10783 
    if self.startDate is not None:
3293 vikas 10784 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10785 
      oprot.writeI64(self.startDate)
10786 
      oprot.writeFieldEnd()
3431 rajveer 10787 
    if self.endDate is not None:
3293 vikas 10788 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10789 
      oprot.writeI64(self.endDate)
10790 
      oprot.writeFieldEnd()
1845 vikas 10791 
    oprot.writeFieldStop()
10792 
    oprot.writeStructEnd()
10793 
 
3431 rajveer 10794 
  def validate(self):
10795 
    return
10796 
 
10797 
 
1845 vikas 10798 
  def __repr__(self):
10799 
    L = ['%s=%r' % (key, value)
10800 
      for key, value in self.__dict__.iteritems()]
10801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10802 
 
10803 
  def __eq__(self, other):
10804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10805 
 
10806 
  def __ne__(self, other):
10807 
    return not (self == other)
10808 
 
1996 vikas 10809 
class getTrackLogsByAffiliate_result:
1845 vikas 10810 
  """
10811 
  Attributes:
10812 
   - success
10813 
   - utx
10814 
  """
10815 
 
10816 
  thrift_spec = (
10817 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10818 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10819 
  )
10820 
 
10821 
  def __init__(self, success=None, utx=None,):
10822 
    self.success = success
10823 
    self.utx = utx
10824 
 
10825 
  def read(self, iprot):
10826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10828 
      return
10829 
    iprot.readStructBegin()
10830 
    while True:
10831 
      (fname, ftype, fid) = iprot.readFieldBegin()
10832 
      if ftype == TType.STOP:
10833 
        break
10834 
      if fid == 0:
10835 
        if ftype == TType.LIST:
10836 
          self.success = []
11592 amit.gupta 10837 
          (_etype135, _size132) = iprot.readListBegin()
10838 
          for _i136 in xrange(_size132):
10839 
            _elem137 = TrackLog()
10840 
            _elem137.read(iprot)
10841 
            self.success.append(_elem137)
1845 vikas 10842 
          iprot.readListEnd()
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      elif fid == 1:
10846 
        if ftype == TType.STRUCT:
1996 vikas 10847 
          self.utx = UserAffiliateException()
1845 vikas 10848 
          self.utx.read(iprot)
10849 
        else:
10850 
          iprot.skip(ftype)
10851 
      else:
10852 
        iprot.skip(ftype)
10853 
      iprot.readFieldEnd()
10854 
    iprot.readStructEnd()
10855 
 
10856 
  def write(self, oprot):
10857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10859 
      return
1996 vikas 10860 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10861 
    if self.success is not None:
1845 vikas 10862 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10863 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10864 
      for iter138 in self.success:
10865 
        iter138.write(oprot)
1845 vikas 10866 
      oprot.writeListEnd()
10867 
      oprot.writeFieldEnd()
3431 rajveer 10868 
    if self.utx is not None:
1845 vikas 10869 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10870 
      self.utx.write(oprot)
10871 
      oprot.writeFieldEnd()
10872 
    oprot.writeFieldStop()
10873 
    oprot.writeStructEnd()
10874 
 
3431 rajveer 10875 
  def validate(self):
10876 
    return
10877 
 
10878 
 
1845 vikas 10879 
  def __repr__(self):
10880 
    L = ['%s=%r' % (key, value)
10881 
      for key, value in self.__dict__.iteritems()]
10882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10883 
 
10884 
  def __eq__(self, other):
10885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10886 
 
10887 
  def __ne__(self, other):
10888 
    return not (self == other)
10889 
 
10890 
class getTrackLogsByUser_args:
10891 
  """
10892 
  Attributes:
10893 
   - userId
10894 
  """
10895 
 
10896 
  thrift_spec = (
10897 
    None, # 0
10898 
    (1, TType.I64, 'userId', None, None, ), # 1
10899 
  )
10900 
 
10901 
  def __init__(self, userId=None,):
10902 
    self.userId = userId
10903 
 
10904 
  def read(self, iprot):
10905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10907 
      return
10908 
    iprot.readStructBegin()
10909 
    while True:
10910 
      (fname, ftype, fid) = iprot.readFieldBegin()
10911 
      if ftype == TType.STOP:
10912 
        break
10913 
      if fid == 1:
10914 
        if ftype == TType.I64:
10915 
          self.userId = iprot.readI64();
10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      else:
10919 
        iprot.skip(ftype)
10920 
      iprot.readFieldEnd()
10921 
    iprot.readStructEnd()
10922 
 
10923 
  def write(self, oprot):
10924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10926 
      return
10927 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10928 
    if self.userId is not None:
1845 vikas 10929 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10930 
      oprot.writeI64(self.userId)
10931 
      oprot.writeFieldEnd()
10932 
    oprot.writeFieldStop()
10933 
    oprot.writeStructEnd()
10934 
 
3431 rajveer 10935 
  def validate(self):
10936 
    return
10937 
 
10938 
 
1845 vikas 10939 
  def __repr__(self):
10940 
    L = ['%s=%r' % (key, value)
10941 
      for key, value in self.__dict__.iteritems()]
10942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10943 
 
10944 
  def __eq__(self, other):
10945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10946 
 
10947 
  def __ne__(self, other):
10948 
    return not (self == other)
10949 
 
10950 
class getTrackLogsByUser_result:
10951 
  """
10952 
  Attributes:
10953 
   - success
10954 
   - utx
10955 
  """
10956 
 
10957 
  thrift_spec = (
10958 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10959 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10960 
  )
10961 
 
10962 
  def __init__(self, success=None, utx=None,):
10963 
    self.success = success
10964 
    self.utx = utx
10965 
 
10966 
  def read(self, iprot):
10967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10969 
      return
10970 
    iprot.readStructBegin()
10971 
    while True:
10972 
      (fname, ftype, fid) = iprot.readFieldBegin()
10973 
      if ftype == TType.STOP:
10974 
        break
10975 
      if fid == 0:
10976 
        if ftype == TType.LIST:
10977 
          self.success = []
11592 amit.gupta 10978 
          (_etype142, _size139) = iprot.readListBegin()
10979 
          for _i143 in xrange(_size139):
10980 
            _elem144 = TrackLog()
10981 
            _elem144.read(iprot)
10982 
            self.success.append(_elem144)
1845 vikas 10983 
          iprot.readListEnd()
10984 
        else:
10985 
          iprot.skip(ftype)
10986 
      elif fid == 1:
10987 
        if ftype == TType.STRUCT:
1996 vikas 10988 
          self.utx = UserAffiliateException()
1845 vikas 10989 
          self.utx.read(iprot)
10990 
        else:
10991 
          iprot.skip(ftype)
10992 
      else:
10993 
        iprot.skip(ftype)
10994 
      iprot.readFieldEnd()
10995 
    iprot.readStructEnd()
10996 
 
10997 
  def write(self, oprot):
10998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11000 
      return
11001 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 11002 
    if self.success is not None:
1845 vikas 11003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11005 
      for iter145 in self.success:
11006 
        iter145.write(oprot)
1845 vikas 11007 
      oprot.writeListEnd()
11008 
      oprot.writeFieldEnd()
3431 rajveer 11009 
    if self.utx is not None:
1845 vikas 11010 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
11011 
      self.utx.write(oprot)
11012 
      oprot.writeFieldEnd()
11013 
    oprot.writeFieldStop()
11014 
    oprot.writeStructEnd()
11015 
 
3431 rajveer 11016 
  def validate(self):
11017 
    return
11018 
 
11019 
 
1845 vikas 11020 
  def __repr__(self):
11021 
    L = ['%s=%r' % (key, value)
11022 
      for key, value in self.__dict__.iteritems()]
11023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11024 
 
11025 
  def __eq__(self, other):
11026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11027 
 
11028 
  def __ne__(self, other):
11029 
    return not (self == other)
11030 
 
11031 
class getTrackLogs_args:
11032 
  """
11033 
  Attributes:
11034 
   - userId
11035 
   - event
11036 
   - url
11037 
  """
11038 
 
11039 
  thrift_spec = (
11040 
    None, # 0
1996 vikas 11041 
    (1, TType.I64, 'userId', None, None, ), # 1
11042 
    (2, TType.STRING, 'event', None, None, ), # 2
11043 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 11044 
  )
11045 
 
1996 vikas 11046 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 11047 
    self.userId = userId
11048 
    self.event = event
11049 
    self.url = url
11050 
 
11051 
  def read(self, iprot):
11052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11054 
      return
11055 
    iprot.readStructBegin()
11056 
    while True:
11057 
      (fname, ftype, fid) = iprot.readFieldBegin()
11058 
      if ftype == TType.STOP:
11059 
        break
11060 
      if fid == 1:
11061 
        if ftype == TType.I64:
1996 vikas 11062 
          self.userId = iprot.readI64();
1845 vikas 11063 
        else:
11064 
          iprot.skip(ftype)
11065 
      elif fid == 2:
11066 
        if ftype == TType.STRING:
11067 
          self.event = iprot.readString();
11068 
        else:
11069 
          iprot.skip(ftype)
1996 vikas 11070 
      elif fid == 3:
1845 vikas 11071 
        if ftype == TType.STRING:
11072 
          self.url = iprot.readString();
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      else:
11076 
        iprot.skip(ftype)
11077 
      iprot.readFieldEnd()
11078 
    iprot.readStructEnd()
11079 
 
11080 
  def write(self, oprot):
11081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11083 
      return
11084 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 11085 
    if self.userId is not None:
1996 vikas 11086 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 11087 
      oprot.writeI64(self.userId)
11088 
      oprot.writeFieldEnd()
3431 rajveer 11089 
    if self.event is not None:
1996 vikas 11090 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 11091 
      oprot.writeString(self.event)
11092 
      oprot.writeFieldEnd()
3431 rajveer 11093 
    if self.url is not None:
1996 vikas 11094 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 11095 
      oprot.writeString(self.url)
11096 
      oprot.writeFieldEnd()
11097 
    oprot.writeFieldStop()
11098 
    oprot.writeStructEnd()
11099 
 
3431 rajveer 11100 
  def validate(self):
11101 
    return
11102 
 
11103 
 
1845 vikas 11104 
  def __repr__(self):
11105 
    L = ['%s=%r' % (key, value)
11106 
      for key, value in self.__dict__.iteritems()]
11107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11108 
 
11109 
  def __eq__(self, other):
11110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11111 
 
11112 
  def __ne__(self, other):
11113 
    return not (self == other)
11114 
 
11115 
class getTrackLogs_result:
11116 
  """
11117 
  Attributes:
11118 
   - success
11119 
   - utx
11120 
  """
11121 
 
11122 
  thrift_spec = (
11123 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 11124 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 11125 
  )
11126 
 
11127 
  def __init__(self, success=None, utx=None,):
11128 
    self.success = success
11129 
    self.utx = utx
11130 
 
11131 
  def read(self, iprot):
11132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11134 
      return
11135 
    iprot.readStructBegin()
11136 
    while True:
11137 
      (fname, ftype, fid) = iprot.readFieldBegin()
11138 
      if ftype == TType.STOP:
11139 
        break
11140 
      if fid == 0:
11141 
        if ftype == TType.LIST:
11142 
          self.success = []
11592 amit.gupta 11143 
          (_etype149, _size146) = iprot.readListBegin()
11144 
          for _i150 in xrange(_size146):
11145 
            _elem151 = TrackLog()
11146 
            _elem151.read(iprot)
11147 
            self.success.append(_elem151)
1845 vikas 11148 
          iprot.readListEnd()
11149 
        else:
11150 
          iprot.skip(ftype)
11151 
      elif fid == 1:
11152 
        if ftype == TType.STRUCT:
1996 vikas 11153 
          self.utx = UserAffiliateException()
1845 vikas 11154 
          self.utx.read(iprot)
11155 
        else:
11156 
          iprot.skip(ftype)
11157 
      else:
11158 
        iprot.skip(ftype)
11159 
      iprot.readFieldEnd()
11160 
    iprot.readStructEnd()
11161 
 
11162 
  def write(self, oprot):
11163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11165 
      return
11166 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 11167 
    if self.success is not None:
1845 vikas 11168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11169 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11170 
      for iter152 in self.success:
11171 
        iter152.write(oprot)
1845 vikas 11172 
      oprot.writeListEnd()
11173 
      oprot.writeFieldEnd()
3431 rajveer 11174 
    if self.utx is not None:
1845 vikas 11175 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
11176 
      self.utx.write(oprot)
11177 
      oprot.writeFieldEnd()
11178 
    oprot.writeFieldStop()
11179 
    oprot.writeStructEnd()
11180 
 
3431 rajveer 11181 
  def validate(self):
11182 
    return
11183 
 
11184 
 
1845 vikas 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 
 
559 chandransh 11196 
class getCurrentCart_args:
94 ashish 11197 
  """
11198 
  Attributes:
559 chandransh 11199 
   - userId
11200 
  """
11201 
 
11202 
  thrift_spec = (
11203 
    None, # 0
11204 
    (1, TType.I64, 'userId', None, None, ), # 1
11205 
  )
11206 
 
11207 
  def __init__(self, userId=None,):
11208 
    self.userId = userId
11209 
 
11210 
  def read(self, iprot):
11211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11213 
      return
11214 
    iprot.readStructBegin()
11215 
    while True:
11216 
      (fname, ftype, fid) = iprot.readFieldBegin()
11217 
      if ftype == TType.STOP:
11218 
        break
11219 
      if fid == 1:
11220 
        if ftype == TType.I64:
11221 
          self.userId = iprot.readI64();
11222 
        else:
11223 
          iprot.skip(ftype)
11224 
      else:
11225 
        iprot.skip(ftype)
11226 
      iprot.readFieldEnd()
11227 
    iprot.readStructEnd()
11228 
 
11229 
  def write(self, oprot):
11230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11232 
      return
11233 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 11234 
    if self.userId is not None:
559 chandransh 11235 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11236 
      oprot.writeI64(self.userId)
11237 
      oprot.writeFieldEnd()
11238 
    oprot.writeFieldStop()
11239 
    oprot.writeStructEnd()
11240 
 
3431 rajveer 11241 
  def validate(self):
11242 
    return
11243 
 
11244 
 
559 chandransh 11245 
  def __repr__(self):
11246 
    L = ['%s=%r' % (key, value)
11247 
      for key, value in self.__dict__.iteritems()]
11248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11249 
 
11250 
  def __eq__(self, other):
11251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11252 
 
11253 
  def __ne__(self, other):
11254 
    return not (self == other)
11255 
 
11256 
class getCurrentCart_result:
11257 
  """
11258 
  Attributes:
94 ashish 11259 
   - success
559 chandransh 11260 
   - scx
94 ashish 11261 
  """
11262 
 
11263 
  thrift_spec = (
559 chandransh 11264 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11265 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11266 
  )
11267 
 
559 chandransh 11268 
  def __init__(self, success=None, scx=None,):
94 ashish 11269 
    self.success = success
559 chandransh 11270 
    self.scx = scx
94 ashish 11271 
 
11272 
  def read(self, iprot):
11273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11275 
      return
11276 
    iprot.readStructBegin()
11277 
    while True:
11278 
      (fname, ftype, fid) = iprot.readFieldBegin()
11279 
      if ftype == TType.STOP:
11280 
        break
11281 
      if fid == 0:
559 chandransh 11282 
        if ftype == TType.STRUCT:
11283 
          self.success = Cart()
11284 
          self.success.read(iprot)
94 ashish 11285 
        else:
11286 
          iprot.skip(ftype)
11287 
      elif fid == 1:
11288 
        if ftype == TType.STRUCT:
559 chandransh 11289 
          self.scx = ShoppingCartException()
11290 
          self.scx.read(iprot)
94 ashish 11291 
        else:
11292 
          iprot.skip(ftype)
11293 
      else:
11294 
        iprot.skip(ftype)
11295 
      iprot.readFieldEnd()
11296 
    iprot.readStructEnd()
11297 
 
11298 
  def write(self, oprot):
11299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11301 
      return
559 chandransh 11302 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 11303 
    if self.success is not None:
559 chandransh 11304 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11305 
      self.success.write(oprot)
94 ashish 11306 
      oprot.writeFieldEnd()
3431 rajveer 11307 
    if self.scx is not None:
559 chandransh 11308 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11309 
      self.scx.write(oprot)
94 ashish 11310 
      oprot.writeFieldEnd()
11311 
    oprot.writeFieldStop()
11312 
    oprot.writeStructEnd()
11313 
 
3431 rajveer 11314 
  def validate(self):
11315 
    return
11316 
 
11317 
 
94 ashish 11318 
  def __repr__(self):
11319 
    L = ['%s=%r' % (key, value)
11320 
      for key, value in self.__dict__.iteritems()]
11321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11322 
 
11323 
  def __eq__(self, other):
11324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11325 
 
11326 
  def __ne__(self, other):
11327 
    return not (self == other)
11328 
 
559 chandransh 11329 
class getCart_args:
504 rajveer 11330 
  """
11331 
  Attributes:
559 chandransh 11332 
   - cartId
504 rajveer 11333 
  """
11334 
 
11335 
  thrift_spec = (
11336 
    None, # 0
559 chandransh 11337 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 11338 
  )
11339 
 
559 chandransh 11340 
  def __init__(self, cartId=None,):
11341 
    self.cartId = cartId
504 rajveer 11342 
 
11343 
  def read(self, iprot):
11344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11346 
      return
11347 
    iprot.readStructBegin()
11348 
    while True:
11349 
      (fname, ftype, fid) = iprot.readFieldBegin()
11350 
      if ftype == TType.STOP:
11351 
        break
11352 
      if fid == 1:
11353 
        if ftype == TType.I64:
559 chandransh 11354 
          self.cartId = iprot.readI64();
504 rajveer 11355 
        else:
11356 
          iprot.skip(ftype)
11357 
      else:
11358 
        iprot.skip(ftype)
11359 
      iprot.readFieldEnd()
11360 
    iprot.readStructEnd()
11361 
 
11362 
  def write(self, oprot):
11363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11365 
      return
559 chandransh 11366 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 11367 
    if self.cartId is not None:
559 chandransh 11368 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11369 
      oprot.writeI64(self.cartId)
504 rajveer 11370 
      oprot.writeFieldEnd()
11371 
    oprot.writeFieldStop()
11372 
    oprot.writeStructEnd()
11373 
 
3431 rajveer 11374 
  def validate(self):
11375 
    return
11376 
 
11377 
 
504 rajveer 11378 
  def __repr__(self):
11379 
    L = ['%s=%r' % (key, value)
11380 
      for key, value in self.__dict__.iteritems()]
11381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11382 
 
11383 
  def __eq__(self, other):
11384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11385 
 
11386 
  def __ne__(self, other):
11387 
    return not (self == other)
11388 
 
559 chandransh 11389 
class getCart_result:
504 rajveer 11390 
  """
11391 
  Attributes:
11392 
   - success
559 chandransh 11393 
   - scx
504 rajveer 11394 
  """
11395 
 
11396 
  thrift_spec = (
559 chandransh 11397 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11398 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 11399 
  )
11400 
 
559 chandransh 11401 
  def __init__(self, success=None, scx=None,):
504 rajveer 11402 
    self.success = success
559 chandransh 11403 
    self.scx = scx
504 rajveer 11404 
 
11405 
  def read(self, iprot):
11406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11408 
      return
11409 
    iprot.readStructBegin()
11410 
    while True:
11411 
      (fname, ftype, fid) = iprot.readFieldBegin()
11412 
      if ftype == TType.STOP:
11413 
        break
11414 
      if fid == 0:
559 chandransh 11415 
        if ftype == TType.STRUCT:
11416 
          self.success = Cart()
11417 
          self.success.read(iprot)
504 rajveer 11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      elif fid == 1:
11421 
        if ftype == TType.STRUCT:
559 chandransh 11422 
          self.scx = ShoppingCartException()
11423 
          self.scx.read(iprot)
504 rajveer 11424 
        else:
11425 
          iprot.skip(ftype)
11426 
      else:
11427 
        iprot.skip(ftype)
11428 
      iprot.readFieldEnd()
11429 
    iprot.readStructEnd()
11430 
 
11431 
  def write(self, oprot):
11432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11434 
      return
559 chandransh 11435 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 11436 
    if self.success is not None:
559 chandransh 11437 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11438 
      self.success.write(oprot)
504 rajveer 11439 
      oprot.writeFieldEnd()
3431 rajveer 11440 
    if self.scx is not None:
559 chandransh 11441 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11442 
      self.scx.write(oprot)
504 rajveer 11443 
      oprot.writeFieldEnd()
11444 
    oprot.writeFieldStop()
11445 
    oprot.writeStructEnd()
11446 
 
3431 rajveer 11447 
  def validate(self):
11448 
    return
11449 
 
11450 
 
504 rajveer 11451 
  def __repr__(self):
11452 
    L = ['%s=%r' % (key, value)
11453 
      for key, value in self.__dict__.iteritems()]
11454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11455 
 
11456 
  def __eq__(self, other):
11457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11458 
 
11459 
  def __ne__(self, other):
11460 
    return not (self == other)
11461 
 
559 chandransh 11462 
class getCartsByTime_args:
11463 
  """
11464 
  Attributes:
11465 
   - from_time
11466 
   - to_time
11467 
   - status
11468 
  """
11469 
 
11470 
  thrift_spec = (
11471 
    None, # 0
11472 
    (1, TType.I64, 'from_time', None, None, ), # 1
11473 
    (2, TType.I64, 'to_time', None, None, ), # 2
11474 
    (3, TType.I32, 'status', None, None, ), # 3
11475 
  )
11476 
 
11477 
  def __init__(self, from_time=None, to_time=None, status=None,):
11478 
    self.from_time = from_time
11479 
    self.to_time = to_time
11480 
    self.status = status
11481 
 
11482 
  def read(self, iprot):
11483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11485 
      return
11486 
    iprot.readStructBegin()
11487 
    while True:
11488 
      (fname, ftype, fid) = iprot.readFieldBegin()
11489 
      if ftype == TType.STOP:
11490 
        break
11491 
      if fid == 1:
94 ashish 11492 
        if ftype == TType.I64:
559 chandransh 11493 
          self.from_time = iprot.readI64();
94 ashish 11494 
        else:
11495 
          iprot.skip(ftype)
122 ashish 11496 
      elif fid == 2:
559 chandransh 11497 
        if ftype == TType.I64:
11498 
          self.to_time = iprot.readI64();
122 ashish 11499 
        else:
11500 
          iprot.skip(ftype)
559 chandransh 11501 
      elif fid == 3:
11502 
        if ftype == TType.I32:
11503 
          self.status = iprot.readI32();
11504 
        else:
11505 
          iprot.skip(ftype)
94 ashish 11506 
      else:
11507 
        iprot.skip(ftype)
11508 
      iprot.readFieldEnd()
11509 
    iprot.readStructEnd()
11510 
 
11511 
  def write(self, oprot):
11512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11514 
      return
559 chandransh 11515 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11516 
    if self.from_time is not None:
559 chandransh 11517 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11518 
      oprot.writeI64(self.from_time)
94 ashish 11519 
      oprot.writeFieldEnd()
3431 rajveer 11520 
    if self.to_time is not None:
559 chandransh 11521 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11522 
      oprot.writeI64(self.to_time)
122 ashish 11523 
      oprot.writeFieldEnd()
3431 rajveer 11524 
    if self.status is not None:
559 chandransh 11525 
      oprot.writeFieldBegin('status', TType.I32, 3)
11526 
      oprot.writeI32(self.status)
11527 
      oprot.writeFieldEnd()
94 ashish 11528 
    oprot.writeFieldStop()
11529 
    oprot.writeStructEnd()
11530 
 
3431 rajveer 11531 
  def validate(self):
11532 
    return
11533 
 
11534 
 
94 ashish 11535 
  def __repr__(self):
11536 
    L = ['%s=%r' % (key, value)
11537 
      for key, value in self.__dict__.iteritems()]
11538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11539 
 
11540 
  def __eq__(self, other):
11541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11542 
 
11543 
  def __ne__(self, other):
11544 
    return not (self == other)
11545 
 
559 chandransh 11546 
class getCartsByTime_result:
94 ashish 11547 
  """
11548 
  Attributes:
11549 
   - success
559 chandransh 11550 
   - scx
94 ashish 11551 
  """
11552 
 
11553 
  thrift_spec = (
559 chandransh 11554 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11555 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11556 
  )
11557 
 
559 chandransh 11558 
  def __init__(self, success=None, scx=None,):
94 ashish 11559 
    self.success = success
559 chandransh 11560 
    self.scx = scx
94 ashish 11561 
 
11562 
  def read(self, iprot):
11563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11565 
      return
11566 
    iprot.readStructBegin()
11567 
    while True:
11568 
      (fname, ftype, fid) = iprot.readFieldBegin()
11569 
      if ftype == TType.STOP:
11570 
        break
11571 
      if fid == 0:
559 chandransh 11572 
        if ftype == TType.LIST:
11573 
          self.success = []
11592 amit.gupta 11574 
          (_etype156, _size153) = iprot.readListBegin()
11575 
          for _i157 in xrange(_size153):
11576 
            _elem158 = Cart()
11577 
            _elem158.read(iprot)
11578 
            self.success.append(_elem158)
559 chandransh 11579 
          iprot.readListEnd()
94 ashish 11580 
        else:
11581 
          iprot.skip(ftype)
11582 
      elif fid == 1:
11583 
        if ftype == TType.STRUCT:
559 chandransh 11584 
          self.scx = ShoppingCartException()
11585 
          self.scx.read(iprot)
94 ashish 11586 
        else:
11587 
          iprot.skip(ftype)
11588 
      else:
11589 
        iprot.skip(ftype)
11590 
      iprot.readFieldEnd()
11591 
    iprot.readStructEnd()
11592 
 
11593 
  def write(self, oprot):
11594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11596 
      return
559 chandransh 11597 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11598 
    if self.success is not None:
559 chandransh 11599 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11600 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11601 
      for iter159 in self.success:
11602 
        iter159.write(oprot)
559 chandransh 11603 
      oprot.writeListEnd()
94 ashish 11604 
      oprot.writeFieldEnd()
3431 rajveer 11605 
    if self.scx is not None:
559 chandransh 11606 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11607 
      self.scx.write(oprot)
94 ashish 11608 
      oprot.writeFieldEnd()
11609 
    oprot.writeFieldStop()
11610 
    oprot.writeStructEnd()
11611 
 
3431 rajveer 11612 
  def validate(self):
11613 
    return
11614 
 
11615 
 
94 ashish 11616 
  def __repr__(self):
11617 
    L = ['%s=%r' % (key, value)
11618 
      for key, value in self.__dict__.iteritems()]
11619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11620 
 
11621 
  def __eq__(self, other):
11622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11623 
 
11624 
  def __ne__(self, other):
11625 
    return not (self == other)
11626 
 
559 chandransh 11627 
class addItemToCart_args:
11628 
  """
11629 
  Attributes:
11630 
   - cartId
11631 
   - itemId
11632 
   - quantity
3557 rajveer 11633 
   - sourceId
559 chandransh 11634 
  """
11635 
 
11636 
  thrift_spec = (
11637 
    None, # 0
11638 
    (1, TType.I64, 'cartId', None, None, ), # 1
11639 
    (2, TType.I64, 'itemId', None, None, ), # 2
11640 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11641 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11642 
  )
11643 
 
3557 rajveer 11644 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11645 
    self.cartId = cartId
11646 
    self.itemId = itemId
11647 
    self.quantity = quantity
3557 rajveer 11648 
    self.sourceId = sourceId
559 chandransh 11649 
 
11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
11659 
      if fid == 1:
11660 
        if ftype == TType.I64:
11661 
          self.cartId = iprot.readI64();
11662 
        else:
11663 
          iprot.skip(ftype)
11664 
      elif fid == 2:
11665 
        if ftype == TType.I64:
11666 
          self.itemId = iprot.readI64();
11667 
        else:
11668 
          iprot.skip(ftype)
11669 
      elif fid == 3:
11670 
        if ftype == TType.I64:
11671 
          self.quantity = iprot.readI64();
11672 
        else:
11673 
          iprot.skip(ftype)
3557 rajveer 11674 
      elif fid == 4:
11675 
        if ftype == TType.I64:
11676 
          self.sourceId = iprot.readI64();
11677 
        else:
11678 
          iprot.skip(ftype)
559 chandransh 11679 
      else:
11680 
        iprot.skip(ftype)
11681 
      iprot.readFieldEnd()
11682 
    iprot.readStructEnd()
11683 
 
11684 
  def write(self, oprot):
11685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11687 
      return
11688 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11689 
    if self.cartId is not None:
559 chandransh 11690 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11691 
      oprot.writeI64(self.cartId)
11692 
      oprot.writeFieldEnd()
3431 rajveer 11693 
    if self.itemId is not None:
559 chandransh 11694 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11695 
      oprot.writeI64(self.itemId)
11696 
      oprot.writeFieldEnd()
3431 rajveer 11697 
    if self.quantity is not None:
559 chandransh 11698 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11699 
      oprot.writeI64(self.quantity)
11700 
      oprot.writeFieldEnd()
3557 rajveer 11701 
    if self.sourceId is not None:
11702 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11703 
      oprot.writeI64(self.sourceId)
11704 
      oprot.writeFieldEnd()
559 chandransh 11705 
    oprot.writeFieldStop()
11706 
    oprot.writeStructEnd()
11707 
 
3431 rajveer 11708 
  def validate(self):
11709 
    return
11710 
 
11711 
 
559 chandransh 11712 
  def __repr__(self):
11713 
    L = ['%s=%r' % (key, value)
11714 
      for key, value in self.__dict__.iteritems()]
11715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11716 
 
11717 
  def __eq__(self, other):
11718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11719 
 
11720 
  def __ne__(self, other):
11721 
    return not (self == other)
11722 
 
11723 
class addItemToCart_result:
11724 
  """
11725 
  Attributes:
2035 rajveer 11726 
   - success
559 chandransh 11727 
   - scx
11728 
  """
11729 
 
11730 
  thrift_spec = (
2035 rajveer 11731 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11732 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11733 
  )
11734 
 
2035 rajveer 11735 
  def __init__(self, success=None, scx=None,):
11736 
    self.success = success
559 chandransh 11737 
    self.scx = scx
11738 
 
11739 
  def read(self, iprot):
11740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11742 
      return
11743 
    iprot.readStructBegin()
11744 
    while True:
11745 
      (fname, ftype, fid) = iprot.readFieldBegin()
11746 
      if ftype == TType.STOP:
11747 
        break
2035 rajveer 11748 
      if fid == 0:
11749 
        if ftype == TType.STRING:
11750 
          self.success = iprot.readString();
11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      elif fid == 1:
559 chandransh 11754 
        if ftype == TType.STRUCT:
11755 
          self.scx = ShoppingCartException()
11756 
          self.scx.read(iprot)
11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      else:
11760 
        iprot.skip(ftype)
11761 
      iprot.readFieldEnd()
11762 
    iprot.readStructEnd()
11763 
 
11764 
  def write(self, oprot):
11765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11767 
      return
11768 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11769 
    if self.success is not None:
2035 rajveer 11770 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11771 
      oprot.writeString(self.success)
11772 
      oprot.writeFieldEnd()
3431 rajveer 11773 
    if self.scx is not None:
559 chandransh 11774 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11775 
      self.scx.write(oprot)
11776 
      oprot.writeFieldEnd()
11777 
    oprot.writeFieldStop()
11778 
    oprot.writeStructEnd()
11779 
 
3431 rajveer 11780 
  def validate(self):
11781 
    return
11782 
 
11783 
 
559 chandransh 11784 
  def __repr__(self):
11785 
    L = ['%s=%r' % (key, value)
11786 
      for key, value in self.__dict__.iteritems()]
11787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11788 
 
11789 
  def __eq__(self, other):
11790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11791 
 
11792 
  def __ne__(self, other):
11793 
    return not (self == other)
11794 
 
11795 
class deleteItemFromCart_args:
11796 
  """
11797 
  Attributes:
11798 
   - cartId
11799 
   - itemId
11800 
  """
11801 
 
11802 
  thrift_spec = (
11803 
    None, # 0
11804 
    (1, TType.I64, 'cartId', None, None, ), # 1
11805 
    (2, TType.I64, 'itemId', None, None, ), # 2
11806 
  )
11807 
 
11808 
  def __init__(self, cartId=None, itemId=None,):
11809 
    self.cartId = cartId
11810 
    self.itemId = itemId
11811 
 
11812 
  def read(self, iprot):
11813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11815 
      return
11816 
    iprot.readStructBegin()
11817 
    while True:
11818 
      (fname, ftype, fid) = iprot.readFieldBegin()
11819 
      if ftype == TType.STOP:
11820 
        break
11821 
      if fid == 1:
11822 
        if ftype == TType.I64:
11823 
          self.cartId = iprot.readI64();
11824 
        else:
11825 
          iprot.skip(ftype)
11826 
      elif fid == 2:
11827 
        if ftype == TType.I64:
11828 
          self.itemId = iprot.readI64();
11829 
        else:
11830 
          iprot.skip(ftype)
11831 
      else:
11832 
        iprot.skip(ftype)
11833 
      iprot.readFieldEnd()
11834 
    iprot.readStructEnd()
11835 
 
11836 
  def write(self, oprot):
11837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11839 
      return
11840 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11841 
    if self.cartId is not None:
559 chandransh 11842 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11843 
      oprot.writeI64(self.cartId)
11844 
      oprot.writeFieldEnd()
3431 rajveer 11845 
    if self.itemId is not None:
559 chandransh 11846 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11847 
      oprot.writeI64(self.itemId)
11848 
      oprot.writeFieldEnd()
11849 
    oprot.writeFieldStop()
11850 
    oprot.writeStructEnd()
11851 
 
3431 rajveer 11852 
  def validate(self):
11853 
    return
11854 
 
11855 
 
559 chandransh 11856 
  def __repr__(self):
11857 
    L = ['%s=%r' % (key, value)
11858 
      for key, value in self.__dict__.iteritems()]
11859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11860 
 
11861 
  def __eq__(self, other):
11862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11863 
 
11864 
  def __ne__(self, other):
11865 
    return not (self == other)
11866 
 
11867 
class deleteItemFromCart_result:
11868 
  """
11869 
  Attributes:
11870 
   - scx
11871 
  """
11872 
 
11873 
  thrift_spec = (
11874 
    None, # 0
11875 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11876 
  )
11877 
 
11878 
  def __init__(self, scx=None,):
11879 
    self.scx = scx
11880 
 
11881 
  def read(self, iprot):
11882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11884 
      return
11885 
    iprot.readStructBegin()
11886 
    while True:
11887 
      (fname, ftype, fid) = iprot.readFieldBegin()
11888 
      if ftype == TType.STOP:
11889 
        break
11890 
      if fid == 1:
11891 
        if ftype == TType.STRUCT:
11892 
          self.scx = ShoppingCartException()
11893 
          self.scx.read(iprot)
11894 
        else:
11895 
          iprot.skip(ftype)
11896 
      else:
11897 
        iprot.skip(ftype)
11898 
      iprot.readFieldEnd()
11899 
    iprot.readStructEnd()
11900 
 
11901 
  def write(self, oprot):
11902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11904 
      return
11905 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11906 
    if self.scx is not None:
559 chandransh 11907 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11908 
      self.scx.write(oprot)
11909 
      oprot.writeFieldEnd()
11910 
    oprot.writeFieldStop()
11911 
    oprot.writeStructEnd()
11912 
 
3431 rajveer 11913 
  def validate(self):
11914 
    return
11915 
 
11916 
 
559 chandransh 11917 
  def __repr__(self):
11918 
    L = ['%s=%r' % (key, value)
11919 
      for key, value in self.__dict__.iteritems()]
11920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11921 
 
11922 
  def __eq__(self, other):
11923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11924 
 
11925 
  def __ne__(self, other):
11926 
    return not (self == other)
11927 
 
11928 
class addAddressToCart_args:
11929 
  """
11930 
  Attributes:
11931 
   - cartId
11932 
   - addressId
11933 
  """
11934 
 
11935 
  thrift_spec = (
11936 
    None, # 0
11937 
    (1, TType.I64, 'cartId', None, None, ), # 1
11938 
    (2, TType.I64, 'addressId', None, None, ), # 2
11939 
  )
11940 
 
11941 
  def __init__(self, cartId=None, addressId=None,):
11942 
    self.cartId = cartId
11943 
    self.addressId = addressId
11944 
 
11945 
  def read(self, iprot):
11946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11948 
      return
11949 
    iprot.readStructBegin()
11950 
    while True:
11951 
      (fname, ftype, fid) = iprot.readFieldBegin()
11952 
      if ftype == TType.STOP:
11953 
        break
11954 
      if fid == 1:
11955 
        if ftype == TType.I64:
11956 
          self.cartId = iprot.readI64();
11957 
        else:
11958 
          iprot.skip(ftype)
11959 
      elif fid == 2:
11960 
        if ftype == TType.I64:
11961 
          self.addressId = iprot.readI64();
11962 
        else:
11963 
          iprot.skip(ftype)
11964 
      else:
11965 
        iprot.skip(ftype)
11966 
      iprot.readFieldEnd()
11967 
    iprot.readStructEnd()
11968 
 
11969 
  def write(self, oprot):
11970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11972 
      return
11973 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11974 
    if self.cartId is not None:
559 chandransh 11975 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11976 
      oprot.writeI64(self.cartId)
11977 
      oprot.writeFieldEnd()
3431 rajveer 11978 
    if self.addressId is not None:
559 chandransh 11979 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11980 
      oprot.writeI64(self.addressId)
11981 
      oprot.writeFieldEnd()
11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
3431 rajveer 11985 
  def validate(self):
11986 
    return
11987 
 
11988 
 
559 chandransh 11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
12000 
class addAddressToCart_result:
575 chandransh 12001 
  """
12002 
  Attributes:
12003 
   - scx
12004 
  """
559 chandransh 12005 
 
12006 
  thrift_spec = (
575 chandransh 12007 
    None, # 0
12008 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12009 
  )
12010 
 
575 chandransh 12011 
  def __init__(self, scx=None,):
12012 
    self.scx = scx
12013 
 
559 chandransh 12014 
  def read(self, iprot):
12015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12017 
      return
12018 
    iprot.readStructBegin()
12019 
    while True:
12020 
      (fname, ftype, fid) = iprot.readFieldBegin()
12021 
      if ftype == TType.STOP:
12022 
        break
575 chandransh 12023 
      if fid == 1:
12024 
        if ftype == TType.STRUCT:
12025 
          self.scx = ShoppingCartException()
12026 
          self.scx.read(iprot)
12027 
        else:
12028 
          iprot.skip(ftype)
559 chandransh 12029 
      else:
12030 
        iprot.skip(ftype)
12031 
      iprot.readFieldEnd()
12032 
    iprot.readStructEnd()
12033 
 
12034 
  def write(self, oprot):
12035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12037 
      return
12038 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 12039 
    if self.scx is not None:
575 chandransh 12040 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12041 
      self.scx.write(oprot)
12042 
      oprot.writeFieldEnd()
559 chandransh 12043 
    oprot.writeFieldStop()
12044 
    oprot.writeStructEnd()
12045 
 
3431 rajveer 12046 
  def validate(self):
12047 
    return
12048 
 
12049 
 
559 chandransh 12050 
  def __repr__(self):
12051 
    L = ['%s=%r' % (key, value)
12052 
      for key, value in self.__dict__.iteritems()]
12053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12054 
 
12055 
  def __eq__(self, other):
12056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12057 
 
12058 
  def __ne__(self, other):
12059 
    return not (self == other)
12060 
 
5553 rajveer 12061 
class addStoreToCart_args:
12062 
  """
12063 
  Attributes:
12064 
   - cartId
12065 
   - storeId
12066 
  """
12067 
 
12068 
  thrift_spec = (
12069 
    None, # 0
12070 
    (1, TType.I64, 'cartId', None, None, ), # 1
12071 
    (2, TType.I64, 'storeId', None, None, ), # 2
12072 
  )
12073 
 
12074 
  def __init__(self, cartId=None, storeId=None,):
12075 
    self.cartId = cartId
12076 
    self.storeId = storeId
12077 
 
12078 
  def read(self, iprot):
12079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12081 
      return
12082 
    iprot.readStructBegin()
12083 
    while True:
12084 
      (fname, ftype, fid) = iprot.readFieldBegin()
12085 
      if ftype == TType.STOP:
12086 
        break
12087 
      if fid == 1:
12088 
        if ftype == TType.I64:
12089 
          self.cartId = iprot.readI64();
12090 
        else:
12091 
          iprot.skip(ftype)
12092 
      elif fid == 2:
12093 
        if ftype == TType.I64:
12094 
          self.storeId = iprot.readI64();
12095 
        else:
12096 
          iprot.skip(ftype)
12097 
      else:
12098 
        iprot.skip(ftype)
12099 
      iprot.readFieldEnd()
12100 
    iprot.readStructEnd()
12101 
 
12102 
  def write(self, oprot):
12103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12105 
      return
12106 
    oprot.writeStructBegin('addStoreToCart_args')
12107 
    if self.cartId is not None:
12108 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12109 
      oprot.writeI64(self.cartId)
12110 
      oprot.writeFieldEnd()
12111 
    if self.storeId is not None:
12112 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
12113 
      oprot.writeI64(self.storeId)
12114 
      oprot.writeFieldEnd()
12115 
    oprot.writeFieldStop()
12116 
    oprot.writeStructEnd()
12117 
 
12118 
  def validate(self):
12119 
    return
12120 
 
12121 
 
12122 
  def __repr__(self):
12123 
    L = ['%s=%r' % (key, value)
12124 
      for key, value in self.__dict__.iteritems()]
12125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12126 
 
12127 
  def __eq__(self, other):
12128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12129 
 
12130 
  def __ne__(self, other):
12131 
    return not (self == other)
12132 
 
12133 
class addStoreToCart_result:
12134 
  """
12135 
  Attributes:
12136 
   - scx
12137 
  """
12138 
 
12139 
  thrift_spec = (
12140 
    None, # 0
12141 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12142 
  )
12143 
 
12144 
  def __init__(self, scx=None,):
12145 
    self.scx = scx
12146 
 
12147 
  def read(self, iprot):
12148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12150 
      return
12151 
    iprot.readStructBegin()
12152 
    while True:
12153 
      (fname, ftype, fid) = iprot.readFieldBegin()
12154 
      if ftype == TType.STOP:
12155 
        break
12156 
      if fid == 1:
12157 
        if ftype == TType.STRUCT:
12158 
          self.scx = ShoppingCartException()
12159 
          self.scx.read(iprot)
12160 
        else:
12161 
          iprot.skip(ftype)
12162 
      else:
12163 
        iprot.skip(ftype)
12164 
      iprot.readFieldEnd()
12165 
    iprot.readStructEnd()
12166 
 
12167 
  def write(self, oprot):
12168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12170 
      return
12171 
    oprot.writeStructBegin('addStoreToCart_result')
12172 
    if self.scx is not None:
12173 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12174 
      self.scx.write(oprot)
12175 
      oprot.writeFieldEnd()
12176 
    oprot.writeFieldStop()
12177 
    oprot.writeStructEnd()
12178 
 
12179 
  def validate(self):
12180 
    return
12181 
 
12182 
 
12183 
  def __repr__(self):
12184 
    L = ['%s=%r' % (key, value)
12185 
      for key, value in self.__dict__.iteritems()]
12186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12187 
 
12188 
  def __eq__(self, other):
12189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12190 
 
12191 
  def __ne__(self, other):
12192 
    return not (self == other)
12193 
 
1976 varun.gupt 12194 
class applyCouponToCart_args:
12195 
  """
12196 
  Attributes:
6922 anupam.sin 12197 
   - cart
1976 varun.gupt 12198 
   - couponCode
12199 
  """
12200 
 
12201 
  thrift_spec = (
12202 
    None, # 0
6922 anupam.sin 12203 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 12204 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
12205 
  )
12206 
 
6922 anupam.sin 12207 
  def __init__(self, cart=None, couponCode=None,):
12208 
    self.cart = cart
1976 varun.gupt 12209 
    self.couponCode = couponCode
12210 
 
12211 
  def read(self, iprot):
12212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12214 
      return
12215 
    iprot.readStructBegin()
12216 
    while True:
12217 
      (fname, ftype, fid) = iprot.readFieldBegin()
12218 
      if ftype == TType.STOP:
12219 
        break
12220 
      if fid == 1:
6922 anupam.sin 12221 
        if ftype == TType.STRUCT:
12222 
          self.cart = Cart()
12223 
          self.cart.read(iprot)
1976 varun.gupt 12224 
        else:
12225 
          iprot.skip(ftype)
12226 
      elif fid == 2:
12227 
        if ftype == TType.STRING:
12228 
          self.couponCode = iprot.readString();
12229 
        else:
12230 
          iprot.skip(ftype)
12231 
      else:
12232 
        iprot.skip(ftype)
12233 
      iprot.readFieldEnd()
12234 
    iprot.readStructEnd()
12235 
 
12236 
  def write(self, oprot):
12237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12239 
      return
12240 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 12241 
    if self.cart is not None:
12242 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
12243 
      self.cart.write(oprot)
1976 varun.gupt 12244 
      oprot.writeFieldEnd()
3431 rajveer 12245 
    if self.couponCode is not None:
1976 varun.gupt 12246 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
12247 
      oprot.writeString(self.couponCode)
12248 
      oprot.writeFieldEnd()
12249 
    oprot.writeFieldStop()
12250 
    oprot.writeStructEnd()
12251 
 
3431 rajveer 12252 
  def validate(self):
12253 
    return
12254 
 
12255 
 
1976 varun.gupt 12256 
  def __repr__(self):
12257 
    L = ['%s=%r' % (key, value)
12258 
      for key, value in self.__dict__.iteritems()]
12259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12260 
 
12261 
  def __eq__(self, other):
12262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12263 
 
12264 
  def __ne__(self, other):
12265 
    return not (self == other)
12266 
 
12267 
class applyCouponToCart_result:
12268 
  """
12269 
  Attributes:
12270 
   - scx
12271 
  """
12272 
 
12273 
  thrift_spec = (
12274 
    None, # 0
12275 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12276 
  )
12277 
 
12278 
  def __init__(self, scx=None,):
12279 
    self.scx = scx
12280 
 
12281 
  def read(self, iprot):
12282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12284 
      return
12285 
    iprot.readStructBegin()
12286 
    while True:
12287 
      (fname, ftype, fid) = iprot.readFieldBegin()
12288 
      if ftype == TType.STOP:
12289 
        break
12290 
      if fid == 1:
12291 
        if ftype == TType.STRUCT:
12292 
          self.scx = ShoppingCartException()
12293 
          self.scx.read(iprot)
12294 
        else:
12295 
          iprot.skip(ftype)
12296 
      else:
12297 
        iprot.skip(ftype)
12298 
      iprot.readFieldEnd()
12299 
    iprot.readStructEnd()
12300 
 
12301 
  def write(self, oprot):
12302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12304 
      return
12305 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 12306 
    if self.scx is not None:
1976 varun.gupt 12307 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12308 
      self.scx.write(oprot)
12309 
      oprot.writeFieldEnd()
12310 
    oprot.writeFieldStop()
12311 
    oprot.writeStructEnd()
12312 
 
3431 rajveer 12313 
  def validate(self):
12314 
    return
12315 
 
12316 
 
1976 varun.gupt 12317 
  def __repr__(self):
12318 
    L = ['%s=%r' % (key, value)
12319 
      for key, value in self.__dict__.iteritems()]
12320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12321 
 
12322 
  def __eq__(self, other):
12323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12324 
 
12325 
  def __ne__(self, other):
12326 
    return not (self == other)
12327 
 
12328 
class removeCoupon_args:
12329 
  """
12330 
  Attributes:
12331 
   - cartId
12332 
  """
12333 
 
12334 
  thrift_spec = (
12335 
    None, # 0
12336 
    (1, TType.I64, 'cartId', None, None, ), # 1
12337 
  )
12338 
 
12339 
  def __init__(self, cartId=None,):
12340 
    self.cartId = cartId
12341 
 
12342 
  def read(self, iprot):
12343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12345 
      return
12346 
    iprot.readStructBegin()
12347 
    while True:
12348 
      (fname, ftype, fid) = iprot.readFieldBegin()
12349 
      if ftype == TType.STOP:
12350 
        break
12351 
      if fid == 1:
12352 
        if ftype == TType.I64:
12353 
          self.cartId = iprot.readI64();
12354 
        else:
12355 
          iprot.skip(ftype)
12356 
      else:
12357 
        iprot.skip(ftype)
12358 
      iprot.readFieldEnd()
12359 
    iprot.readStructEnd()
12360 
 
12361 
  def write(self, oprot):
12362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12364 
      return
12365 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 12366 
    if self.cartId is not None:
1976 varun.gupt 12367 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12368 
      oprot.writeI64(self.cartId)
12369 
      oprot.writeFieldEnd()
12370 
    oprot.writeFieldStop()
12371 
    oprot.writeStructEnd()
12372 
 
3431 rajveer 12373 
  def validate(self):
12374 
    return
12375 
 
12376 
 
1976 varun.gupt 12377 
  def __repr__(self):
12378 
    L = ['%s=%r' % (key, value)
12379 
      for key, value in self.__dict__.iteritems()]
12380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12381 
 
12382 
  def __eq__(self, other):
12383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12384 
 
12385 
  def __ne__(self, other):
12386 
    return not (self == other)
12387 
 
12388 
class removeCoupon_result:
12389 
  """
12390 
  Attributes:
12391 
   - scx
12392 
  """
12393 
 
12394 
  thrift_spec = (
12395 
    None, # 0
12396 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12397 
  )
12398 
 
12399 
  def __init__(self, scx=None,):
12400 
    self.scx = scx
12401 
 
12402 
  def read(self, iprot):
12403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12405 
      return
12406 
    iprot.readStructBegin()
12407 
    while True:
12408 
      (fname, ftype, fid) = iprot.readFieldBegin()
12409 
      if ftype == TType.STOP:
12410 
        break
12411 
      if fid == 1:
12412 
        if ftype == TType.STRUCT:
12413 
          self.scx = ShoppingCartException()
12414 
          self.scx.read(iprot)
12415 
        else:
12416 
          iprot.skip(ftype)
12417 
      else:
12418 
        iprot.skip(ftype)
12419 
      iprot.readFieldEnd()
12420 
    iprot.readStructEnd()
12421 
 
12422 
  def write(self, oprot):
12423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12425 
      return
12426 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 12427 
    if self.scx is not None:
1976 varun.gupt 12428 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12429 
      self.scx.write(oprot)
12430 
      oprot.writeFieldEnd()
12431 
    oprot.writeFieldStop()
12432 
    oprot.writeStructEnd()
12433 
 
3431 rajveer 12434 
  def validate(self):
12435 
    return
12436 
 
12437 
 
1976 varun.gupt 12438 
  def __repr__(self):
12439 
    L = ['%s=%r' % (key, value)
12440 
      for key, value in self.__dict__.iteritems()]
12441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12442 
 
12443 
  def __eq__(self, other):
12444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12445 
 
12446 
  def __ne__(self, other):
12447 
    return not (self == other)
12448 
 
3554 varun.gupt 12449 
class deleteDiscountsFromCart_args:
12450 
  """
12451 
  Attributes:
12452 
   - cartId
12453 
  """
12454 
 
12455 
  thrift_spec = (
12456 
    None, # 0
12457 
    (1, TType.I64, 'cartId', None, None, ), # 1
12458 
  )
12459 
 
12460 
  def __init__(self, cartId=None,):
12461 
    self.cartId = cartId
12462 
 
12463 
  def read(self, iprot):
12464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12466 
      return
12467 
    iprot.readStructBegin()
12468 
    while True:
12469 
      (fname, ftype, fid) = iprot.readFieldBegin()
12470 
      if ftype == TType.STOP:
12471 
        break
12472 
      if fid == 1:
12473 
        if ftype == TType.I64:
12474 
          self.cartId = iprot.readI64();
12475 
        else:
12476 
          iprot.skip(ftype)
12477 
      else:
12478 
        iprot.skip(ftype)
12479 
      iprot.readFieldEnd()
12480 
    iprot.readStructEnd()
12481 
 
12482 
  def write(self, oprot):
12483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12485 
      return
12486 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12487 
    if self.cartId is not None:
12488 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12489 
      oprot.writeI64(self.cartId)
12490 
      oprot.writeFieldEnd()
12491 
    oprot.writeFieldStop()
12492 
    oprot.writeStructEnd()
12493 
 
12494 
  def validate(self):
12495 
    return
12496 
 
12497 
 
12498 
  def __repr__(self):
12499 
    L = ['%s=%r' % (key, value)
12500 
      for key, value in self.__dict__.iteritems()]
12501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12502 
 
12503 
  def __eq__(self, other):
12504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12505 
 
12506 
  def __ne__(self, other):
12507 
    return not (self == other)
12508 
 
12509 
class deleteDiscountsFromCart_result:
12510 
  """
12511 
  Attributes:
12512 
   - scx
12513 
  """
12514 
 
12515 
  thrift_spec = (
12516 
    None, # 0
12517 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12518 
  )
12519 
 
12520 
  def __init__(self, scx=None,):
12521 
    self.scx = scx
12522 
 
12523 
  def read(self, iprot):
12524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12526 
      return
12527 
    iprot.readStructBegin()
12528 
    while True:
12529 
      (fname, ftype, fid) = iprot.readFieldBegin()
12530 
      if ftype == TType.STOP:
12531 
        break
12532 
      if fid == 1:
12533 
        if ftype == TType.STRUCT:
12534 
          self.scx = ShoppingCartException()
12535 
          self.scx.read(iprot)
12536 
        else:
12537 
          iprot.skip(ftype)
12538 
      else:
12539 
        iprot.skip(ftype)
12540 
      iprot.readFieldEnd()
12541 
    iprot.readStructEnd()
12542 
 
12543 
  def write(self, oprot):
12544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12546 
      return
12547 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12548 
    if self.scx is not None:
12549 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12550 
      self.scx.write(oprot)
12551 
      oprot.writeFieldEnd()
12552 
    oprot.writeFieldStop()
12553 
    oprot.writeStructEnd()
12554 
 
12555 
  def validate(self):
12556 
    return
12557 
 
12558 
 
12559 
  def __repr__(self):
12560 
    L = ['%s=%r' % (key, value)
12561 
      for key, value in self.__dict__.iteritems()]
12562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12563 
 
12564 
  def __eq__(self, other):
12565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12566 
 
12567 
  def __ne__(self, other):
12568 
    return not (self == other)
12569 
 
12570 
class saveDiscounts_args:
12571 
  """
12572 
  Attributes:
12573 
   - discounts
12574 
  """
12575 
 
12576 
  thrift_spec = (
12577 
    None, # 0
12578 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12579 
  )
12580 
 
12581 
  def __init__(self, discounts=None,):
12582 
    self.discounts = discounts
12583 
 
12584 
  def read(self, iprot):
12585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12587 
      return
12588 
    iprot.readStructBegin()
12589 
    while True:
12590 
      (fname, ftype, fid) = iprot.readFieldBegin()
12591 
      if ftype == TType.STOP:
12592 
        break
12593 
      if fid == 1:
12594 
        if ftype == TType.LIST:
12595 
          self.discounts = []
11592 amit.gupta 12596 
          (_etype163, _size160) = iprot.readListBegin()
12597 
          for _i164 in xrange(_size160):
12598 
            _elem165 = Discount()
12599 
            _elem165.read(iprot)
12600 
            self.discounts.append(_elem165)
3554 varun.gupt 12601 
          iprot.readListEnd()
12602 
        else:
12603 
          iprot.skip(ftype)
12604 
      else:
12605 
        iprot.skip(ftype)
12606 
      iprot.readFieldEnd()
12607 
    iprot.readStructEnd()
12608 
 
12609 
  def write(self, oprot):
12610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12612 
      return
12613 
    oprot.writeStructBegin('saveDiscounts_args')
12614 
    if self.discounts is not None:
12615 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12616 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12617 
      for iter166 in self.discounts:
12618 
        iter166.write(oprot)
3554 varun.gupt 12619 
      oprot.writeListEnd()
12620 
      oprot.writeFieldEnd()
12621 
    oprot.writeFieldStop()
12622 
    oprot.writeStructEnd()
12623 
 
12624 
  def validate(self):
12625 
    return
12626 
 
12627 
 
12628 
  def __repr__(self):
12629 
    L = ['%s=%r' % (key, value)
12630 
      for key, value in self.__dict__.iteritems()]
12631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12632 
 
12633 
  def __eq__(self, other):
12634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12635 
 
12636 
  def __ne__(self, other):
12637 
    return not (self == other)
12638 
 
12639 
class saveDiscounts_result:
12640 
  """
12641 
  Attributes:
12642 
   - scx
12643 
  """
12644 
 
12645 
  thrift_spec = (
12646 
    None, # 0
12647 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12648 
  )
12649 
 
12650 
  def __init__(self, scx=None,):
12651 
    self.scx = scx
12652 
 
12653 
  def read(self, iprot):
12654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12656 
      return
12657 
    iprot.readStructBegin()
12658 
    while True:
12659 
      (fname, ftype, fid) = iprot.readFieldBegin()
12660 
      if ftype == TType.STOP:
12661 
        break
12662 
      if fid == 1:
12663 
        if ftype == TType.STRUCT:
12664 
          self.scx = ShoppingCartException()
12665 
          self.scx.read(iprot)
12666 
        else:
12667 
          iprot.skip(ftype)
12668 
      else:
12669 
        iprot.skip(ftype)
12670 
      iprot.readFieldEnd()
12671 
    iprot.readStructEnd()
12672 
 
12673 
  def write(self, oprot):
12674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12676 
      return
12677 
    oprot.writeStructBegin('saveDiscounts_result')
12678 
    if self.scx is not None:
12679 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12680 
      self.scx.write(oprot)
12681 
      oprot.writeFieldEnd()
12682 
    oprot.writeFieldStop()
12683 
    oprot.writeStructEnd()
12684 
 
12685 
  def validate(self):
12686 
    return
12687 
 
12688 
 
12689 
  def __repr__(self):
12690 
    L = ['%s=%r' % (key, value)
12691 
      for key, value in self.__dict__.iteritems()]
12692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12693 
 
12694 
  def __eq__(self, other):
12695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12696 
 
12697 
  def __ne__(self, other):
12698 
    return not (self == other)
12699 
 
690 chandransh 12700 
class createOrders_args:
559 chandransh 12701 
  """
12702 
  Attributes:
12703 
   - cartId
2815 vikas 12704 
   - sessionSource
12705 
   - sessionStartTime
3858 vikas 12706 
   - firstSource
12707 
   - firstSourceTime
5326 rajveer 12708 
   - userId
6389 rajveer 12709 
   - schemeId
11526 amit.gupta 12710 
   - orderSource
21454 amit.gupta 12711 
   - selfPickup
559 chandransh 12712 
  """
12713 
 
12714 
  thrift_spec = (
12715 
    None, # 0
12716 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12717 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12718 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12719 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12720 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12721 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12722 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12723 
    (8, TType.I64, 'orderSource', None, None, ), # 8
21454 amit.gupta 12724 
    (9, TType.BOOL, 'selfPickup', None, None, ), # 9
559 chandransh 12725 
  )
12726 
 
21454 amit.gupta 12727 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None, selfPickup=None,):
559 chandransh 12728 
    self.cartId = cartId
2815 vikas 12729 
    self.sessionSource = sessionSource
12730 
    self.sessionStartTime = sessionStartTime
3858 vikas 12731 
    self.firstSource = firstSource
12732 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12733 
    self.userId = userId
6389 rajveer 12734 
    self.schemeId = schemeId
11526 amit.gupta 12735 
    self.orderSource = orderSource
21454 amit.gupta 12736 
    self.selfPickup = selfPickup
559 chandransh 12737 
 
12738 
  def read(self, iprot):
12739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12741 
      return
12742 
    iprot.readStructBegin()
12743 
    while True:
12744 
      (fname, ftype, fid) = iprot.readFieldBegin()
12745 
      if ftype == TType.STOP:
12746 
        break
12747 
      if fid == 1:
12748 
        if ftype == TType.I64:
12749 
          self.cartId = iprot.readI64();
12750 
        else:
12751 
          iprot.skip(ftype)
2815 vikas 12752 
      elif fid == 2:
12753 
        if ftype == TType.STRING:
12754 
          self.sessionSource = iprot.readString();
12755 
        else:
12756 
          iprot.skip(ftype)
12757 
      elif fid == 3:
12758 
        if ftype == TType.I64:
12759 
          self.sessionStartTime = iprot.readI64();
12760 
        else:
12761 
          iprot.skip(ftype)
3858 vikas 12762 
      elif fid == 4:
12763 
        if ftype == TType.STRING:
12764 
          self.firstSource = iprot.readString();
12765 
        else:
12766 
          iprot.skip(ftype)
12767 
      elif fid == 5:
12768 
        if ftype == TType.I64:
12769 
          self.firstSourceTime = iprot.readI64();
12770 
        else:
12771 
          iprot.skip(ftype)
5326 rajveer 12772 
      elif fid == 6:
12773 
        if ftype == TType.I64:
12774 
          self.userId = iprot.readI64();
12775 
        else:
12776 
          iprot.skip(ftype)
6389 rajveer 12777 
      elif fid == 7:
12778 
        if ftype == TType.I64:
12779 
          self.schemeId = iprot.readI64();
12780 
        else:
12781 
          iprot.skip(ftype)
11526 amit.gupta 12782 
      elif fid == 8:
12783 
        if ftype == TType.I64:
12784 
          self.orderSource = iprot.readI64();
12785 
        else:
12786 
          iprot.skip(ftype)
21454 amit.gupta 12787 
      elif fid == 9:
12788 
        if ftype == TType.BOOL:
12789 
          self.selfPickup = iprot.readBool();
12790 
        else:
12791 
          iprot.skip(ftype)
559 chandransh 12792 
      else:
12793 
        iprot.skip(ftype)
12794 
      iprot.readFieldEnd()
12795 
    iprot.readStructEnd()
12796 
 
12797 
  def write(self, oprot):
12798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12800 
      return
690 chandransh 12801 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12802 
    if self.cartId is not None:
559 chandransh 12803 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12804 
      oprot.writeI64(self.cartId)
12805 
      oprot.writeFieldEnd()
3431 rajveer 12806 
    if self.sessionSource is not None:
2815 vikas 12807 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12808 
      oprot.writeString(self.sessionSource)
12809 
      oprot.writeFieldEnd()
3431 rajveer 12810 
    if self.sessionStartTime is not None:
2815 vikas 12811 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12812 
      oprot.writeI64(self.sessionStartTime)
12813 
      oprot.writeFieldEnd()
3858 vikas 12814 
    if self.firstSource is not None:
12815 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12816 
      oprot.writeString(self.firstSource)
12817 
      oprot.writeFieldEnd()
12818 
    if self.firstSourceTime is not None:
12819 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12820 
      oprot.writeI64(self.firstSourceTime)
12821 
      oprot.writeFieldEnd()
5326 rajveer 12822 
    if self.userId is not None:
12823 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12824 
      oprot.writeI64(self.userId)
12825 
      oprot.writeFieldEnd()
6389 rajveer 12826 
    if self.schemeId is not None:
12827 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12828 
      oprot.writeI64(self.schemeId)
12829 
      oprot.writeFieldEnd()
11526 amit.gupta 12830 
    if self.orderSource is not None:
12831 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12832 
      oprot.writeI64(self.orderSource)
12833 
      oprot.writeFieldEnd()
21454 amit.gupta 12834 
    if self.selfPickup is not None:
12835 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 9)
12836 
      oprot.writeBool(self.selfPickup)
12837 
      oprot.writeFieldEnd()
559 chandransh 12838 
    oprot.writeFieldStop()
12839 
    oprot.writeStructEnd()
12840 
 
3431 rajveer 12841 
  def validate(self):
12842 
    return
12843 
 
12844 
 
559 chandransh 12845 
  def __repr__(self):
12846 
    L = ['%s=%r' % (key, value)
12847 
      for key, value in self.__dict__.iteritems()]
12848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12849 
 
12850 
  def __eq__(self, other):
12851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12852 
 
12853 
  def __ne__(self, other):
12854 
    return not (self == other)
12855 
 
690 chandransh 12856 
class createOrders_result:
559 chandransh 12857 
  """
12858 
  Attributes:
94 ashish 12859 
   - success
559 chandransh 12860 
   - scx
94 ashish 12861 
  """
12862 
 
12863 
  thrift_spec = (
575 chandransh 12864 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12865 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12866 
  )
12867 
 
559 chandransh 12868 
  def __init__(self, success=None, scx=None,):
94 ashish 12869 
    self.success = success
559 chandransh 12870 
    self.scx = scx
94 ashish 12871 
 
12872 
  def read(self, iprot):
12873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12875 
      return
12876 
    iprot.readStructBegin()
12877 
    while True:
12878 
      (fname, ftype, fid) = iprot.readFieldBegin()
12879 
      if ftype == TType.STOP:
12880 
        break
12881 
      if fid == 0:
575 chandransh 12882 
        if ftype == TType.I64:
12883 
          self.success = iprot.readI64();
94 ashish 12884 
        else:
12885 
          iprot.skip(ftype)
12886 
      elif fid == 1:
12887 
        if ftype == TType.STRUCT:
559 chandransh 12888 
          self.scx = ShoppingCartException()
12889 
          self.scx.read(iprot)
94 ashish 12890 
        else:
12891 
          iprot.skip(ftype)
12892 
      else:
12893 
        iprot.skip(ftype)
12894 
      iprot.readFieldEnd()
12895 
    iprot.readStructEnd()
12896 
 
12897 
  def write(self, oprot):
12898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12900 
      return
690 chandransh 12901 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12902 
    if self.success is not None:
575 chandransh 12903 
      oprot.writeFieldBegin('success', TType.I64, 0)
12904 
      oprot.writeI64(self.success)
94 ashish 12905 
      oprot.writeFieldEnd()
3431 rajveer 12906 
    if self.scx is not None:
559 chandransh 12907 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12908 
      self.scx.write(oprot)
94 ashish 12909 
      oprot.writeFieldEnd()
12910 
    oprot.writeFieldStop()
12911 
    oprot.writeStructEnd()
12912 
 
3431 rajveer 12913 
  def validate(self):
12914 
    return
12915 
 
12916 
 
94 ashish 12917 
  def __repr__(self):
12918 
    L = ['%s=%r' % (key, value)
12919 
      for key, value in self.__dict__.iteritems()]
12920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12921 
 
12922 
  def __eq__(self, other):
12923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12924 
 
12925 
  def __ne__(self, other):
12926 
    return not (self == other)
12927 
 
559 chandransh 12928 
class validateCart_args:
94 ashish 12929 
  """
12930 
  Attributes:
559 chandransh 12931 
   - cartId
3557 rajveer 12932 
   - sourceId
94 ashish 12933 
  """
12934 
 
12935 
  thrift_spec = (
12936 
    None, # 0
559 chandransh 12937 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12938 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12939 
  )
12940 
 
3557 rajveer 12941 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12942 
    self.cartId = cartId
3557 rajveer 12943 
    self.sourceId = sourceId
94 ashish 12944 
 
12945 
  def read(self, iprot):
12946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12948 
      return
12949 
    iprot.readStructBegin()
12950 
    while True:
12951 
      (fname, ftype, fid) = iprot.readFieldBegin()
12952 
      if ftype == TType.STOP:
12953 
        break
12954 
      if fid == 1:
12955 
        if ftype == TType.I64:
559 chandransh 12956 
          self.cartId = iprot.readI64();
94 ashish 12957 
        else:
12958 
          iprot.skip(ftype)
3557 rajveer 12959 
      elif fid == 2:
12960 
        if ftype == TType.I64:
12961 
          self.sourceId = iprot.readI64();
12962 
        else:
12963 
          iprot.skip(ftype)
94 ashish 12964 
      else:
12965 
        iprot.skip(ftype)
12966 
      iprot.readFieldEnd()
12967 
    iprot.readStructEnd()
12968 
 
12969 
  def write(self, oprot):
12970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12972 
      return
559 chandransh 12973 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12974 
    if self.cartId is not None:
559 chandransh 12975 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12976 
      oprot.writeI64(self.cartId)
94 ashish 12977 
      oprot.writeFieldEnd()
3557 rajveer 12978 
    if self.sourceId is not None:
12979 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12980 
      oprot.writeI64(self.sourceId)
12981 
      oprot.writeFieldEnd()
94 ashish 12982 
    oprot.writeFieldStop()
12983 
    oprot.writeStructEnd()
12984 
 
3431 rajveer 12985 
  def validate(self):
12986 
    return
12987 
 
12988 
 
94 ashish 12989 
  def __repr__(self):
12990 
    L = ['%s=%r' % (key, value)
12991 
      for key, value in self.__dict__.iteritems()]
12992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12993 
 
12994 
  def __eq__(self, other):
12995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12996 
 
12997 
  def __ne__(self, other):
12998 
    return not (self == other)
12999 
 
559 chandransh 13000 
class validateCart_result:
94 ashish 13001 
  """
13002 
  Attributes:
13003 
   - success
575 chandransh 13004 
   - scex
94 ashish 13005 
  """
13006 
 
13007 
  thrift_spec = (
6736 amit.gupta 13008 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 13009 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 13010 
  )
13011 
 
575 chandransh 13012 
  def __init__(self, success=None, scex=None,):
94 ashish 13013 
    self.success = success
575 chandransh 13014 
    self.scex = scex
94 ashish 13015 
 
13016 
  def read(self, iprot):
13017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13019 
      return
13020 
    iprot.readStructBegin()
13021 
    while True:
13022 
      (fname, ftype, fid) = iprot.readFieldBegin()
13023 
      if ftype == TType.STOP:
13024 
        break
13025 
      if fid == 0:
6736 amit.gupta 13026 
        if ftype == TType.LIST:
13027 
          self.success = []
11592 amit.gupta 13028 
          (_etype170, _size167) = iprot.readListBegin()
13029 
          for _i171 in xrange(_size167):
13030 
            _elem172 = iprot.readString();
13031 
            self.success.append(_elem172)
6736 amit.gupta 13032 
          iprot.readListEnd()
94 ashish 13033 
        else:
13034 
          iprot.skip(ftype)
575 chandransh 13035 
      elif fid == 1:
13036 
        if ftype == TType.STRUCT:
13037 
          self.scex = ShoppingCartException()
13038 
          self.scex.read(iprot)
13039 
        else:
13040 
          iprot.skip(ftype)
94 ashish 13041 
      else:
13042 
        iprot.skip(ftype)
13043 
      iprot.readFieldEnd()
13044 
    iprot.readStructEnd()
13045 
 
13046 
  def write(self, oprot):
13047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13049 
      return
559 chandransh 13050 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 13051 
    if self.success is not None:
6736 amit.gupta 13052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13053 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 13054 
      for iter173 in self.success:
13055 
        oprot.writeString(iter173)
6736 amit.gupta 13056 
      oprot.writeListEnd()
94 ashish 13057 
      oprot.writeFieldEnd()
3431 rajveer 13058 
    if self.scex is not None:
575 chandransh 13059 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13060 
      self.scex.write(oprot)
13061 
      oprot.writeFieldEnd()
559 chandransh 13062 
    oprot.writeFieldStop()
13063 
    oprot.writeStructEnd()
13064 
 
3431 rajveer 13065 
  def validate(self):
13066 
    return
13067 
 
13068 
 
559 chandransh 13069 
  def __repr__(self):
13070 
    L = ['%s=%r' % (key, value)
13071 
      for key, value in self.__dict__.iteritems()]
13072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13073 
 
13074 
  def __eq__(self, other):
13075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13076 
 
13077 
  def __ne__(self, other):
13078 
    return not (self == other)
13079 
 
11980 amit.gupta 13080 
class validateCartWithDealerCoupon_args:
13081 
  """
13082 
  Attributes:
13083 
   - cartId
13084 
   - sourceId
13085 
   - dealCoupon
13086 
  """
13087 
 
13088 
  thrift_spec = (
13089 
    None, # 0
13090 
    (1, TType.I64, 'cartId', None, None, ), # 1
13091 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13092 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
13093 
  )
13094 
 
13095 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
13096 
    self.cartId = cartId
13097 
    self.sourceId = sourceId
13098 
    self.dealCoupon = dealCoupon
13099 
 
13100 
  def read(self, iprot):
13101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13103 
      return
13104 
    iprot.readStructBegin()
13105 
    while True:
13106 
      (fname, ftype, fid) = iprot.readFieldBegin()
13107 
      if ftype == TType.STOP:
13108 
        break
13109 
      if fid == 1:
13110 
        if ftype == TType.I64:
13111 
          self.cartId = iprot.readI64();
13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      elif fid == 2:
13115 
        if ftype == TType.I64:
13116 
          self.sourceId = iprot.readI64();
13117 
        else:
13118 
          iprot.skip(ftype)
13119 
      elif fid == 3:
13120 
        if ftype == TType.STRING:
13121 
          self.dealCoupon = iprot.readString();
13122 
        else:
13123 
          iprot.skip(ftype)
13124 
      else:
13125 
        iprot.skip(ftype)
13126 
      iprot.readFieldEnd()
13127 
    iprot.readStructEnd()
13128 
 
13129 
  def write(self, oprot):
13130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13132 
      return
13133 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
13134 
    if self.cartId is not None:
13135 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13136 
      oprot.writeI64(self.cartId)
13137 
      oprot.writeFieldEnd()
13138 
    if self.sourceId is not None:
13139 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13140 
      oprot.writeI64(self.sourceId)
13141 
      oprot.writeFieldEnd()
13142 
    if self.dealCoupon is not None:
13143 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
13144 
      oprot.writeString(self.dealCoupon)
13145 
      oprot.writeFieldEnd()
13146 
    oprot.writeFieldStop()
13147 
    oprot.writeStructEnd()
13148 
 
13149 
  def validate(self):
13150 
    return
13151 
 
13152 
 
13153 
  def __repr__(self):
13154 
    L = ['%s=%r' % (key, value)
13155 
      for key, value in self.__dict__.iteritems()]
13156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13157 
 
13158 
  def __eq__(self, other):
13159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13160 
 
13161 
  def __ne__(self, other):
13162 
    return not (self == other)
13163 
 
13164 
class validateCartWithDealerCoupon_result:
13165 
  """
13166 
  Attributes:
13167 
   - success
13168 
   - scex
13169 
  """
13170 
 
13171 
  thrift_spec = (
13172 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13173 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13174 
  )
13175 
 
13176 
  def __init__(self, success=None, scex=None,):
13177 
    self.success = success
13178 
    self.scex = scex
13179 
 
13180 
  def read(self, iprot):
13181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13183 
      return
13184 
    iprot.readStructBegin()
13185 
    while True:
13186 
      (fname, ftype, fid) = iprot.readFieldBegin()
13187 
      if ftype == TType.STOP:
13188 
        break
13189 
      if fid == 0:
13190 
        if ftype == TType.LIST:
13191 
          self.success = []
13192 
          (_etype177, _size174) = iprot.readListBegin()
13193 
          for _i178 in xrange(_size174):
13194 
            _elem179 = iprot.readString();
13195 
            self.success.append(_elem179)
13196 
          iprot.readListEnd()
13197 
        else:
13198 
          iprot.skip(ftype)
13199 
      elif fid == 1:
13200 
        if ftype == TType.STRUCT:
13201 
          self.scex = ShoppingCartException()
13202 
          self.scex.read(iprot)
13203 
        else:
13204 
          iprot.skip(ftype)
13205 
      else:
13206 
        iprot.skip(ftype)
13207 
      iprot.readFieldEnd()
13208 
    iprot.readStructEnd()
13209 
 
13210 
  def write(self, oprot):
13211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13213 
      return
13214 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
13215 
    if self.success is not None:
13216 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13217 
      oprot.writeListBegin(TType.STRING, len(self.success))
13218 
      for iter180 in self.success:
13219 
        oprot.writeString(iter180)
13220 
      oprot.writeListEnd()
13221 
      oprot.writeFieldEnd()
13222 
    if self.scex is not None:
13223 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13224 
      self.scex.write(oprot)
13225 
      oprot.writeFieldEnd()
13226 
    oprot.writeFieldStop()
13227 
    oprot.writeStructEnd()
13228 
 
13229 
  def validate(self):
13230 
    return
13231 
 
13232 
 
13233 
  def __repr__(self):
13234 
    L = ['%s=%r' % (key, value)
13235 
      for key, value in self.__dict__.iteritems()]
13236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13237 
 
13238 
  def __eq__(self, other):
13239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13240 
 
13241 
  def __ne__(self, other):
13242 
    return not (self == other)
13243 
 
690 chandransh 13244 
class mergeCart_args:
575 chandransh 13245 
  """
13246 
  Attributes:
690 chandransh 13247 
   - fromCartId
13248 
   - toCartId
13249 
  """
13250 
 
13251 
  thrift_spec = (
13252 
    None, # 0
13253 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
13254 
    (2, TType.I64, 'toCartId', None, None, ), # 2
13255 
  )
13256 
 
13257 
  def __init__(self, fromCartId=None, toCartId=None,):
13258 
    self.fromCartId = fromCartId
13259 
    self.toCartId = toCartId
13260 
 
13261 
  def read(self, iprot):
13262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13264 
      return
13265 
    iprot.readStructBegin()
13266 
    while True:
13267 
      (fname, ftype, fid) = iprot.readFieldBegin()
13268 
      if ftype == TType.STOP:
13269 
        break
13270 
      if fid == 1:
13271 
        if ftype == TType.I64:
13272 
          self.fromCartId = iprot.readI64();
13273 
        else:
13274 
          iprot.skip(ftype)
13275 
      elif fid == 2:
13276 
        if ftype == TType.I64:
13277 
          self.toCartId = iprot.readI64();
13278 
        else:
13279 
          iprot.skip(ftype)
13280 
      else:
13281 
        iprot.skip(ftype)
13282 
      iprot.readFieldEnd()
13283 
    iprot.readStructEnd()
13284 
 
13285 
  def write(self, oprot):
13286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13288 
      return
13289 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 13290 
    if self.fromCartId is not None:
690 chandransh 13291 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
13292 
      oprot.writeI64(self.fromCartId)
13293 
      oprot.writeFieldEnd()
3431 rajveer 13294 
    if self.toCartId is not None:
690 chandransh 13295 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
13296 
      oprot.writeI64(self.toCartId)
13297 
      oprot.writeFieldEnd()
13298 
    oprot.writeFieldStop()
13299 
    oprot.writeStructEnd()
13300 
 
3431 rajveer 13301 
  def validate(self):
13302 
    return
13303 
 
13304 
 
690 chandransh 13305 
  def __repr__(self):
13306 
    L = ['%s=%r' % (key, value)
13307 
      for key, value in self.__dict__.iteritems()]
13308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13309 
 
13310 
  def __eq__(self, other):
13311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13312 
 
13313 
  def __ne__(self, other):
13314 
    return not (self == other)
13315 
 
13316 
class mergeCart_result:
13317 
 
13318 
  thrift_spec = (
13319 
  )
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 
      else:
13331 
        iprot.skip(ftype)
13332 
      iprot.readFieldEnd()
13333 
    iprot.readStructEnd()
13334 
 
13335 
  def write(self, oprot):
13336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13338 
      return
13339 
    oprot.writeStructBegin('mergeCart_result')
13340 
    oprot.writeFieldStop()
13341 
    oprot.writeStructEnd()
13342 
 
3431 rajveer 13343 
  def validate(self):
13344 
    return
13345 
 
13346 
 
690 chandransh 13347 
  def __repr__(self):
13348 
    L = ['%s=%r' % (key, value)
13349 
      for key, value in self.__dict__.iteritems()]
13350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13351 
 
13352 
  def __eq__(self, other):
13353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13354 
 
13355 
  def __ne__(self, other):
13356 
    return not (self == other)
13357 
 
13358 
class checkOut_args:
13359 
  """
13360 
  Attributes:
575 chandransh 13361 
   - cartId
13362 
  """
13363 
 
13364 
  thrift_spec = (
13365 
    None, # 0
13366 
    (1, TType.I64, 'cartId', None, None, ), # 1
13367 
  )
13368 
 
13369 
  def __init__(self, cartId=None,):
13370 
    self.cartId = cartId
13371 
 
13372 
  def read(self, iprot):
13373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13375 
      return
13376 
    iprot.readStructBegin()
13377 
    while True:
13378 
      (fname, ftype, fid) = iprot.readFieldBegin()
13379 
      if ftype == TType.STOP:
13380 
        break
13381 
      if fid == 1:
13382 
        if ftype == TType.I64:
13383 
          self.cartId = iprot.readI64();
13384 
        else:
13385 
          iprot.skip(ftype)
13386 
      else:
13387 
        iprot.skip(ftype)
13388 
      iprot.readFieldEnd()
13389 
    iprot.readStructEnd()
13390 
 
13391 
  def write(self, oprot):
13392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13394 
      return
690 chandransh 13395 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 13396 
    if self.cartId is not None:
575 chandransh 13397 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13398 
      oprot.writeI64(self.cartId)
13399 
      oprot.writeFieldEnd()
13400 
    oprot.writeFieldStop()
13401 
    oprot.writeStructEnd()
13402 
 
3431 rajveer 13403 
  def validate(self):
13404 
    return
13405 
 
13406 
 
575 chandransh 13407 
  def __repr__(self):
13408 
    L = ['%s=%r' % (key, value)
13409 
      for key, value in self.__dict__.iteritems()]
13410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13411 
 
13412 
  def __eq__(self, other):
13413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13414 
 
13415 
  def __ne__(self, other):
13416 
    return not (self == other)
13417 
 
690 chandransh 13418 
class checkOut_result:
575 chandransh 13419 
  """
13420 
  Attributes:
13421 
   - success
13422 
   - scex
13423 
  """
13424 
 
13425 
  thrift_spec = (
13426 
    (0, TType.BOOL, 'success', None, None, ), # 0
13427 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13428 
  )
13429 
 
13430 
  def __init__(self, success=None, scex=None,):
13431 
    self.success = success
13432 
    self.scex = scex
13433 
 
13434 
  def read(self, iprot):
13435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13437 
      return
13438 
    iprot.readStructBegin()
13439 
    while True:
13440 
      (fname, ftype, fid) = iprot.readFieldBegin()
13441 
      if ftype == TType.STOP:
13442 
        break
13443 
      if fid == 0:
13444 
        if ftype == TType.BOOL:
13445 
          self.success = iprot.readBool();
13446 
        else:
13447 
          iprot.skip(ftype)
13448 
      elif fid == 1:
13449 
        if ftype == TType.STRUCT:
13450 
          self.scex = ShoppingCartException()
13451 
          self.scex.read(iprot)
13452 
        else:
13453 
          iprot.skip(ftype)
13454 
      else:
13455 
        iprot.skip(ftype)
13456 
      iprot.readFieldEnd()
13457 
    iprot.readStructEnd()
13458 
 
13459 
  def write(self, oprot):
13460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13462 
      return
690 chandransh 13463 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 13464 
    if self.success is not None:
575 chandransh 13465 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13466 
      oprot.writeBool(self.success)
13467 
      oprot.writeFieldEnd()
3431 rajveer 13468 
    if self.scex is not None:
575 chandransh 13469 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13470 
      self.scex.write(oprot)
13471 
      oprot.writeFieldEnd()
13472 
    oprot.writeFieldStop()
13473 
    oprot.writeStructEnd()
13474 
 
3431 rajveer 13475 
  def validate(self):
13476 
    return
13477 
 
13478 
 
575 chandransh 13479 
  def __repr__(self):
13480 
    L = ['%s=%r' % (key, value)
13481 
      for key, value in self.__dict__.iteritems()]
13482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13483 
 
13484 
  def __eq__(self, other):
13485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13486 
 
13487 
  def __ne__(self, other):
13488 
    return not (self == other)
13489 
 
690 chandransh 13490 
class resetCart_args:
559 chandransh 13491 
  """
13492 
  Attributes:
690 chandransh 13493 
   - cartId
13494 
   - items
559 chandransh 13495 
  """
13496 
 
13497 
  thrift_spec = (
13498 
    None, # 0
690 chandransh 13499 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13500 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13501 
  )
13502 
 
690 chandransh 13503 
  def __init__(self, cartId=None, items=None,):
13504 
    self.cartId = cartId
13505 
    self.items = items
559 chandransh 13506 
 
13507 
  def read(self, iprot):
13508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13510 
      return
13511 
    iprot.readStructBegin()
13512 
    while True:
13513 
      (fname, ftype, fid) = iprot.readFieldBegin()
13514 
      if ftype == TType.STOP:
13515 
        break
13516 
      if fid == 1:
13517 
        if ftype == TType.I64:
690 chandransh 13518 
          self.cartId = iprot.readI64();
559 chandransh 13519 
        else:
13520 
          iprot.skip(ftype)
13521 
      elif fid == 2:
690 chandransh 13522 
        if ftype == TType.MAP:
13523 
          self.items = {}
11980 amit.gupta 13524 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13525 
          for _i185 in xrange(_size181):
13526 
            _key186 = iprot.readI64();
13527 
            _val187 = iprot.readDouble();
13528 
            self.items[_key186] = _val187
690 chandransh 13529 
          iprot.readMapEnd()
559 chandransh 13530 
        else:
13531 
          iprot.skip(ftype)
13532 
      else:
13533 
        iprot.skip(ftype)
13534 
      iprot.readFieldEnd()
13535 
    iprot.readStructEnd()
13536 
 
13537 
  def write(self, oprot):
13538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13540 
      return
690 chandransh 13541 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13542 
    if self.cartId is not None:
690 chandransh 13543 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13544 
      oprot.writeI64(self.cartId)
94 ashish 13545 
      oprot.writeFieldEnd()
3431 rajveer 13546 
    if self.items is not None:
690 chandransh 13547 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13548 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13549 
      for kiter188,viter189 in self.items.items():
13550 
        oprot.writeI64(kiter188)
13551 
        oprot.writeDouble(viter189)
690 chandransh 13552 
      oprot.writeMapEnd()
559 chandransh 13553 
      oprot.writeFieldEnd()
94 ashish 13554 
    oprot.writeFieldStop()
13555 
    oprot.writeStructEnd()
13556 
 
3431 rajveer 13557 
  def validate(self):
13558 
    return
13559 
 
13560 
 
94 ashish 13561 
  def __repr__(self):
13562 
    L = ['%s=%r' % (key, value)
13563 
      for key, value in self.__dict__.iteritems()]
13564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13565 
 
13566 
  def __eq__(self, other):
13567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13568 
 
13569 
  def __ne__(self, other):
13570 
    return not (self == other)
13571 
 
690 chandransh 13572 
class resetCart_result:
13573 
  """
13574 
  Attributes:
13575 
   - success
13576 
   - scex
13577 
  """
559 chandransh 13578 
 
13579 
  thrift_spec = (
690 chandransh 13580 
    (0, TType.BOOL, 'success', None, None, ), # 0
13581 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13582 
  )
13583 
 
690 chandransh 13584 
  def __init__(self, success=None, scex=None,):
13585 
    self.success = success
13586 
    self.scex = scex
13587 
 
559 chandransh 13588 
  def read(self, iprot):
13589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13591 
      return
13592 
    iprot.readStructBegin()
13593 
    while True:
13594 
      (fname, ftype, fid) = iprot.readFieldBegin()
13595 
      if ftype == TType.STOP:
13596 
        break
690 chandransh 13597 
      if fid == 0:
13598 
        if ftype == TType.BOOL:
13599 
          self.success = iprot.readBool();
13600 
        else:
13601 
          iprot.skip(ftype)
13602 
      elif fid == 1:
13603 
        if ftype == TType.STRUCT:
13604 
          self.scex = ShoppingCartException()
13605 
          self.scex.read(iprot)
13606 
        else:
13607 
          iprot.skip(ftype)
559 chandransh 13608 
      else:
13609 
        iprot.skip(ftype)
13610 
      iprot.readFieldEnd()
13611 
    iprot.readStructEnd()
13612 
 
13613 
  def write(self, oprot):
13614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13616 
      return
690 chandransh 13617 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13618 
    if self.success is not None:
690 chandransh 13619 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13620 
      oprot.writeBool(self.success)
13621 
      oprot.writeFieldEnd()
3431 rajveer 13622 
    if self.scex is not None:
690 chandransh 13623 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13624 
      self.scex.write(oprot)
13625 
      oprot.writeFieldEnd()
559 chandransh 13626 
    oprot.writeFieldStop()
13627 
    oprot.writeStructEnd()
13628 
 
3431 rajveer 13629 
  def validate(self):
13630 
    return
13631 
 
13632 
 
559 chandransh 13633 
  def __repr__(self):
13634 
    L = ['%s=%r' % (key, value)
13635 
      for key, value in self.__dict__.iteritems()]
13636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13637 
 
13638 
  def __eq__(self, other):
13639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13640 
 
13641 
  def __ne__(self, other):
13642 
    return not (self == other)
13643 
 
2981 rajveer 13644 
class getUserCount_args:
94 ashish 13645 
  """
13646 
  Attributes:
2981 rajveer 13647 
   - userType
559 chandransh 13648 
  """
13649 
 
13650 
  thrift_spec = (
13651 
    None, # 0
2981 rajveer 13652 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13653 
  )
13654 
 
2981 rajveer 13655 
  def __init__(self, userType=None,):
13656 
    self.userType = userType
559 chandransh 13657 
 
13658 
  def read(self, iprot):
13659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13661 
      return
13662 
    iprot.readStructBegin()
13663 
    while True:
13664 
      (fname, ftype, fid) = iprot.readFieldBegin()
13665 
      if ftype == TType.STOP:
13666 
        break
13667 
      if fid == 1:
2981 rajveer 13668 
        if ftype == TType.I32:
13669 
          self.userType = iprot.readI32();
559 chandransh 13670 
        else:
13671 
          iprot.skip(ftype)
13672 
      else:
13673 
        iprot.skip(ftype)
13674 
      iprot.readFieldEnd()
13675 
    iprot.readStructEnd()
13676 
 
13677 
  def write(self, oprot):
13678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13680 
      return
2981 rajveer 13681 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13682 
    if self.userType is not None:
2981 rajveer 13683 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13684 
      oprot.writeI32(self.userType)
559 chandransh 13685 
      oprot.writeFieldEnd()
13686 
    oprot.writeFieldStop()
13687 
    oprot.writeStructEnd()
13688 
 
3431 rajveer 13689 
  def validate(self):
13690 
    return
13691 
 
13692 
 
559 chandransh 13693 
  def __repr__(self):
13694 
    L = ['%s=%r' % (key, value)
13695 
      for key, value in self.__dict__.iteritems()]
13696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13697 
 
13698 
  def __eq__(self, other):
13699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13700 
 
13701 
  def __ne__(self, other):
13702 
    return not (self == other)
13703 
 
2981 rajveer 13704 
class getUserCount_result:
94 ashish 13705 
  """
13706 
  Attributes:
13707 
   - success
13708 
  """
13709 
 
13710 
  thrift_spec = (
2981 rajveer 13711 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13712 
  )
13713 
 
2981 rajveer 13714 
  def __init__(self, success=None,):
94 ashish 13715 
    self.success = success
13716 
 
13717 
  def read(self, iprot):
13718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13720 
      return
13721 
    iprot.readStructBegin()
13722 
    while True:
13723 
      (fname, ftype, fid) = iprot.readFieldBegin()
13724 
      if ftype == TType.STOP:
13725 
        break
13726 
      if fid == 0:
2981 rajveer 13727 
        if ftype == TType.I64:
13728 
          self.success = iprot.readI64();
94 ashish 13729 
        else:
13730 
          iprot.skip(ftype)
13731 
      else:
13732 
        iprot.skip(ftype)
13733 
      iprot.readFieldEnd()
13734 
    iprot.readStructEnd()
13735 
 
13736 
  def write(self, oprot):
13737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13739 
      return
2981 rajveer 13740 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13741 
    if self.success is not None:
2981 rajveer 13742 
      oprot.writeFieldBegin('success', TType.I64, 0)
13743 
      oprot.writeI64(self.success)
94 ashish 13744 
      oprot.writeFieldEnd()
13745 
    oprot.writeFieldStop()
13746 
    oprot.writeStructEnd()
13747 
 
3431 rajveer 13748 
  def validate(self):
13749 
    return
13750 
 
13751 
 
94 ashish 13752 
  def __repr__(self):
13753 
    L = ['%s=%r' % (key, value)
13754 
      for key, value in self.__dict__.iteritems()]
13755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13756 
 
13757 
  def __eq__(self, other):
13758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13759 
 
13760 
  def __ne__(self, other):
13761 
    return not (self == other)
13762 
 
2981 rajveer 13763 
class getAllUsers_args:
94 ashish 13764 
  """
13765 
  Attributes:
2981 rajveer 13766 
   - userType
13767 
   - startDate
13768 
   - endDate
94 ashish 13769 
  """
13770 
 
13771 
  thrift_spec = (
13772 
    None, # 0
2981 rajveer 13773 
    (1, TType.I32, 'userType', None, None, ), # 1
13774 
    (2, TType.I64, 'startDate', None, None, ), # 2
13775 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13776 
  )
13777 
 
2981 rajveer 13778 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13779 
    self.userType = userType
13780 
    self.startDate = startDate
13781 
    self.endDate = endDate
94 ashish 13782 
 
13783 
  def read(self, iprot):
13784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13786 
      return
13787 
    iprot.readStructBegin()
13788 
    while True:
13789 
      (fname, ftype, fid) = iprot.readFieldBegin()
13790 
      if ftype == TType.STOP:
13791 
        break
13792 
      if fid == 1:
2981 rajveer 13793 
        if ftype == TType.I32:
13794 
          self.userType = iprot.readI32();
94 ashish 13795 
        else:
13796 
          iprot.skip(ftype)
13797 
      elif fid == 2:
559 chandransh 13798 
        if ftype == TType.I64:
2981 rajveer 13799 
          self.startDate = iprot.readI64();
94 ashish 13800 
        else:
13801 
          iprot.skip(ftype)
2981 rajveer 13802 
      elif fid == 3:
13803 
        if ftype == TType.I64:
13804 
          self.endDate = iprot.readI64();
13805 
        else:
13806 
          iprot.skip(ftype)
94 ashish 13807 
      else:
13808 
        iprot.skip(ftype)
13809 
      iprot.readFieldEnd()
13810 
    iprot.readStructEnd()
13811 
 
13812 
  def write(self, oprot):
13813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13815 
      return
2981 rajveer 13816 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13817 
    if self.userType is not None:
2981 rajveer 13818 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13819 
      oprot.writeI32(self.userType)
94 ashish 13820 
      oprot.writeFieldEnd()
3431 rajveer 13821 
    if self.startDate is not None:
2981 rajveer 13822 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13823 
      oprot.writeI64(self.startDate)
94 ashish 13824 
      oprot.writeFieldEnd()
3431 rajveer 13825 
    if self.endDate is not None:
2981 rajveer 13826 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13827 
      oprot.writeI64(self.endDate)
13828 
      oprot.writeFieldEnd()
94 ashish 13829 
    oprot.writeFieldStop()
13830 
    oprot.writeStructEnd()
13831 
 
3431 rajveer 13832 
  def validate(self):
13833 
    return
13834 
 
13835 
 
94 ashish 13836 
  def __repr__(self):
13837 
    L = ['%s=%r' % (key, value)
13838 
      for key, value in self.__dict__.iteritems()]
13839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13840 
 
13841 
  def __eq__(self, other):
13842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13843 
 
13844 
  def __ne__(self, other):
13845 
    return not (self == other)
13846 
 
2981 rajveer 13847 
class getAllUsers_result:
94 ashish 13848 
  """
13849 
  Attributes:
13850 
   - success
13851 
  """
13852 
 
13853 
  thrift_spec = (
2981 rajveer 13854 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13855 
  )
13856 
 
2981 rajveer 13857 
  def __init__(self, success=None,):
94 ashish 13858 
    self.success = success
13859 
 
13860 
  def read(self, iprot):
13861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13863 
      return
13864 
    iprot.readStructBegin()
13865 
    while True:
13866 
      (fname, ftype, fid) = iprot.readFieldBegin()
13867 
      if ftype == TType.STOP:
13868 
        break
13869 
      if fid == 0:
2981 rajveer 13870 
        if ftype == TType.LIST:
13871 
          self.success = []
11980 amit.gupta 13872 
          (_etype193, _size190) = iprot.readListBegin()
13873 
          for _i194 in xrange(_size190):
13874 
            _elem195 = User()
13875 
            _elem195.read(iprot)
13876 
            self.success.append(_elem195)
2981 rajveer 13877 
          iprot.readListEnd()
94 ashish 13878 
        else:
13879 
          iprot.skip(ftype)
13880 
      else:
13881 
        iprot.skip(ftype)
13882 
      iprot.readFieldEnd()
13883 
    iprot.readStructEnd()
13884 
 
13885 
  def write(self, oprot):
13886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13888 
      return
2981 rajveer 13889 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13890 
    if self.success is not None:
2981 rajveer 13891 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13892 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13893 
      for iter196 in self.success:
13894 
        iter196.write(oprot)
2981 rajveer 13895 
      oprot.writeListEnd()
94 ashish 13896 
      oprot.writeFieldEnd()
13897 
    oprot.writeFieldStop()
13898 
    oprot.writeStructEnd()
13899 
 
3431 rajveer 13900 
  def validate(self):
13901 
    return
13902 
 
13903 
 
94 ashish 13904 
  def __repr__(self):
13905 
    L = ['%s=%r' % (key, value)
13906 
      for key, value in self.__dict__.iteritems()]
13907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13908 
 
13909 
  def __eq__(self, other):
13910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13911 
 
13912 
  def __ne__(self, other):
13913 
    return not (self == other)
13914 
 
2981 rajveer 13915 
class getMyResearchItems_args:
559 chandransh 13916 
  """
13917 
  Attributes:
772 rajveer 13918 
   - userId
559 chandransh 13919 
  """
13920 
 
13921 
  thrift_spec = (
13922 
    None, # 0
772 rajveer 13923 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13924 
  )
13925 
 
772 rajveer 13926 
  def __init__(self, userId=None,):
13927 
    self.userId = userId
559 chandransh 13928 
 
13929 
  def read(self, iprot):
13930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13932 
      return
13933 
    iprot.readStructBegin()
13934 
    while True:
13935 
      (fname, ftype, fid) = iprot.readFieldBegin()
13936 
      if ftype == TType.STOP:
13937 
        break
13938 
      if fid == 1:
13939 
        if ftype == TType.I64:
772 rajveer 13940 
          self.userId = iprot.readI64();
559 chandransh 13941 
        else:
13942 
          iprot.skip(ftype)
13943 
      else:
13944 
        iprot.skip(ftype)
13945 
      iprot.readFieldEnd()
13946 
    iprot.readStructEnd()
13947 
 
13948 
  def write(self, oprot):
13949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13951 
      return
2981 rajveer 13952 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13953 
    if self.userId is not None:
772 rajveer 13954 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13955 
      oprot.writeI64(self.userId)
559 chandransh 13956 
      oprot.writeFieldEnd()
13957 
    oprot.writeFieldStop()
13958 
    oprot.writeStructEnd()
13959 
 
3431 rajveer 13960 
  def validate(self):
13961 
    return
13962 
 
13963 
 
559 chandransh 13964 
  def __repr__(self):
13965 
    L = ['%s=%r' % (key, value)
13966 
      for key, value in self.__dict__.iteritems()]
13967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13968 
 
13969 
  def __eq__(self, other):
13970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13971 
 
13972 
  def __ne__(self, other):
13973 
    return not (self == other)
13974 
 
2981 rajveer 13975 
class getMyResearchItems_result:
559 chandransh 13976 
  """
13977 
  Attributes:
130 ashish 13978 
   - success
559 chandransh 13979 
   - scx
130 ashish 13980 
  """
13981 
 
13982 
  thrift_spec = (
2981 rajveer 13983 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13984 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13985 
  )
13986 
 
559 chandransh 13987 
  def __init__(self, success=None, scx=None,):
130 ashish 13988 
    self.success = success
559 chandransh 13989 
    self.scx = scx
130 ashish 13990 
 
13991 
  def read(self, iprot):
13992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13994 
      return
13995 
    iprot.readStructBegin()
13996 
    while True:
13997 
      (fname, ftype, fid) = iprot.readFieldBegin()
13998 
      if ftype == TType.STOP:
13999 
        break
14000 
      if fid == 0:
2981 rajveer 14001 
        if ftype == TType.LIST:
14002 
          self.success = []
11980 amit.gupta 14003 
          (_etype200, _size197) = iprot.readListBegin()
14004 
          for _i201 in xrange(_size197):
14005 
            _elem202 = iprot.readI64();
14006 
            self.success.append(_elem202)
2981 rajveer 14007 
          iprot.readListEnd()
130 ashish 14008 
        else:
14009 
          iprot.skip(ftype)
14010 
      elif fid == 1:
14011 
        if ftype == TType.STRUCT:
559 chandransh 14012 
          self.scx = WidgetException()
14013 
          self.scx.read(iprot)
130 ashish 14014 
        else:
14015 
          iprot.skip(ftype)
14016 
      else:
14017 
        iprot.skip(ftype)
14018 
      iprot.readFieldEnd()
14019 
    iprot.readStructEnd()
14020 
 
14021 
  def write(self, oprot):
14022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14024 
      return
2981 rajveer 14025 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 14026 
    if self.success is not None:
2981 rajveer 14027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14028 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14029 
      for iter203 in self.success:
14030 
        oprot.writeI64(iter203)
2981 rajveer 14031 
      oprot.writeListEnd()
130 ashish 14032 
      oprot.writeFieldEnd()
3431 rajveer 14033 
    if self.scx is not None:
559 chandransh 14034 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14035 
      self.scx.write(oprot)
130 ashish 14036 
      oprot.writeFieldEnd()
14037 
    oprot.writeFieldStop()
14038 
    oprot.writeStructEnd()
14039 
 
3431 rajveer 14040 
  def validate(self):
14041 
    return
14042 
 
14043 
 
130 ashish 14044 
  def __repr__(self):
14045 
    L = ['%s=%r' % (key, value)
14046 
      for key, value in self.__dict__.iteritems()]
14047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14048 
 
14049 
  def __eq__(self, other):
14050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14051 
 
14052 
  def __ne__(self, other):
14053 
    return not (self == other)
14054 
 
2981 rajveer 14055 
class updateMyResearch_args:
130 ashish 14056 
  """
14057 
  Attributes:
2981 rajveer 14058 
   - userId
14059 
   - itemId
130 ashish 14060 
  """
14061 
 
14062 
  thrift_spec = (
14063 
    None, # 0
2981 rajveer 14064 
    (1, TType.I64, 'userId', None, None, ), # 1
14065 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 14066 
  )
14067 
 
2981 rajveer 14068 
  def __init__(self, userId=None, itemId=None,):
14069 
    self.userId = userId
14070 
    self.itemId = itemId
130 ashish 14071 
 
14072 
  def read(self, iprot):
14073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14075 
      return
14076 
    iprot.readStructBegin()
14077 
    while True:
14078 
      (fname, ftype, fid) = iprot.readFieldBegin()
14079 
      if ftype == TType.STOP:
14080 
        break
14081 
      if fid == 1:
559 chandransh 14082 
        if ftype == TType.I64:
2981 rajveer 14083 
          self.userId = iprot.readI64();
130 ashish 14084 
        else:
14085 
          iprot.skip(ftype)
14086 
      elif fid == 2:
559 chandransh 14087 
        if ftype == TType.I64:
2981 rajveer 14088 
          self.itemId = iprot.readI64();
559 chandransh 14089 
        else:
14090 
          iprot.skip(ftype)
130 ashish 14091 
      else:
14092 
        iprot.skip(ftype)
14093 
      iprot.readFieldEnd()
14094 
    iprot.readStructEnd()
14095 
 
14096 
  def write(self, oprot):
14097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14099 
      return
2981 rajveer 14100 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 14101 
    if self.userId is not None:
2981 rajveer 14102 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14103 
      oprot.writeI64(self.userId)
130 ashish 14104 
      oprot.writeFieldEnd()
3431 rajveer 14105 
    if self.itemId is not None:
2981 rajveer 14106 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14107 
      oprot.writeI64(self.itemId)
130 ashish 14108 
      oprot.writeFieldEnd()
14109 
    oprot.writeFieldStop()
14110 
    oprot.writeStructEnd()
14111 
 
3431 rajveer 14112 
  def validate(self):
14113 
    return
14114 
 
14115 
 
130 ashish 14116 
  def __repr__(self):
14117 
    L = ['%s=%r' % (key, value)
14118 
      for key, value in self.__dict__.iteritems()]
14119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14120 
 
14121 
  def __eq__(self, other):
14122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14123 
 
14124 
  def __ne__(self, other):
14125 
    return not (self == other)
14126 
 
2981 rajveer 14127 
class updateMyResearch_result:
14128 
  """
14129 
  Attributes:
14130 
   - success
14131 
   - scx
14132 
  """
559 chandransh 14133 
 
14134 
  thrift_spec = (
2981 rajveer 14135 
    (0, TType.BOOL, 'success', None, None, ), # 0
14136 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 14137 
  )
14138 
 
2981 rajveer 14139 
  def __init__(self, success=None, scx=None,):
14140 
    self.success = success
14141 
    self.scx = scx
14142 
 
559 chandransh 14143 
  def read(self, iprot):
14144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14146 
      return
14147 
    iprot.readStructBegin()
14148 
    while True:
14149 
      (fname, ftype, fid) = iprot.readFieldBegin()
14150 
      if ftype == TType.STOP:
14151 
        break
2981 rajveer 14152 
      if fid == 0:
14153 
        if ftype == TType.BOOL:
14154 
          self.success = iprot.readBool();
14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      elif fid == 1:
14158 
        if ftype == TType.STRUCT:
14159 
          self.scx = WidgetException()
14160 
          self.scx.read(iprot)
14161 
        else:
14162 
          iprot.skip(ftype)
559 chandransh 14163 
      else:
14164 
        iprot.skip(ftype)
14165 
      iprot.readFieldEnd()
14166 
    iprot.readStructEnd()
14167 
 
14168 
  def write(self, oprot):
14169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14171 
      return
2981 rajveer 14172 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 14173 
    if self.success is not None:
2981 rajveer 14174 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14175 
      oprot.writeBool(self.success)
14176 
      oprot.writeFieldEnd()
3431 rajveer 14177 
    if self.scx is not None:
2981 rajveer 14178 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14179 
      self.scx.write(oprot)
14180 
      oprot.writeFieldEnd()
559 chandransh 14181 
    oprot.writeFieldStop()
14182 
    oprot.writeStructEnd()
14183 
 
3431 rajveer 14184 
  def validate(self):
14185 
    return
14186 
 
14187 
 
559 chandransh 14188 
  def __repr__(self):
14189 
    L = ['%s=%r' % (key, value)
14190 
      for key, value in self.__dict__.iteritems()]
14191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14192 
 
14193 
  def __eq__(self, other):
14194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14195 
 
14196 
  def __ne__(self, other):
14197 
    return not (self == other)
14198 
 
2981 rajveer 14199 
class deleteItemFromMyResearch_args:
1596 ankur.sing 14200 
  """
14201 
  Attributes:
2981 rajveer 14202 
   - userId
14203 
   - itemId
1596 ankur.sing 14204 
  """
559 chandransh 14205 
 
1596 ankur.sing 14206 
  thrift_spec = (
14207 
    None, # 0
2981 rajveer 14208 
    (1, TType.I64, 'userId', None, None, ), # 1
14209 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 14210 
  )
14211 
 
2981 rajveer 14212 
  def __init__(self, userId=None, itemId=None,):
14213 
    self.userId = userId
14214 
    self.itemId = itemId
1596 ankur.sing 14215 
 
14216 
  def read(self, iprot):
14217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14219 
      return
14220 
    iprot.readStructBegin()
14221 
    while True:
14222 
      (fname, ftype, fid) = iprot.readFieldBegin()
14223 
      if ftype == TType.STOP:
14224 
        break
14225 
      if fid == 1:
2981 rajveer 14226 
        if ftype == TType.I64:
14227 
          self.userId = iprot.readI64();
1596 ankur.sing 14228 
        else:
14229 
          iprot.skip(ftype)
2981 rajveer 14230 
      elif fid == 2:
14231 
        if ftype == TType.I64:
14232 
          self.itemId = iprot.readI64();
14233 
        else:
14234 
          iprot.skip(ftype)
1596 ankur.sing 14235 
      else:
14236 
        iprot.skip(ftype)
14237 
      iprot.readFieldEnd()
14238 
    iprot.readStructEnd()
14239 
 
14240 
  def write(self, oprot):
14241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14243 
      return
2981 rajveer 14244 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 14245 
    if self.userId is not None:
2981 rajveer 14246 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14247 
      oprot.writeI64(self.userId)
1596 ankur.sing 14248 
      oprot.writeFieldEnd()
3431 rajveer 14249 
    if self.itemId is not None:
2981 rajveer 14250 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14251 
      oprot.writeI64(self.itemId)
14252 
      oprot.writeFieldEnd()
1596 ankur.sing 14253 
    oprot.writeFieldStop()
14254 
    oprot.writeStructEnd()
14255 
 
3431 rajveer 14256 
  def validate(self):
14257 
    return
14258 
 
14259 
 
1596 ankur.sing 14260 
  def __repr__(self):
14261 
    L = ['%s=%r' % (key, value)
14262 
      for key, value in self.__dict__.iteritems()]
14263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14264 
 
14265 
  def __eq__(self, other):
14266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14267 
 
14268 
  def __ne__(self, other):
14269 
    return not (self == other)
14270 
 
2981 rajveer 14271 
class deleteItemFromMyResearch_result:
1596 ankur.sing 14272 
  """
14273 
  Attributes:
2981 rajveer 14274 
   - scx
1596 ankur.sing 14275 
  """
14276 
 
14277 
  thrift_spec = (
2981 rajveer 14278 
    None, # 0
14279 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 14280 
  )
14281 
 
2981 rajveer 14282 
  def __init__(self, scx=None,):
14283 
    self.scx = scx
1596 ankur.sing 14284 
 
14285 
  def read(self, iprot):
14286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14288 
      return
14289 
    iprot.readStructBegin()
14290 
    while True:
14291 
      (fname, ftype, fid) = iprot.readFieldBegin()
14292 
      if ftype == TType.STOP:
14293 
        break
2981 rajveer 14294 
      if fid == 1:
14295 
        if ftype == TType.STRUCT:
14296 
          self.scx = WidgetException()
14297 
          self.scx.read(iprot)
1596 ankur.sing 14298 
        else:
14299 
          iprot.skip(ftype)
14300 
      else:
14301 
        iprot.skip(ftype)
14302 
      iprot.readFieldEnd()
14303 
    iprot.readStructEnd()
14304 
 
14305 
  def write(self, oprot):
14306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14308 
      return
2981 rajveer 14309 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 14310 
    if self.scx is not None:
2981 rajveer 14311 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14312 
      self.scx.write(oprot)
1596 ankur.sing 14313 
      oprot.writeFieldEnd()
14314 
    oprot.writeFieldStop()
14315 
    oprot.writeStructEnd()
14316 
 
3431 rajveer 14317 
  def validate(self):
14318 
    return
14319 
 
14320 
 
1596 ankur.sing 14321 
  def __repr__(self):
14322 
    L = ['%s=%r' % (key, value)
14323 
      for key, value in self.__dict__.iteritems()]
14324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14325 
 
14326 
  def __eq__(self, other):
14327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14328 
 
14329 
  def __ne__(self, other):
14330 
    return not (self == other)
14331 
 
2981 rajveer 14332 
class getBrowseHistoryItems_args:
1673 ankur.sing 14333 
  """
14334 
  Attributes:
2981 rajveer 14335 
   - userId
1673 ankur.sing 14336 
  """
1596 ankur.sing 14337 
 
1673 ankur.sing 14338 
  thrift_spec = (
14339 
    None, # 0
2981 rajveer 14340 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 14341 
  )
14342 
 
2981 rajveer 14343 
  def __init__(self, userId=None,):
14344 
    self.userId = userId
1673 ankur.sing 14345 
 
14346 
  def read(self, iprot):
14347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14349 
      return
14350 
    iprot.readStructBegin()
14351 
    while True:
14352 
      (fname, ftype, fid) = iprot.readFieldBegin()
14353 
      if ftype == TType.STOP:
14354 
        break
14355 
      if fid == 1:
1891 ankur.sing 14356 
        if ftype == TType.I64:
2981 rajveer 14357 
          self.userId = iprot.readI64();
1891 ankur.sing 14358 
        else:
14359 
          iprot.skip(ftype)
1673 ankur.sing 14360 
      else:
14361 
        iprot.skip(ftype)
14362 
      iprot.readFieldEnd()
14363 
    iprot.readStructEnd()
14364 
 
14365 
  def write(self, oprot):
14366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14368 
      return
2981 rajveer 14369 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 14370 
    if self.userId is not None:
2981 rajveer 14371 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14372 
      oprot.writeI64(self.userId)
1673 ankur.sing 14373 
      oprot.writeFieldEnd()
14374 
    oprot.writeFieldStop()
14375 
    oprot.writeStructEnd()
14376 
 
3431 rajveer 14377 
  def validate(self):
14378 
    return
14379 
 
14380 
 
1673 ankur.sing 14381 
  def __repr__(self):
14382 
    L = ['%s=%r' % (key, value)
14383 
      for key, value in self.__dict__.iteritems()]
14384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14385 
 
14386 
  def __eq__(self, other):
14387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14388 
 
14389 
  def __ne__(self, other):
14390 
    return not (self == other)
14391 
 
2981 rajveer 14392 
class getBrowseHistoryItems_result:
1673 ankur.sing 14393 
  """
14394 
  Attributes:
14395 
   - success
2981 rajveer 14396 
   - scx
1673 ankur.sing 14397 
  """
14398 
 
14399 
  thrift_spec = (
2981 rajveer 14400 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14401 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 14402 
  )
14403 
 
2981 rajveer 14404 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 14405 
    self.success = success
2981 rajveer 14406 
    self.scx = scx
1673 ankur.sing 14407 
 
14408 
  def read(self, iprot):
14409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14411 
      return
14412 
    iprot.readStructBegin()
14413 
    while True:
14414 
      (fname, ftype, fid) = iprot.readFieldBegin()
14415 
      if ftype == TType.STOP:
14416 
        break
14417 
      if fid == 0:
14418 
        if ftype == TType.LIST:
14419 
          self.success = []
11980 amit.gupta 14420 
          (_etype207, _size204) = iprot.readListBegin()
14421 
          for _i208 in xrange(_size204):
14422 
            _elem209 = iprot.readI64();
14423 
            self.success.append(_elem209)
1673 ankur.sing 14424 
          iprot.readListEnd()
14425 
        else:
14426 
          iprot.skip(ftype)
2981 rajveer 14427 
      elif fid == 1:
14428 
        if ftype == TType.STRUCT:
14429 
          self.scx = WidgetException()
14430 
          self.scx.read(iprot)
14431 
        else:
14432 
          iprot.skip(ftype)
1673 ankur.sing 14433 
      else:
14434 
        iprot.skip(ftype)
14435 
      iprot.readFieldEnd()
14436 
    iprot.readStructEnd()
14437 
 
14438 
  def write(self, oprot):
14439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14441 
      return
2981 rajveer 14442 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 14443 
    if self.success is not None:
1673 ankur.sing 14444 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 14445 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14446 
      for iter210 in self.success:
14447 
        oprot.writeI64(iter210)
1673 ankur.sing 14448 
      oprot.writeListEnd()
14449 
      oprot.writeFieldEnd()
3431 rajveer 14450 
    if self.scx is not None:
2981 rajveer 14451 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14452 
      self.scx.write(oprot)
2642 varun.gupt 14453 
      oprot.writeFieldEnd()
14454 
    oprot.writeFieldStop()
14455 
    oprot.writeStructEnd()
14456 
 
3431 rajveer 14457 
  def validate(self):
14458 
    return
14459 
 
14460 
 
2642 varun.gupt 14461 
  def __repr__(self):
14462 
    L = ['%s=%r' % (key, value)
14463 
      for key, value in self.__dict__.iteritems()]
14464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14465 
 
14466 
  def __eq__(self, other):
14467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14468 
 
14469 
  def __ne__(self, other):
14470 
    return not (self == other)
14471 
 
2981 rajveer 14472 
class updateBrowseHistory_args:
2642 varun.gupt 14473 
  """
14474 
  Attributes:
2981 rajveer 14475 
   - userId
14476 
   - itemId
2642 varun.gupt 14477 
  """
14478 
 
14479 
  thrift_spec = (
14480 
    None, # 0
2981 rajveer 14481 
    (1, TType.I64, 'userId', None, None, ), # 1
14482 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 14483 
  )
14484 
 
2981 rajveer 14485 
  def __init__(self, userId=None, itemId=None,):
14486 
    self.userId = userId
14487 
    self.itemId = itemId
2642 varun.gupt 14488 
 
14489 
  def read(self, iprot):
14490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14492 
      return
14493 
    iprot.readStructBegin()
14494 
    while True:
14495 
      (fname, ftype, fid) = iprot.readFieldBegin()
14496 
      if ftype == TType.STOP:
14497 
        break
14498 
      if fid == 1:
14499 
        if ftype == TType.I64:
2981 rajveer 14500 
          self.userId = iprot.readI64();
2642 varun.gupt 14501 
        else:
14502 
          iprot.skip(ftype)
14503 
      elif fid == 2:
14504 
        if ftype == TType.I64:
2981 rajveer 14505 
          self.itemId = iprot.readI64();
2642 varun.gupt 14506 
        else:
14507 
          iprot.skip(ftype)
14508 
      else:
14509 
        iprot.skip(ftype)
14510 
      iprot.readFieldEnd()
14511 
    iprot.readStructEnd()
14512 
 
14513 
  def write(self, oprot):
14514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14516 
      return
2981 rajveer 14517 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14518 
    if self.userId is not None:
2981 rajveer 14519 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14520 
      oprot.writeI64(self.userId)
2642 varun.gupt 14521 
      oprot.writeFieldEnd()
3431 rajveer 14522 
    if self.itemId is not None:
2981 rajveer 14523 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14524 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14525 
      oprot.writeFieldEnd()
14526 
    oprot.writeFieldStop()
14527 
    oprot.writeStructEnd()
14528 
 
3431 rajveer 14529 
  def validate(self):
14530 
    return
14531 
 
14532 
 
2642 varun.gupt 14533 
  def __repr__(self):
14534 
    L = ['%s=%r' % (key, value)
14535 
      for key, value in self.__dict__.iteritems()]
14536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14537 
 
14538 
  def __eq__(self, other):
14539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14540 
 
14541 
  def __ne__(self, other):
14542 
    return not (self == other)
14543 
 
2981 rajveer 14544 
class updateBrowseHistory_result:
2642 varun.gupt 14545 
 
14546 
  thrift_spec = (
14547 
  )
14548 
 
14549 
  def read(self, iprot):
14550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14552 
      return
14553 
    iprot.readStructBegin()
14554 
    while True:
14555 
      (fname, ftype, fid) = iprot.readFieldBegin()
14556 
      if ftype == TType.STOP:
14557 
        break
14558 
      else:
14559 
        iprot.skip(ftype)
14560 
      iprot.readFieldEnd()
14561 
    iprot.readStructEnd()
14562 
 
14563 
  def write(self, oprot):
14564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14566 
      return
2981 rajveer 14567 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14568 
    oprot.writeFieldStop()
14569 
    oprot.writeStructEnd()
14570 
 
3431 rajveer 14571 
  def validate(self):
14572 
    return
14573 
 
14574 
 
2642 varun.gupt 14575 
  def __repr__(self):
14576 
    L = ['%s=%r' % (key, value)
14577 
      for key, value in self.__dict__.iteritems()]
14578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14579 
 
14580 
  def __eq__(self, other):
14581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14582 
 
14583 
  def __ne__(self, other):
14584 
    return not (self == other)
14585 
 
3385 varun.gupt 14586 
class getCartsWithCouponCount_args:
14587 
  """
14588 
  Attributes:
14589 
   - couponCode
14590 
  """
2642 varun.gupt 14591 
 
3385 varun.gupt 14592 
  thrift_spec = (
14593 
    None, # 0
14594 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14595 
  )
14596 
 
14597 
  def __init__(self, couponCode=None,):
14598 
    self.couponCode = couponCode
14599 
 
14600 
  def read(self, iprot):
14601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14603 
      return
14604 
    iprot.readStructBegin()
14605 
    while True:
14606 
      (fname, ftype, fid) = iprot.readFieldBegin()
14607 
      if ftype == TType.STOP:
14608 
        break
14609 
      if fid == 1:
14610 
        if ftype == TType.STRING:
14611 
          self.couponCode = iprot.readString();
14612 
        else:
14613 
          iprot.skip(ftype)
14614 
      else:
14615 
        iprot.skip(ftype)
14616 
      iprot.readFieldEnd()
14617 
    iprot.readStructEnd()
14618 
 
14619 
  def write(self, oprot):
14620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14622 
      return
14623 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14624 
    if self.couponCode is not None:
3385 varun.gupt 14625 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14626 
      oprot.writeString(self.couponCode)
14627 
      oprot.writeFieldEnd()
14628 
    oprot.writeFieldStop()
14629 
    oprot.writeStructEnd()
14630 
 
3431 rajveer 14631 
  def validate(self):
14632 
    return
14633 
 
14634 
 
3385 varun.gupt 14635 
  def __repr__(self):
14636 
    L = ['%s=%r' % (key, value)
14637 
      for key, value in self.__dict__.iteritems()]
14638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14639 
 
14640 
  def __eq__(self, other):
14641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14642 
 
14643 
  def __ne__(self, other):
14644 
    return not (self == other)
14645 
 
14646 
class getCartsWithCouponCount_result:
14647 
  """
14648 
  Attributes:
14649 
   - success
14650 
  """
14651 
 
14652 
  thrift_spec = (
14653 
    (0, TType.I64, 'success', None, None, ), # 0
14654 
  )
14655 
 
14656 
  def __init__(self, success=None,):
14657 
    self.success = success
14658 
 
14659 
  def read(self, iprot):
14660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14662 
      return
14663 
    iprot.readStructBegin()
14664 
    while True:
14665 
      (fname, ftype, fid) = iprot.readFieldBegin()
14666 
      if ftype == TType.STOP:
14667 
        break
14668 
      if fid == 0:
14669 
        if ftype == TType.I64:
14670 
          self.success = iprot.readI64();
14671 
        else:
14672 
          iprot.skip(ftype)
14673 
      else:
14674 
        iprot.skip(ftype)
14675 
      iprot.readFieldEnd()
14676 
    iprot.readStructEnd()
14677 
 
14678 
  def write(self, oprot):
14679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14681 
      return
14682 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14683 
    if self.success is not None:
3385 varun.gupt 14684 
      oprot.writeFieldBegin('success', TType.I64, 0)
14685 
      oprot.writeI64(self.success)
14686 
      oprot.writeFieldEnd()
14687 
    oprot.writeFieldStop()
14688 
    oprot.writeStructEnd()
14689 
 
3431 rajveer 14690 
  def validate(self):
14691 
    return
14692 
 
14693 
 
3385 varun.gupt 14694 
  def __repr__(self):
14695 
    L = ['%s=%r' % (key, value)
14696 
      for key, value in self.__dict__.iteritems()]
14697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14698 
 
14699 
  def __eq__(self, other):
14700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14701 
 
14702 
  def __ne__(self, other):
14703 
    return not (self == other)
3499 mandeep.dh 14704 
 
14705 
class increaseTrustLevel_args:
14706 
  """
14707 
  Attributes:
14708 
   - userId
14709 
   - trustLevelDelta
14710 
  """
14711 
 
14712 
  thrift_spec = (
14713 
    None, # 0
14714 
    (1, TType.I64, 'userId', None, None, ), # 1
14715 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14716 
  )
14717 
 
14718 
  def __init__(self, userId=None, trustLevelDelta=None,):
14719 
    self.userId = userId
14720 
    self.trustLevelDelta = trustLevelDelta
14721 
 
14722 
  def read(self, iprot):
14723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14725 
      return
14726 
    iprot.readStructBegin()
14727 
    while True:
14728 
      (fname, ftype, fid) = iprot.readFieldBegin()
14729 
      if ftype == TType.STOP:
14730 
        break
14731 
      if fid == 1:
14732 
        if ftype == TType.I64:
14733 
          self.userId = iprot.readI64();
14734 
        else:
14735 
          iprot.skip(ftype)
14736 
      elif fid == 2:
14737 
        if ftype == TType.DOUBLE:
14738 
          self.trustLevelDelta = iprot.readDouble();
14739 
        else:
14740 
          iprot.skip(ftype)
14741 
      else:
14742 
        iprot.skip(ftype)
14743 
      iprot.readFieldEnd()
14744 
    iprot.readStructEnd()
14745 
 
14746 
  def write(self, oprot):
14747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14749 
      return
14750 
    oprot.writeStructBegin('increaseTrustLevel_args')
14751 
    if self.userId is not None:
14752 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14753 
      oprot.writeI64(self.userId)
14754 
      oprot.writeFieldEnd()
14755 
    if self.trustLevelDelta is not None:
14756 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14757 
      oprot.writeDouble(self.trustLevelDelta)
14758 
      oprot.writeFieldEnd()
14759 
    oprot.writeFieldStop()
14760 
    oprot.writeStructEnd()
14761 
 
14762 
  def validate(self):
14763 
    return
14764 
 
14765 
 
14766 
  def __repr__(self):
14767 
    L = ['%s=%r' % (key, value)
14768 
      for key, value in self.__dict__.iteritems()]
14769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14770 
 
14771 
  def __eq__(self, other):
14772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14773 
 
14774 
  def __ne__(self, other):
14775 
    return not (self == other)
4668 varun.gupt 14776 
 
5407 amar.kumar 14777 
class getTrustLevel_args:
14778 
  """
14779 
  Attributes:
14780 
   - userId
14781 
  """
14782 
 
14783 
  thrift_spec = (
14784 
    None, # 0
14785 
    (1, TType.I64, 'userId', None, None, ), # 1
14786 
  )
14787 
 
14788 
  def __init__(self, userId=None,):
14789 
    self.userId = userId
14790 
 
14791 
  def read(self, iprot):
14792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14794 
      return
14795 
    iprot.readStructBegin()
14796 
    while True:
14797 
      (fname, ftype, fid) = iprot.readFieldBegin()
14798 
      if ftype == TType.STOP:
14799 
        break
14800 
      if fid == 1:
14801 
        if ftype == TType.I64:
14802 
          self.userId = iprot.readI64();
14803 
        else:
14804 
          iprot.skip(ftype)
14805 
      else:
14806 
        iprot.skip(ftype)
14807 
      iprot.readFieldEnd()
14808 
    iprot.readStructEnd()
14809 
 
14810 
  def write(self, oprot):
14811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14813 
      return
14814 
    oprot.writeStructBegin('getTrustLevel_args')
14815 
    if self.userId is not None:
14816 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14817 
      oprot.writeI64(self.userId)
14818 
      oprot.writeFieldEnd()
14819 
    oprot.writeFieldStop()
14820 
    oprot.writeStructEnd()
14821 
 
14822 
  def validate(self):
14823 
    return
14824 
 
14825 
 
14826 
  def __repr__(self):
14827 
    L = ['%s=%r' % (key, value)
14828 
      for key, value in self.__dict__.iteritems()]
14829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14830 
 
14831 
  def __eq__(self, other):
14832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14833 
 
14834 
  def __ne__(self, other):
14835 
    return not (self == other)
14836 
 
14837 
class getTrustLevel_result:
14838 
  """
14839 
  Attributes:
14840 
   - success
14841 
  """
14842 
 
14843 
  thrift_spec = (
14844 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14845 
  )
14846 
 
14847 
  def __init__(self, success=None,):
14848 
    self.success = success
14849 
 
14850 
  def read(self, iprot):
14851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14853 
      return
14854 
    iprot.readStructBegin()
14855 
    while True:
14856 
      (fname, ftype, fid) = iprot.readFieldBegin()
14857 
      if ftype == TType.STOP:
14858 
        break
14859 
      if fid == 0:
14860 
        if ftype == TType.DOUBLE:
14861 
          self.success = iprot.readDouble();
14862 
        else:
14863 
          iprot.skip(ftype)
14864 
      else:
14865 
        iprot.skip(ftype)
14866 
      iprot.readFieldEnd()
14867 
    iprot.readStructEnd()
14868 
 
14869 
  def write(self, oprot):
14870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14872 
      return
14873 
    oprot.writeStructBegin('getTrustLevel_result')
14874 
    if self.success is not None:
14875 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14876 
      oprot.writeDouble(self.success)
14877 
      oprot.writeFieldEnd()
14878 
    oprot.writeFieldStop()
14879 
    oprot.writeStructEnd()
14880 
 
14881 
  def validate(self):
14882 
    return
14883 
 
14884 
 
14885 
  def __repr__(self):
14886 
    L = ['%s=%r' % (key, value)
14887 
      for key, value in self.__dict__.iteritems()]
14888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14889 
 
14890 
  def __eq__(self, other):
14891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14892 
 
14893 
  def __ne__(self, other):
14894 
    return not (self == other)
14895 
 
4668 varun.gupt 14896 
class showCODOption_args:
14897 
  """
14898 
  Attributes:
14899 
   - cartId
14900 
   - sourceId
14901 
   - pincode
14902 
  """
14903 
 
14904 
  thrift_spec = (
14905 
    None, # 0
14906 
    (1, TType.I64, 'cartId', None, None, ), # 1
14907 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14908 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14909 
  )
14910 
 
14911 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14912 
    self.cartId = cartId
14913 
    self.sourceId = sourceId
14914 
    self.pincode = pincode
14915 
 
14916 
  def read(self, iprot):
14917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14919 
      return
14920 
    iprot.readStructBegin()
14921 
    while True:
14922 
      (fname, ftype, fid) = iprot.readFieldBegin()
14923 
      if ftype == TType.STOP:
14924 
        break
14925 
      if fid == 1:
14926 
        if ftype == TType.I64:
14927 
          self.cartId = iprot.readI64();
14928 
        else:
14929 
          iprot.skip(ftype)
14930 
      elif fid == 2:
14931 
        if ftype == TType.I64:
14932 
          self.sourceId = iprot.readI64();
14933 
        else:
14934 
          iprot.skip(ftype)
14935 
      elif fid == 3:
14936 
        if ftype == TType.STRING:
14937 
          self.pincode = iprot.readString();
14938 
        else:
14939 
          iprot.skip(ftype)
14940 
      else:
14941 
        iprot.skip(ftype)
14942 
      iprot.readFieldEnd()
14943 
    iprot.readStructEnd()
14944 
 
14945 
  def write(self, oprot):
14946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14948 
      return
14949 
    oprot.writeStructBegin('showCODOption_args')
14950 
    if self.cartId is not None:
14951 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14952 
      oprot.writeI64(self.cartId)
14953 
      oprot.writeFieldEnd()
14954 
    if self.sourceId is not None:
14955 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14956 
      oprot.writeI64(self.sourceId)
14957 
      oprot.writeFieldEnd()
14958 
    if self.pincode is not None:
14959 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14960 
      oprot.writeString(self.pincode)
14961 
      oprot.writeFieldEnd()
14962 
    oprot.writeFieldStop()
14963 
    oprot.writeStructEnd()
14964 
 
14965 
  def validate(self):
14966 
    return
14967 
 
14968 
 
14969 
  def __repr__(self):
14970 
    L = ['%s=%r' % (key, value)
14971 
      for key, value in self.__dict__.iteritems()]
14972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14973 
 
14974 
  def __eq__(self, other):
14975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14976 
 
14977 
  def __ne__(self, other):
14978 
    return not (self == other)
14979 
 
14980 
class showCODOption_result:
14981 
  """
14982 
  Attributes:
14983 
   - success
14984 
  """
14985 
 
14986 
  thrift_spec = (
14987 
    (0, TType.BOOL, 'success', None, None, ), # 0
14988 
  )
14989 
 
14990 
  def __init__(self, success=None,):
14991 
    self.success = success
14992 
 
14993 
  def read(self, iprot):
14994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14996 
      return
14997 
    iprot.readStructBegin()
14998 
    while True:
14999 
      (fname, ftype, fid) = iprot.readFieldBegin()
15000 
      if ftype == TType.STOP:
15001 
        break
15002 
      if fid == 0:
15003 
        if ftype == TType.BOOL:
15004 
          self.success = iprot.readBool();
15005 
        else:
15006 
          iprot.skip(ftype)
15007 
      else:
15008 
        iprot.skip(ftype)
15009 
      iprot.readFieldEnd()
15010 
    iprot.readStructEnd()
15011 
 
15012 
  def write(self, oprot):
15013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15015 
      return
15016 
    oprot.writeStructBegin('showCODOption_result')
15017 
    if self.success is not None:
15018 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15019 
      oprot.writeBool(self.success)
15020 
      oprot.writeFieldEnd()
15021 
    oprot.writeFieldStop()
15022 
    oprot.writeStructEnd()
15023 
 
15024 
  def validate(self):
15025 
    return
15026 
 
15027 
 
15028 
  def __repr__(self):
15029 
    L = ['%s=%r' % (key, value)
15030 
      for key, value in self.__dict__.iteritems()]
15031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15032 
 
15033 
  def __eq__(self, other):
15034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15035 
 
15036 
  def __ne__(self, other):
15037 
    return not (self == other)
5623 anupam.sin 15038 
 
15039 
class getUserEmails_args:
15040 
  """
15041 
  Attributes:
15042 
   - startDate
15043 
   - endDate
15044 
  """
15045 
 
15046 
  thrift_spec = (
15047 
    None, # 0
15048 
    (1, TType.I64, 'startDate', None, None, ), # 1
15049 
    (2, TType.I64, 'endDate', None, None, ), # 2
15050 
  )
15051 
 
15052 
  def __init__(self, startDate=None, endDate=None,):
15053 
    self.startDate = startDate
15054 
    self.endDate = endDate
15055 
 
15056 
  def read(self, iprot):
15057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15059 
      return
15060 
    iprot.readStructBegin()
15061 
    while True:
15062 
      (fname, ftype, fid) = iprot.readFieldBegin()
15063 
      if ftype == TType.STOP:
15064 
        break
15065 
      if fid == 1:
15066 
        if ftype == TType.I64:
15067 
          self.startDate = iprot.readI64();
15068 
        else:
15069 
          iprot.skip(ftype)
15070 
      elif fid == 2:
15071 
        if ftype == TType.I64:
15072 
          self.endDate = iprot.readI64();
15073 
        else:
15074 
          iprot.skip(ftype)
15075 
      else:
15076 
        iprot.skip(ftype)
15077 
      iprot.readFieldEnd()
15078 
    iprot.readStructEnd()
15079 
 
15080 
  def write(self, oprot):
15081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15083 
      return
15084 
    oprot.writeStructBegin('getUserEmails_args')
15085 
    if self.startDate is not None:
15086 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
15087 
      oprot.writeI64(self.startDate)
15088 
      oprot.writeFieldEnd()
15089 
    if self.endDate is not None:
15090 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
15091 
      oprot.writeI64(self.endDate)
15092 
      oprot.writeFieldEnd()
15093 
    oprot.writeFieldStop()
15094 
    oprot.writeStructEnd()
15095 
 
15096 
  def validate(self):
15097 
    return
15098 
 
15099 
 
15100 
  def __repr__(self):
15101 
    L = ['%s=%r' % (key, value)
15102 
      for key, value in self.__dict__.iteritems()]
15103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15104 
 
15105 
  def __eq__(self, other):
15106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15107 
 
15108 
  def __ne__(self, other):
15109 
    return not (self == other)
15110 
 
15111 
class getUserEmails_result:
15112 
  """
15113 
  Attributes:
15114 
   - success
15115 
  """
15116 
 
15117 
  thrift_spec = (
15118 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15119 
  )
15120 
 
15121 
  def __init__(self, success=None,):
15122 
    self.success = success
15123 
 
15124 
  def read(self, iprot):
15125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15127 
      return
15128 
    iprot.readStructBegin()
15129 
    while True:
15130 
      (fname, ftype, fid) = iprot.readFieldBegin()
15131 
      if ftype == TType.STOP:
15132 
        break
15133 
      if fid == 0:
15134 
        if ftype == TType.LIST:
15135 
          self.success = []
11980 amit.gupta 15136 
          (_etype214, _size211) = iprot.readListBegin()
15137 
          for _i215 in xrange(_size211):
15138 
            _elem216 = iprot.readString();
15139 
            self.success.append(_elem216)
5623 anupam.sin 15140 
          iprot.readListEnd()
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('getUserEmails_result')
15153 
    if self.success is not None:
15154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15155 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 15156 
      for iter217 in self.success:
15157 
        oprot.writeString(iter217)
5623 anupam.sin 15158 
      oprot.writeListEnd()
15159 
      oprot.writeFieldEnd()
15160 
    oprot.writeFieldStop()
15161 
    oprot.writeStructEnd()
15162 
 
15163 
  def validate(self):
15164 
    return
15165 
 
15166 
 
15167 
  def __repr__(self):
15168 
    L = ['%s=%r' % (key, value)
15169 
      for key, value in self.__dict__.iteritems()]
15170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15171 
 
15172 
  def __eq__(self, other):
15173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15174 
 
15175 
  def __ne__(self, other):
15176 
    return not (self == other)
6821 amar.kumar 15177 
 
6903 anupam.sin 15178 
class insureItem_args:
15179 
  """
15180 
  Attributes:
15181 
   - itemId
15182 
   - cartId
15183 
   - toInsure
9299 kshitij.so 15184 
   - insurerType
6903 anupam.sin 15185 
  """
15186 
 
15187 
  thrift_spec = (
15188 
    None, # 0
15189 
    (1, TType.I64, 'itemId', None, None, ), # 1
15190 
    (2, TType.I64, 'cartId', None, None, ), # 2
15191 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 15192 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 15193 
  )
15194 
 
9299 kshitij.so 15195 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 15196 
    self.itemId = itemId
15197 
    self.cartId = cartId
15198 
    self.toInsure = toInsure
9299 kshitij.so 15199 
    self.insurerType = insurerType
6903 anupam.sin 15200 
 
15201 
  def read(self, iprot):
15202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15204 
      return
15205 
    iprot.readStructBegin()
15206 
    while True:
15207 
      (fname, ftype, fid) = iprot.readFieldBegin()
15208 
      if ftype == TType.STOP:
15209 
        break
15210 
      if fid == 1:
15211 
        if ftype == TType.I64:
15212 
          self.itemId = iprot.readI64();
15213 
        else:
15214 
          iprot.skip(ftype)
15215 
      elif fid == 2:
15216 
        if ftype == TType.I64:
15217 
          self.cartId = iprot.readI64();
15218 
        else:
15219 
          iprot.skip(ftype)
15220 
      elif fid == 3:
15221 
        if ftype == TType.BOOL:
15222 
          self.toInsure = iprot.readBool();
15223 
        else:
15224 
          iprot.skip(ftype)
9299 kshitij.so 15225 
      elif fid == 4:
15226 
        if ftype == TType.I32:
15227 
          self.insurerType = iprot.readI32();
15228 
        else:
15229 
          iprot.skip(ftype)
6903 anupam.sin 15230 
      else:
15231 
        iprot.skip(ftype)
15232 
      iprot.readFieldEnd()
15233 
    iprot.readStructEnd()
15234 
 
15235 
  def write(self, oprot):
15236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15238 
      return
15239 
    oprot.writeStructBegin('insureItem_args')
15240 
    if self.itemId is not None:
15241 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15242 
      oprot.writeI64(self.itemId)
15243 
      oprot.writeFieldEnd()
15244 
    if self.cartId is not None:
15245 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
15246 
      oprot.writeI64(self.cartId)
15247 
      oprot.writeFieldEnd()
15248 
    if self.toInsure is not None:
15249 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
15250 
      oprot.writeBool(self.toInsure)
15251 
      oprot.writeFieldEnd()
9299 kshitij.so 15252 
    if self.insurerType is not None:
15253 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
15254 
      oprot.writeI32(self.insurerType)
15255 
      oprot.writeFieldEnd()
6903 anupam.sin 15256 
    oprot.writeFieldStop()
15257 
    oprot.writeStructEnd()
15258 
 
15259 
  def validate(self):
15260 
    return
15261 
 
15262 
 
15263 
  def __repr__(self):
15264 
    L = ['%s=%r' % (key, value)
15265 
      for key, value in self.__dict__.iteritems()]
15266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15267 
 
15268 
  def __eq__(self, other):
15269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15270 
 
15271 
  def __ne__(self, other):
15272 
    return not (self == other)
15273 
 
15274 
class insureItem_result:
15275 
  """
15276 
  Attributes:
15277 
   - success
15278 
  """
15279 
 
15280 
  thrift_spec = (
15281 
    (0, TType.BOOL, 'success', None, None, ), # 0
15282 
  )
15283 
 
15284 
  def __init__(self, success=None,):
15285 
    self.success = success
15286 
 
15287 
  def read(self, iprot):
15288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15290 
      return
15291 
    iprot.readStructBegin()
15292 
    while True:
15293 
      (fname, ftype, fid) = iprot.readFieldBegin()
15294 
      if ftype == TType.STOP:
15295 
        break
15296 
      if fid == 0:
15297 
        if ftype == TType.BOOL:
15298 
          self.success = iprot.readBool();
15299 
        else:
15300 
          iprot.skip(ftype)
15301 
      else:
15302 
        iprot.skip(ftype)
15303 
      iprot.readFieldEnd()
15304 
    iprot.readStructEnd()
15305 
 
15306 
  def write(self, oprot):
15307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15309 
      return
15310 
    oprot.writeStructBegin('insureItem_result')
15311 
    if self.success is not None:
15312 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15313 
      oprot.writeBool(self.success)
15314 
      oprot.writeFieldEnd()
15315 
    oprot.writeFieldStop()
15316 
    oprot.writeStructEnd()
15317 
 
15318 
  def validate(self):
15319 
    return
15320 
 
15321 
 
15322 
  def __repr__(self):
15323 
    L = ['%s=%r' % (key, value)
15324 
      for key, value in self.__dict__.iteritems()]
15325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15326 
 
15327 
  def __eq__(self, other):
15328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15329 
 
15330 
  def __ne__(self, other):
15331 
    return not (self == other)
15332 
 
15333 
class cancelInsurance_args:
15334 
  """
15335 
  Attributes:
15336 
   - cartId
15337 
  """
15338 
 
15339 
  thrift_spec = (
15340 
    None, # 0
15341 
    (1, TType.I64, 'cartId', None, None, ), # 1
15342 
  )
15343 
 
15344 
  def __init__(self, cartId=None,):
15345 
    self.cartId = cartId
15346 
 
15347 
  def read(self, iprot):
15348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15350 
      return
15351 
    iprot.readStructBegin()
15352 
    while True:
15353 
      (fname, ftype, fid) = iprot.readFieldBegin()
15354 
      if ftype == TType.STOP:
15355 
        break
15356 
      if fid == 1:
15357 
        if ftype == TType.I64:
15358 
          self.cartId = iprot.readI64();
15359 
        else:
15360 
          iprot.skip(ftype)
15361 
      else:
15362 
        iprot.skip(ftype)
15363 
      iprot.readFieldEnd()
15364 
    iprot.readStructEnd()
15365 
 
15366 
  def write(self, oprot):
15367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15369 
      return
15370 
    oprot.writeStructBegin('cancelInsurance_args')
15371 
    if self.cartId is not None:
15372 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15373 
      oprot.writeI64(self.cartId)
15374 
      oprot.writeFieldEnd()
15375 
    oprot.writeFieldStop()
15376 
    oprot.writeStructEnd()
15377 
 
15378 
  def validate(self):
15379 
    return
15380 
 
15381 
 
15382 
  def __repr__(self):
15383 
    L = ['%s=%r' % (key, value)
15384 
      for key, value in self.__dict__.iteritems()]
15385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15386 
 
15387 
  def __eq__(self, other):
15388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15389 
 
15390 
  def __ne__(self, other):
15391 
    return not (self == other)
15392 
 
15393 
class cancelInsurance_result:
15394 
  """
15395 
  Attributes:
15396 
   - success
15397 
  """
15398 
 
15399 
  thrift_spec = (
15400 
    (0, TType.BOOL, 'success', None, None, ), # 0
15401 
  )
15402 
 
15403 
  def __init__(self, success=None,):
15404 
    self.success = success
15405 
 
15406 
  def read(self, iprot):
15407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15409 
      return
15410 
    iprot.readStructBegin()
15411 
    while True:
15412 
      (fname, ftype, fid) = iprot.readFieldBegin()
15413 
      if ftype == TType.STOP:
15414 
        break
15415 
      if fid == 0:
15416 
        if ftype == TType.BOOL:
15417 
          self.success = iprot.readBool();
15418 
        else:
15419 
          iprot.skip(ftype)
15420 
      else:
15421 
        iprot.skip(ftype)
15422 
      iprot.readFieldEnd()
15423 
    iprot.readStructEnd()
15424 
 
15425 
  def write(self, oprot):
15426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15428 
      return
15429 
    oprot.writeStructBegin('cancelInsurance_result')
15430 
    if self.success is not None:
15431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15432 
      oprot.writeBool(self.success)
15433 
      oprot.writeFieldEnd()
15434 
    oprot.writeFieldStop()
15435 
    oprot.writeStructEnd()
15436 
 
15437 
  def validate(self):
15438 
    return
15439 
 
15440 
 
15441 
  def __repr__(self):
15442 
    L = ['%s=%r' % (key, value)
15443 
      for key, value in self.__dict__.iteritems()]
15444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15445 
 
15446 
  def __eq__(self, other):
15447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15448 
 
15449 
  def __ne__(self, other):
15450 
    return not (self == other)
15451 
 
15452 
class storeInsuranceSpecificDetails_args:
15453 
  """
15454 
  Attributes:
15455 
   - addressId
15456 
   - dob
15457 
   - guardianName
15458 
  """
15459 
 
15460 
  thrift_spec = (
15461 
    None, # 0
15462 
    (1, TType.I64, 'addressId', None, None, ), # 1
15463 
    (2, TType.STRING, 'dob', None, None, ), # 2
15464 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
15465 
  )
15466 
 
15467 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
15468 
    self.addressId = addressId
15469 
    self.dob = dob
15470 
    self.guardianName = guardianName
15471 
 
15472 
  def read(self, iprot):
15473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15475 
      return
15476 
    iprot.readStructBegin()
15477 
    while True:
15478 
      (fname, ftype, fid) = iprot.readFieldBegin()
15479 
      if ftype == TType.STOP:
15480 
        break
15481 
      if fid == 1:
15482 
        if ftype == TType.I64:
15483 
          self.addressId = iprot.readI64();
15484 
        else:
15485 
          iprot.skip(ftype)
15486 
      elif fid == 2:
15487 
        if ftype == TType.STRING:
15488 
          self.dob = iprot.readString();
15489 
        else:
15490 
          iprot.skip(ftype)
15491 
      elif fid == 3:
15492 
        if ftype == TType.STRING:
15493 
          self.guardianName = iprot.readString();
15494 
        else:
15495 
          iprot.skip(ftype)
15496 
      else:
15497 
        iprot.skip(ftype)
15498 
      iprot.readFieldEnd()
15499 
    iprot.readStructEnd()
15500 
 
15501 
  def write(self, oprot):
15502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15504 
      return
15505 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15506 
    if self.addressId is not None:
15507 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15508 
      oprot.writeI64(self.addressId)
15509 
      oprot.writeFieldEnd()
15510 
    if self.dob is not None:
15511 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15512 
      oprot.writeString(self.dob)
15513 
      oprot.writeFieldEnd()
15514 
    if self.guardianName is not None:
15515 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15516 
      oprot.writeString(self.guardianName)
15517 
      oprot.writeFieldEnd()
15518 
    oprot.writeFieldStop()
15519 
    oprot.writeStructEnd()
15520 
 
15521 
  def validate(self):
15522 
    return
15523 
 
15524 
 
15525 
  def __repr__(self):
15526 
    L = ['%s=%r' % (key, value)
15527 
      for key, value in self.__dict__.iteritems()]
15528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15529 
 
15530 
  def __eq__(self, other):
15531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15532 
 
15533 
  def __ne__(self, other):
15534 
    return not (self == other)
15535 
 
15536 
class storeInsuranceSpecificDetails_result:
15537 
  """
15538 
  Attributes:
15539 
   - success
15540 
  """
15541 
 
15542 
  thrift_spec = (
15543 
    (0, TType.BOOL, 'success', None, None, ), # 0
15544 
  )
15545 
 
15546 
  def __init__(self, success=None,):
15547 
    self.success = success
15548 
 
15549 
  def read(self, iprot):
15550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15552 
      return
15553 
    iprot.readStructBegin()
15554 
    while True:
15555 
      (fname, ftype, fid) = iprot.readFieldBegin()
15556 
      if ftype == TType.STOP:
15557 
        break
15558 
      if fid == 0:
15559 
        if ftype == TType.BOOL:
15560 
          self.success = iprot.readBool();
15561 
        else:
15562 
          iprot.skip(ftype)
15563 
      else:
15564 
        iprot.skip(ftype)
15565 
      iprot.readFieldEnd()
15566 
    iprot.readStructEnd()
15567 
 
15568 
  def write(self, oprot):
15569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15571 
      return
15572 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15573 
    if self.success is not None:
15574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15575 
      oprot.writeBool(self.success)
15576 
      oprot.writeFieldEnd()
15577 
    oprot.writeFieldStop()
15578 
    oprot.writeStructEnd()
15579 
 
15580 
  def validate(self):
15581 
    return
15582 
 
15583 
 
15584 
  def __repr__(self):
15585 
    L = ['%s=%r' % (key, value)
15586 
      for key, value in self.__dict__.iteritems()]
15587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15588 
 
15589 
  def __eq__(self, other):
15590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15591 
 
15592 
  def __ne__(self, other):
15593 
    return not (self == other)
15594 
 
15595 
class isInsuranceDetailPresent_args:
15596 
  """
15597 
  Attributes:
15598 
   - addressId
15599 
  """
15600 
 
15601 
  thrift_spec = (
15602 
    None, # 0
15603 
    (1, TType.I64, 'addressId', None, None, ), # 1
15604 
  )
15605 
 
15606 
  def __init__(self, addressId=None,):
15607 
    self.addressId = addressId
15608 
 
15609 
  def read(self, iprot):
15610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15612 
      return
15613 
    iprot.readStructBegin()
15614 
    while True:
15615 
      (fname, ftype, fid) = iprot.readFieldBegin()
15616 
      if ftype == TType.STOP:
15617 
        break
15618 
      if fid == 1:
15619 
        if ftype == TType.I64:
15620 
          self.addressId = iprot.readI64();
15621 
        else:
15622 
          iprot.skip(ftype)
15623 
      else:
15624 
        iprot.skip(ftype)
15625 
      iprot.readFieldEnd()
15626 
    iprot.readStructEnd()
15627 
 
15628 
  def write(self, oprot):
15629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15631 
      return
15632 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15633 
    if self.addressId is not None:
15634 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15635 
      oprot.writeI64(self.addressId)
15636 
      oprot.writeFieldEnd()
15637 
    oprot.writeFieldStop()
15638 
    oprot.writeStructEnd()
15639 
 
15640 
  def validate(self):
15641 
    return
15642 
 
15643 
 
15644 
  def __repr__(self):
15645 
    L = ['%s=%r' % (key, value)
15646 
      for key, value in self.__dict__.iteritems()]
15647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15648 
 
15649 
  def __eq__(self, other):
15650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15651 
 
15652 
  def __ne__(self, other):
15653 
    return not (self == other)
15654 
 
15655 
class isInsuranceDetailPresent_result:
15656 
  """
15657 
  Attributes:
15658 
   - success
15659 
  """
15660 
 
15661 
  thrift_spec = (
15662 
    (0, TType.BOOL, 'success', None, None, ), # 0
15663 
  )
15664 
 
15665 
  def __init__(self, success=None,):
15666 
    self.success = success
15667 
 
15668 
  def read(self, iprot):
15669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15671 
      return
15672 
    iprot.readStructBegin()
15673 
    while True:
15674 
      (fname, ftype, fid) = iprot.readFieldBegin()
15675 
      if ftype == TType.STOP:
15676 
        break
15677 
      if fid == 0:
15678 
        if ftype == TType.BOOL:
15679 
          self.success = iprot.readBool();
15680 
        else:
15681 
          iprot.skip(ftype)
15682 
      else:
15683 
        iprot.skip(ftype)
15684 
      iprot.readFieldEnd()
15685 
    iprot.readStructEnd()
15686 
 
15687 
  def write(self, oprot):
15688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15690 
      return
15691 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15692 
    if self.success is not None:
15693 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15694 
      oprot.writeBool(self.success)
15695 
      oprot.writeFieldEnd()
15696 
    oprot.writeFieldStop()
15697 
    oprot.writeStructEnd()
15698 
 
15699 
  def validate(self):
15700 
    return
15701 
 
15702 
 
15703 
  def __repr__(self):
15704 
    L = ['%s=%r' % (key, value)
15705 
      for key, value in self.__dict__.iteritems()]
15706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15707 
 
15708 
  def __eq__(self, other):
15709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15710 
 
15711 
  def __ne__(self, other):
15712 
    return not (self == other)
15713 
 
9791 rajveer 15714 
class getProductsAddedToCart_args:
6821 amar.kumar 15715 
  """
15716 
  Attributes:
15717 
   - startDate
15718 
   - endDate
15719 
  """
15720 
 
15721 
  thrift_spec = (
15722 
    None, # 0
9791 rajveer 15723 
    (1, TType.I64, 'startDate', None, None, ), # 1
15724 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15725 
  )
15726 
 
9791 rajveer 15727 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15728 
    self.startDate = startDate
15729 
    self.endDate = endDate
15730 
 
15731 
  def read(self, iprot):
15732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15734 
      return
15735 
    iprot.readStructBegin()
15736 
    while True:
15737 
      (fname, ftype, fid) = iprot.readFieldBegin()
15738 
      if ftype == TType.STOP:
15739 
        break
15740 
      if fid == 1:
15741 
        if ftype == TType.I64:
9791 rajveer 15742 
          self.startDate = iprot.readI64();
6821 amar.kumar 15743 
        else:
15744 
          iprot.skip(ftype)
15745 
      elif fid == 2:
15746 
        if ftype == TType.I64:
15747 
          self.endDate = iprot.readI64();
15748 
        else:
15749 
          iprot.skip(ftype)
15750 
      else:
15751 
        iprot.skip(ftype)
15752 
      iprot.readFieldEnd()
15753 
    iprot.readStructEnd()
15754 
 
15755 
  def write(self, oprot):
15756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15758 
      return
9791 rajveer 15759 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15760 
    if self.startDate is not None:
9791 rajveer 15761 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15762 
      oprot.writeI64(self.startDate)
15763 
      oprot.writeFieldEnd()
15764 
    if self.endDate is not None:
9791 rajveer 15765 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15766 
      oprot.writeI64(self.endDate)
15767 
      oprot.writeFieldEnd()
15768 
    oprot.writeFieldStop()
15769 
    oprot.writeStructEnd()
15770 
 
15771 
  def validate(self):
15772 
    return
15773 
 
15774 
 
15775 
  def __repr__(self):
15776 
    L = ['%s=%r' % (key, value)
15777 
      for key, value in self.__dict__.iteritems()]
15778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15779 
 
15780 
  def __eq__(self, other):
15781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15782 
 
15783 
  def __ne__(self, other):
15784 
    return not (self == other)
15785 
 
9791 rajveer 15786 
class getProductsAddedToCart_result:
6821 amar.kumar 15787 
  """
15788 
  Attributes:
15789 
   - success
15790 
  """
15791 
 
15792 
  thrift_spec = (
9791 rajveer 15793 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15794 
  )
15795 
 
15796 
  def __init__(self, success=None,):
15797 
    self.success = success
15798 
 
15799 
  def read(self, iprot):
15800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15802 
      return
15803 
    iprot.readStructBegin()
15804 
    while True:
15805 
      (fname, ftype, fid) = iprot.readFieldBegin()
15806 
      if ftype == TType.STOP:
15807 
        break
15808 
      if fid == 0:
9791 rajveer 15809 
        if ftype == TType.LIST:
15810 
          self.success = []
11980 amit.gupta 15811 
          (_etype221, _size218) = iprot.readListBegin()
15812 
          for _i222 in xrange(_size218):
15813 
            _elem223 = iprot.readI64();
15814 
            self.success.append(_elem223)
9791 rajveer 15815 
          iprot.readListEnd()
6821 amar.kumar 15816 
        else:
15817 
          iprot.skip(ftype)
15818 
      else:
15819 
        iprot.skip(ftype)
15820 
      iprot.readFieldEnd()
15821 
    iprot.readStructEnd()
15822 
 
15823 
  def write(self, oprot):
15824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15826 
      return
9791 rajveer 15827 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15828 
    if self.success is not None:
9791 rajveer 15829 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15830 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15831 
      for iter224 in self.success:
15832 
        oprot.writeI64(iter224)
9791 rajveer 15833 
      oprot.writeListEnd()
6821 amar.kumar 15834 
      oprot.writeFieldEnd()
15835 
    oprot.writeFieldStop()
15836 
    oprot.writeStructEnd()
15837 
 
15838 
  def validate(self):
15839 
    return
15840 
 
15841 
 
15842 
  def __repr__(self):
15843 
    L = ['%s=%r' % (key, value)
15844 
      for key, value in self.__dict__.iteritems()]
15845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15846 
 
15847 
  def __eq__(self, other):
15848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15849 
 
15850 
  def __ne__(self, other):
15851 
    return not (self == other)
11592 amit.gupta 15852 
 
15853 
class validateCartPlus_args:
15854 
  """
15855 
  Attributes:
15856 
   - cartId
15857 
   - sourceId
11980 amit.gupta 15858 
   - dealerCoupon
11592 amit.gupta 15859 
  """
15860 
 
15861 
  thrift_spec = (
15862 
    None, # 0
15863 
    (1, TType.I64, 'cartId', None, None, ), # 1
15864 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15865 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15866 
  )
15867 
 
11980 amit.gupta 15868 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15869 
    self.cartId = cartId
15870 
    self.sourceId = sourceId
11980 amit.gupta 15871 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15872 
 
15873 
  def read(self, iprot):
15874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15876 
      return
15877 
    iprot.readStructBegin()
15878 
    while True:
15879 
      (fname, ftype, fid) = iprot.readFieldBegin()
15880 
      if ftype == TType.STOP:
15881 
        break
15882 
      if fid == 1:
15883 
        if ftype == TType.I64:
15884 
          self.cartId = iprot.readI64();
15885 
        else:
15886 
          iprot.skip(ftype)
15887 
      elif fid == 2:
15888 
        if ftype == TType.I64:
15889 
          self.sourceId = iprot.readI64();
15890 
        else:
15891 
          iprot.skip(ftype)
11980 amit.gupta 15892 
      elif fid == 3:
15893 
        if ftype == TType.STRING:
15894 
          self.dealerCoupon = iprot.readString();
15895 
        else:
15896 
          iprot.skip(ftype)
11592 amit.gupta 15897 
      else:
15898 
        iprot.skip(ftype)
15899 
      iprot.readFieldEnd()
15900 
    iprot.readStructEnd()
15901 
 
15902 
  def write(self, oprot):
15903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15905 
      return
15906 
    oprot.writeStructBegin('validateCartPlus_args')
15907 
    if self.cartId is not None:
15908 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15909 
      oprot.writeI64(self.cartId)
15910 
      oprot.writeFieldEnd()
15911 
    if self.sourceId is not None:
15912 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15913 
      oprot.writeI64(self.sourceId)
15914 
      oprot.writeFieldEnd()
11980 amit.gupta 15915 
    if self.dealerCoupon is not None:
15916 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15917 
      oprot.writeString(self.dealerCoupon)
15918 
      oprot.writeFieldEnd()
11592 amit.gupta 15919 
    oprot.writeFieldStop()
15920 
    oprot.writeStructEnd()
15921 
 
15922 
  def validate(self):
15923 
    return
15924 
 
15925 
 
15926 
  def __repr__(self):
15927 
    L = ['%s=%r' % (key, value)
15928 
      for key, value in self.__dict__.iteritems()]
15929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15930 
 
15931 
  def __eq__(self, other):
15932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15933 
 
15934 
  def __ne__(self, other):
15935 
    return not (self == other)
15936 
 
15937 
class validateCartPlus_result:
15938 
  """
15939 
  Attributes:
15940 
   - success
15941 
   - scex
15942 
  """
15943 
 
15944 
  thrift_spec = (
15945 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15946 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15947 
  )
15948 
 
15949 
  def __init__(self, success=None, scex=None,):
15950 
    self.success = success
15951 
    self.scex = scex
15952 
 
15953 
  def read(self, iprot):
15954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15956 
      return
15957 
    iprot.readStructBegin()
15958 
    while True:
15959 
      (fname, ftype, fid) = iprot.readFieldBegin()
15960 
      if ftype == TType.STOP:
15961 
        break
15962 
      if fid == 0:
15963 
        if ftype == TType.STRUCT:
15964 
          self.success = CartPlus()
15965 
          self.success.read(iprot)
15966 
        else:
15967 
          iprot.skip(ftype)
15968 
      elif fid == 1:
15969 
        if ftype == TType.STRUCT:
15970 
          self.scex = ShoppingCartException()
15971 
          self.scex.read(iprot)
15972 
        else:
15973 
          iprot.skip(ftype)
15974 
      else:
15975 
        iprot.skip(ftype)
15976 
      iprot.readFieldEnd()
15977 
    iprot.readStructEnd()
15978 
 
15979 
  def write(self, oprot):
15980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15982 
      return
15983 
    oprot.writeStructBegin('validateCartPlus_result')
15984 
    if self.success is not None:
15985 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15986 
      self.success.write(oprot)
15987 
      oprot.writeFieldEnd()
15988 
    if self.scex is not None:
15989 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15990 
      self.scex.write(oprot)
15991 
      oprot.writeFieldEnd()
15992 
    oprot.writeFieldStop()
15993 
    oprot.writeStructEnd()
15994 
 
15995 
  def validate(self):
15996 
    return
15997 
 
15998 
 
15999 
  def __repr__(self):
16000 
    L = ['%s=%r' % (key, value)
16001 
      for key, value in self.__dict__.iteritems()]
16002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16003 
 
16004 
  def __eq__(self, other):
16005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16006 
 
16007 
  def __ne__(self, other):
16008 
    return not (self == other)
11679 vikram.rag 16009 
 
16010 
class isPrivateDealUser_args:
16011 
  """
16012 
  Attributes:
16013 
   - userId
16014 
  """
16015 
 
16016 
  thrift_spec = (
16017 
    None, # 0
16018 
    (1, TType.I64, 'userId', None, None, ), # 1
16019 
  )
16020 
 
16021 
  def __init__(self, userId=None,):
16022 
    self.userId = userId
16023 
 
16024 
  def read(self, iprot):
16025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16027 
      return
16028 
    iprot.readStructBegin()
16029 
    while True:
16030 
      (fname, ftype, fid) = iprot.readFieldBegin()
16031 
      if ftype == TType.STOP:
16032 
        break
16033 
      if fid == 1:
16034 
        if ftype == TType.I64:
16035 
          self.userId = iprot.readI64();
16036 
        else:
16037 
          iprot.skip(ftype)
16038 
      else:
16039 
        iprot.skip(ftype)
16040 
      iprot.readFieldEnd()
16041 
    iprot.readStructEnd()
16042 
 
16043 
  def write(self, oprot):
16044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16046 
      return
16047 
    oprot.writeStructBegin('isPrivateDealUser_args')
16048 
    if self.userId is not None:
16049 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16050 
      oprot.writeI64(self.userId)
16051 
      oprot.writeFieldEnd()
16052 
    oprot.writeFieldStop()
16053 
    oprot.writeStructEnd()
16054 
 
16055 
  def validate(self):
16056 
    return
16057 
 
16058 
 
16059 
  def __repr__(self):
16060 
    L = ['%s=%r' % (key, value)
16061 
      for key, value in self.__dict__.iteritems()]
16062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16063 
 
16064 
  def __eq__(self, other):
16065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16066 
 
16067 
  def __ne__(self, other):
16068 
    return not (self == other)
16069 
 
16070 
class isPrivateDealUser_result:
16071 
  """
16072 
  Attributes:
16073 
   - success
16074 
  """
16075 
 
16076 
  thrift_spec = (
16077 
    (0, TType.BOOL, 'success', None, None, ), # 0
16078 
  )
16079 
 
16080 
  def __init__(self, success=None,):
16081 
    self.success = success
16082 
 
16083 
  def read(self, iprot):
16084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16086 
      return
16087 
    iprot.readStructBegin()
16088 
    while True:
16089 
      (fname, ftype, fid) = iprot.readFieldBegin()
16090 
      if ftype == TType.STOP:
16091 
        break
16092 
      if fid == 0:
16093 
        if ftype == TType.BOOL:
16094 
          self.success = iprot.readBool();
16095 
        else:
16096 
          iprot.skip(ftype)
16097 
      else:
16098 
        iprot.skip(ftype)
16099 
      iprot.readFieldEnd()
16100 
    iprot.readStructEnd()
16101 
 
16102 
  def write(self, oprot):
16103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16105 
      return
16106 
    oprot.writeStructBegin('isPrivateDealUser_result')
16107 
    if self.success is not None:
16108 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16109 
      oprot.writeBool(self.success)
16110 
      oprot.writeFieldEnd()
16111 
    oprot.writeFieldStop()
16112 
    oprot.writeStructEnd()
16113 
 
16114 
  def validate(self):
16115 
    return
16116 
 
16117 
 
16118 
  def __repr__(self):
16119 
    L = ['%s=%r' % (key, value)
16120 
      for key, value in self.__dict__.iteritems()]
16121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16122 
 
16123 
  def __eq__(self, other):
16124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16125 
 
16126 
  def __ne__(self, other):
16127 
    return not (self == other)
11890 kshitij.so 16128 
 
16129 
class addPrivateDealUser_args:
16130 
  """
16131 
  Attributes:
16132 
   - userId
16133 
  """
16134 
 
16135 
  thrift_spec = (
16136 
    None, # 0
16137 
    (1, TType.I64, 'userId', None, None, ), # 1
16138 
  )
16139 
 
16140 
  def __init__(self, userId=None,):
16141 
    self.userId = userId
16142 
 
16143 
  def read(self, iprot):
16144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16146 
      return
16147 
    iprot.readStructBegin()
16148 
    while True:
16149 
      (fname, ftype, fid) = iprot.readFieldBegin()
16150 
      if ftype == TType.STOP:
16151 
        break
16152 
      if fid == 1:
16153 
        if ftype == TType.I64:
16154 
          self.userId = iprot.readI64();
16155 
        else:
16156 
          iprot.skip(ftype)
16157 
      else:
16158 
        iprot.skip(ftype)
16159 
      iprot.readFieldEnd()
16160 
    iprot.readStructEnd()
16161 
 
16162 
  def write(self, oprot):
16163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16165 
      return
16166 
    oprot.writeStructBegin('addPrivateDealUser_args')
16167 
    if self.userId is not None:
16168 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16169 
      oprot.writeI64(self.userId)
16170 
      oprot.writeFieldEnd()
16171 
    oprot.writeFieldStop()
16172 
    oprot.writeStructEnd()
16173 
 
16174 
  def validate(self):
16175 
    return
16176 
 
16177 
 
16178 
  def __repr__(self):
16179 
    L = ['%s=%r' % (key, value)
16180 
      for key, value in self.__dict__.iteritems()]
16181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16182 
 
16183 
  def __eq__(self, other):
16184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16185 
 
16186 
  def __ne__(self, other):
16187 
    return not (self == other)
16188 
 
16189 
class addPrivateDealUser_result:
16190 
  """
16191 
  Attributes:
16192 
   - success
16193 
  """
16194 
 
16195 
  thrift_spec = (
16196 
    (0, TType.BOOL, 'success', None, None, ), # 0
16197 
  )
16198 
 
16199 
  def __init__(self, success=None,):
16200 
    self.success = success
16201 
 
16202 
  def read(self, iprot):
16203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16205 
      return
16206 
    iprot.readStructBegin()
16207 
    while True:
16208 
      (fname, ftype, fid) = iprot.readFieldBegin()
16209 
      if ftype == TType.STOP:
16210 
        break
16211 
      if fid == 0:
16212 
        if ftype == TType.BOOL:
16213 
          self.success = iprot.readBool();
16214 
        else:
16215 
          iprot.skip(ftype)
16216 
      else:
16217 
        iprot.skip(ftype)
16218 
      iprot.readFieldEnd()
16219 
    iprot.readStructEnd()
16220 
 
16221 
  def write(self, oprot):
16222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16224 
      return
16225 
    oprot.writeStructBegin('addPrivateDealUser_result')
16226 
    if self.success is not None:
16227 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16228 
      oprot.writeBool(self.success)
16229 
      oprot.writeFieldEnd()
16230 
    oprot.writeFieldStop()
16231 
    oprot.writeStructEnd()
16232 
 
16233 
  def validate(self):
16234 
    return
16235 
 
16236 
 
16237 
  def __repr__(self):
16238 
    L = ['%s=%r' % (key, value)
16239 
      for key, value in self.__dict__.iteritems()]
16240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16241 
 
16242 
  def __eq__(self, other):
16243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16244 
 
16245 
  def __ne__(self, other):
16246 
    return not (self == other)
16247 
 
16248 
class changePrivateDealUserStatus_args:
16249 
  """
16250 
  Attributes:
16251 
   - userId
16252 
   - isActive
16253 
  """
16254 
 
16255 
  thrift_spec = (
16256 
    None, # 0
16257 
    (1, TType.I64, 'userId', None, None, ), # 1
16258 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
16259 
  )
16260 
 
16261 
  def __init__(self, userId=None, isActive=None,):
16262 
    self.userId = userId
16263 
    self.isActive = isActive
16264 
 
16265 
  def read(self, iprot):
16266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16268 
      return
16269 
    iprot.readStructBegin()
16270 
    while True:
16271 
      (fname, ftype, fid) = iprot.readFieldBegin()
16272 
      if ftype == TType.STOP:
16273 
        break
16274 
      if fid == 1:
16275 
        if ftype == TType.I64:
16276 
          self.userId = iprot.readI64();
16277 
        else:
16278 
          iprot.skip(ftype)
16279 
      elif fid == 2:
16280 
        if ftype == TType.BOOL:
16281 
          self.isActive = iprot.readBool();
16282 
        else:
16283 
          iprot.skip(ftype)
16284 
      else:
16285 
        iprot.skip(ftype)
16286 
      iprot.readFieldEnd()
16287 
    iprot.readStructEnd()
16288 
 
16289 
  def write(self, oprot):
16290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16292 
      return
16293 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
16294 
    if self.userId is not None:
16295 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16296 
      oprot.writeI64(self.userId)
16297 
      oprot.writeFieldEnd()
16298 
    if self.isActive is not None:
16299 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
16300 
      oprot.writeBool(self.isActive)
16301 
      oprot.writeFieldEnd()
16302 
    oprot.writeFieldStop()
16303 
    oprot.writeStructEnd()
16304 
 
16305 
  def validate(self):
16306 
    return
16307 
 
16308 
 
16309 
  def __repr__(self):
16310 
    L = ['%s=%r' % (key, value)
16311 
      for key, value in self.__dict__.iteritems()]
16312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16313 
 
16314 
  def __eq__(self, other):
16315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16316 
 
16317 
  def __ne__(self, other):
16318 
    return not (self == other)
16319 
 
16320 
class changePrivateDealUserStatus_result:
16321 
  """
16322 
  Attributes:
16323 
   - success
16324 
  """
16325 
 
16326 
  thrift_spec = (
16327 
    (0, TType.BOOL, 'success', None, None, ), # 0
16328 
  )
16329 
 
16330 
  def __init__(self, success=None,):
16331 
    self.success = success
16332 
 
16333 
  def read(self, iprot):
16334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16336 
      return
16337 
    iprot.readStructBegin()
16338 
    while True:
16339 
      (fname, ftype, fid) = iprot.readFieldBegin()
16340 
      if ftype == TType.STOP:
16341 
        break
16342 
      if fid == 0:
16343 
        if ftype == TType.BOOL:
16344 
          self.success = iprot.readBool();
16345 
        else:
16346 
          iprot.skip(ftype)
16347 
      else:
16348 
        iprot.skip(ftype)
16349 
      iprot.readFieldEnd()
16350 
    iprot.readStructEnd()
16351 
 
16352 
  def write(self, oprot):
16353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16355 
      return
16356 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
16357 
    if self.success is not None:
16358 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16359 
      oprot.writeBool(self.success)
16360 
      oprot.writeFieldEnd()
16361 
    oprot.writeFieldStop()
16362 
    oprot.writeStructEnd()
16363 
 
16364 
  def validate(self):
16365 
    return
16366 
 
16367 
 
16368 
  def __repr__(self):
16369 
    L = ['%s=%r' % (key, value)
16370 
      for key, value in self.__dict__.iteritems()]
16371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16372 
 
16373 
  def __eq__(self, other):
16374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16375 
 
16376 
  def __ne__(self, other):
16377 
    return not (self == other)
16378 
 
16379 
class getPrivateDealUser_args:
16380 
  """
16381 
  Attributes:
16382 
   - userId
16383 
  """
16384 
 
16385 
  thrift_spec = (
16386 
    None, # 0
16387 
    (1, TType.I64, 'userId', None, None, ), # 1
16388 
  )
16389 
 
16390 
  def __init__(self, userId=None,):
16391 
    self.userId = userId
16392 
 
16393 
  def read(self, iprot):
16394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16396 
      return
16397 
    iprot.readStructBegin()
16398 
    while True:
16399 
      (fname, ftype, fid) = iprot.readFieldBegin()
16400 
      if ftype == TType.STOP:
16401 
        break
16402 
      if fid == 1:
16403 
        if ftype == TType.I64:
16404 
          self.userId = iprot.readI64();
16405 
        else:
16406 
          iprot.skip(ftype)
16407 
      else:
16408 
        iprot.skip(ftype)
16409 
      iprot.readFieldEnd()
16410 
    iprot.readStructEnd()
16411 
 
16412 
  def write(self, oprot):
16413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16415 
      return
16416 
    oprot.writeStructBegin('getPrivateDealUser_args')
16417 
    if self.userId is not None:
16418 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16419 
      oprot.writeI64(self.userId)
16420 
      oprot.writeFieldEnd()
16421 
    oprot.writeFieldStop()
16422 
    oprot.writeStructEnd()
16423 
 
16424 
  def validate(self):
16425 
    return
16426 
 
16427 
 
16428 
  def __repr__(self):
16429 
    L = ['%s=%r' % (key, value)
16430 
      for key, value in self.__dict__.iteritems()]
16431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16432 
 
16433 
  def __eq__(self, other):
16434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16435 
 
16436 
  def __ne__(self, other):
16437 
    return not (self == other)
16438 
 
16439 
class getPrivateDealUser_result:
16440 
  """
16441 
  Attributes:
16442 
   - success
16443 
  """
16444 
 
16445 
  thrift_spec = (
16446 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
16447 
  )
16448 
 
16449 
  def __init__(self, success=None,):
16450 
    self.success = success
16451 
 
16452 
  def read(self, iprot):
16453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16455 
      return
16456 
    iprot.readStructBegin()
16457 
    while True:
16458 
      (fname, ftype, fid) = iprot.readFieldBegin()
16459 
      if ftype == TType.STOP:
16460 
        break
16461 
      if fid == 0:
16462 
        if ftype == TType.STRUCT:
16463 
          self.success = PrivateDealUser()
16464 
          self.success.read(iprot)
16465 
        else:
16466 
          iprot.skip(ftype)
16467 
      else:
16468 
        iprot.skip(ftype)
16469 
      iprot.readFieldEnd()
16470 
    iprot.readStructEnd()
16471 
 
16472 
  def write(self, oprot):
16473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16475 
      return
16476 
    oprot.writeStructBegin('getPrivateDealUser_result')
16477 
    if self.success is not None:
16478 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16479 
      self.success.write(oprot)
16480 
      oprot.writeFieldEnd()
16481 
    oprot.writeFieldStop()
16482 
    oprot.writeStructEnd()
16483 
 
16484 
  def validate(self):
16485 
    return
16486 
 
16487 
 
16488 
  def __repr__(self):
16489 
    L = ['%s=%r' % (key, value)
16490 
      for key, value in self.__dict__.iteritems()]
16491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16492 
 
16493 
  def __eq__(self, other):
16494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16495 
 
16496 
  def __ne__(self, other):
16497 
    return not (self == other)
12696 amit.gupta 16498 
 
16499 
class registerCounter_args:
16500 
  """
16501 
  Attributes:
16502 
   - counter
16503 
   - userId
16504 
  """
16505 
 
16506 
  thrift_spec = (
16507 
    None, # 0
16508 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16509 
    (2, TType.I64, 'userId', None, None, ), # 2
16510 
  )
16511 
 
16512 
  def __init__(self, counter=None, userId=None,):
16513 
    self.counter = counter
16514 
    self.userId = userId
16515 
 
16516 
  def read(self, iprot):
16517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16519 
      return
16520 
    iprot.readStructBegin()
16521 
    while True:
16522 
      (fname, ftype, fid) = iprot.readFieldBegin()
16523 
      if ftype == TType.STOP:
16524 
        break
16525 
      if fid == 1:
16526 
        if ftype == TType.STRUCT:
16527 
          self.counter = Counter()
16528 
          self.counter.read(iprot)
16529 
        else:
16530 
          iprot.skip(ftype)
16531 
      elif fid == 2:
16532 
        if ftype == TType.I64:
16533 
          self.userId = iprot.readI64();
16534 
        else:
16535 
          iprot.skip(ftype)
16536 
      else:
16537 
        iprot.skip(ftype)
16538 
      iprot.readFieldEnd()
16539 
    iprot.readStructEnd()
16540 
 
16541 
  def write(self, oprot):
16542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16544 
      return
16545 
    oprot.writeStructBegin('registerCounter_args')
16546 
    if self.counter is not None:
16547 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16548 
      self.counter.write(oprot)
16549 
      oprot.writeFieldEnd()
16550 
    if self.userId is not None:
16551 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16552 
      oprot.writeI64(self.userId)
16553 
      oprot.writeFieldEnd()
16554 
    oprot.writeFieldStop()
16555 
    oprot.writeStructEnd()
16556 
 
16557 
  def validate(self):
16558 
    return
16559 
 
16560 
 
16561 
  def __repr__(self):
16562 
    L = ['%s=%r' % (key, value)
16563 
      for key, value in self.__dict__.iteritems()]
16564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16565 
 
16566 
  def __eq__(self, other):
16567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16568 
 
16569 
  def __ne__(self, other):
16570 
    return not (self == other)
16571 
 
16572 
class registerCounter_result:
16573 
  """
16574 
  Attributes:
16575 
   - success
16576 
  """
16577 
 
16578 
  thrift_spec = (
16579 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16580 
  )
16581 
 
16582 
  def __init__(self, success=None,):
16583 
    self.success = success
16584 
 
16585 
  def read(self, iprot):
16586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16588 
      return
16589 
    iprot.readStructBegin()
16590 
    while True:
16591 
      (fname, ftype, fid) = iprot.readFieldBegin()
16592 
      if ftype == TType.STOP:
16593 
        break
16594 
      if fid == 0:
16595 
        if ftype == TType.MAP:
16596 
          self.success = {}
16597 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16598 
          for _i229 in xrange(_size225):
16599 
            _key230 = iprot.readString();
16600 
            _val231 = iprot.readString();
16601 
            self.success[_key230] = _val231
16602 
          iprot.readMapEnd()
16603 
        else:
16604 
          iprot.skip(ftype)
16605 
      else:
16606 
        iprot.skip(ftype)
16607 
      iprot.readFieldEnd()
16608 
    iprot.readStructEnd()
16609 
 
16610 
  def write(self, oprot):
16611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16613 
      return
16614 
    oprot.writeStructBegin('registerCounter_result')
16615 
    if self.success is not None:
16616 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16617 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16618 
      for kiter232,viter233 in self.success.items():
16619 
        oprot.writeString(kiter232)
16620 
        oprot.writeString(viter233)
16621 
      oprot.writeMapEnd()
16622 
      oprot.writeFieldEnd()
16623 
    oprot.writeFieldStop()
16624 
    oprot.writeStructEnd()
16625 
 
16626 
  def validate(self):
16627 
    return
16628 
 
16629 
 
16630 
  def __repr__(self):
16631 
    L = ['%s=%r' % (key, value)
16632 
      for key, value in self.__dict__.iteritems()]
16633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16634 
 
16635 
  def __eq__(self, other):
16636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16637 
 
16638 
  def __ne__(self, other):
16639 
    return not (self == other)
12722 amit.gupta 16640 
 
16641 
class searchCounter_args:
16642 
  """
16643 
  Attributes:
16644 
   - type1
16645 
   - searchString
16646 
  """
16647 
 
16648 
  thrift_spec = (
16649 
    None, # 0
16650 
    (1, TType.STRING, 'type1', None, None, ), # 1
16651 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16652 
  )
16653 
 
16654 
  def __init__(self, type1=None, searchString=None,):
16655 
    self.type1 = type1
16656 
    self.searchString = searchString
16657 
 
16658 
  def read(self, iprot):
16659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16661 
      return
16662 
    iprot.readStructBegin()
16663 
    while True:
16664 
      (fname, ftype, fid) = iprot.readFieldBegin()
16665 
      if ftype == TType.STOP:
16666 
        break
16667 
      if fid == 1:
16668 
        if ftype == TType.STRING:
16669 
          self.type1 = iprot.readString();
16670 
        else:
16671 
          iprot.skip(ftype)
16672 
      elif fid == 2:
16673 
        if ftype == TType.STRING:
16674 
          self.searchString = iprot.readString();
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      else:
16678 
        iprot.skip(ftype)
16679 
      iprot.readFieldEnd()
16680 
    iprot.readStructEnd()
16681 
 
16682 
  def write(self, oprot):
16683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16685 
      return
16686 
    oprot.writeStructBegin('searchCounter_args')
16687 
    if self.type1 is not None:
16688 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16689 
      oprot.writeString(self.type1)
16690 
      oprot.writeFieldEnd()
16691 
    if self.searchString is not None:
16692 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16693 
      oprot.writeString(self.searchString)
16694 
      oprot.writeFieldEnd()
16695 
    oprot.writeFieldStop()
16696 
    oprot.writeStructEnd()
16697 
 
16698 
  def validate(self):
16699 
    return
16700 
 
16701 
 
16702 
  def __repr__(self):
16703 
    L = ['%s=%r' % (key, value)
16704 
      for key, value in self.__dict__.iteritems()]
16705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16706 
 
16707 
  def __eq__(self, other):
16708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16709 
 
16710 
  def __ne__(self, other):
16711 
    return not (self == other)
16712 
 
16713 
class searchCounter_result:
16714 
  """
16715 
  Attributes:
16716 
   - success
16717 
  """
16718 
 
16719 
  thrift_spec = (
16720 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16721 
  )
16722 
 
16723 
  def __init__(self, success=None,):
16724 
    self.success = success
16725 
 
16726 
  def read(self, iprot):
16727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16729 
      return
16730 
    iprot.readStructBegin()
16731 
    while True:
16732 
      (fname, ftype, fid) = iprot.readFieldBegin()
16733 
      if ftype == TType.STOP:
16734 
        break
16735 
      if fid == 0:
16736 
        if ftype == TType.LIST:
16737 
          self.success = []
16738 
          (_etype237, _size234) = iprot.readListBegin()
16739 
          for _i238 in xrange(_size234):
16740 
            _elem239 = Counter()
16741 
            _elem239.read(iprot)
16742 
            self.success.append(_elem239)
16743 
          iprot.readListEnd()
16744 
        else:
16745 
          iprot.skip(ftype)
16746 
      else:
16747 
        iprot.skip(ftype)
16748 
      iprot.readFieldEnd()
16749 
    iprot.readStructEnd()
16750 
 
16751 
  def write(self, oprot):
16752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16754 
      return
16755 
    oprot.writeStructBegin('searchCounter_result')
16756 
    if self.success is not None:
16757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16759 
      for iter240 in self.success:
16760 
        iter240.write(oprot)
16761 
      oprot.writeListEnd()
16762 
      oprot.writeFieldEnd()
16763 
    oprot.writeFieldStop()
16764 
    oprot.writeStructEnd()
16765 
 
16766 
  def validate(self):
16767 
    return
16768 
 
16769 
 
16770 
  def __repr__(self):
16771 
    L = ['%s=%r' % (key, value)
16772 
      for key, value in self.__dict__.iteritems()]
16773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16774 
 
16775 
  def __eq__(self, other):
16776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16777 
 
16778 
  def __ne__(self, other):
16779 
    return not (self == other)
16780 
 
18977 amit.gupta 16781 
class getCounterByUserId_args:
16782 
  """
16783 
  Attributes:
16784 
   - userId
16785 
  """
16786 
 
16787 
  thrift_spec = (
16788 
    None, # 0
16789 
    (1, TType.I64, 'userId', None, None, ), # 1
16790 
  )
16791 
 
16792 
  def __init__(self, userId=None,):
16793 
    self.userId = userId
16794 
 
16795 
  def read(self, iprot):
16796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16798 
      return
16799 
    iprot.readStructBegin()
16800 
    while True:
16801 
      (fname, ftype, fid) = iprot.readFieldBegin()
16802 
      if ftype == TType.STOP:
16803 
        break
16804 
      if fid == 1:
16805 
        if ftype == TType.I64:
16806 
          self.userId = iprot.readI64();
16807 
        else:
16808 
          iprot.skip(ftype)
16809 
      else:
16810 
        iprot.skip(ftype)
16811 
      iprot.readFieldEnd()
16812 
    iprot.readStructEnd()
16813 
 
16814 
  def write(self, oprot):
16815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16817 
      return
16818 
    oprot.writeStructBegin('getCounterByUserId_args')
16819 
    if self.userId is not None:
16820 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16821 
      oprot.writeI64(self.userId)
16822 
      oprot.writeFieldEnd()
16823 
    oprot.writeFieldStop()
16824 
    oprot.writeStructEnd()
16825 
 
16826 
  def validate(self):
16827 
    return
16828 
 
16829 
 
16830 
  def __repr__(self):
16831 
    L = ['%s=%r' % (key, value)
16832 
      for key, value in self.__dict__.iteritems()]
16833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16834 
 
16835 
  def __eq__(self, other):
16836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16837 
 
16838 
  def __ne__(self, other):
16839 
    return not (self == other)
16840 
 
16841 
class getCounterByUserId_result:
16842 
  """
16843 
  Attributes:
16844 
   - success
16845 
  """
16846 
 
16847 
  thrift_spec = (
16848 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16849 
  )
16850 
 
16851 
  def __init__(self, success=None,):
16852 
    self.success = success
16853 
 
16854 
  def read(self, iprot):
16855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16857 
      return
16858 
    iprot.readStructBegin()
16859 
    while True:
16860 
      (fname, ftype, fid) = iprot.readFieldBegin()
16861 
      if ftype == TType.STOP:
16862 
        break
16863 
      if fid == 0:
16864 
        if ftype == TType.STRUCT:
16865 
          self.success = Counter()
16866 
          self.success.read(iprot)
16867 
        else:
16868 
          iprot.skip(ftype)
16869 
      else:
16870 
        iprot.skip(ftype)
16871 
      iprot.readFieldEnd()
16872 
    iprot.readStructEnd()
16873 
 
16874 
  def write(self, oprot):
16875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16877 
      return
16878 
    oprot.writeStructBegin('getCounterByUserId_result')
16879 
    if self.success is not None:
16880 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16881 
      self.success.write(oprot)
16882 
      oprot.writeFieldEnd()
16883 
    oprot.writeFieldStop()
16884 
    oprot.writeStructEnd()
16885 
 
16886 
  def validate(self):
16887 
    return
16888 
 
16889 
 
16890 
  def __repr__(self):
16891 
    L = ['%s=%r' % (key, value)
16892 
      for key, value in self.__dict__.iteritems()]
16893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16894 
 
16895 
  def __eq__(self, other):
16896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16897 
 
16898 
  def __ne__(self, other):
16899 
    return not (self == other)
16900 
 
12722 amit.gupta 16901 
class getAllUsersByCounter_args:
16902 
  """
16903 
  Attributes:
16904 
   - counterId
16905 
  """
16906 
 
16907 
  thrift_spec = (
16908 
    None, # 0
16909 
    (1, TType.I64, 'counterId', None, None, ), # 1
16910 
  )
16911 
 
16912 
  def __init__(self, counterId=None,):
16913 
    self.counterId = counterId
16914 
 
16915 
  def read(self, iprot):
16916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16918 
      return
16919 
    iprot.readStructBegin()
16920 
    while True:
16921 
      (fname, ftype, fid) = iprot.readFieldBegin()
16922 
      if ftype == TType.STOP:
16923 
        break
16924 
      if fid == 1:
16925 
        if ftype == TType.I64:
16926 
          self.counterId = iprot.readI64();
16927 
        else:
16928 
          iprot.skip(ftype)
16929 
      else:
16930 
        iprot.skip(ftype)
16931 
      iprot.readFieldEnd()
16932 
    iprot.readStructEnd()
16933 
 
16934 
  def write(self, oprot):
16935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16937 
      return
16938 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16939 
    if self.counterId is not None:
16940 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16941 
      oprot.writeI64(self.counterId)
16942 
      oprot.writeFieldEnd()
16943 
    oprot.writeFieldStop()
16944 
    oprot.writeStructEnd()
16945 
 
16946 
  def validate(self):
16947 
    return
16948 
 
16949 
 
16950 
  def __repr__(self):
16951 
    L = ['%s=%r' % (key, value)
16952 
      for key, value in self.__dict__.iteritems()]
16953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16954 
 
16955 
  def __eq__(self, other):
16956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16957 
 
16958 
  def __ne__(self, other):
16959 
    return not (self == other)
16960 
 
16961 
class getAllUsersByCounter_result:
16962 
  """
16963 
  Attributes:
16964 
   - success
16965 
  """
16966 
 
16967 
  thrift_spec = (
16968 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16969 
  )
16970 
 
16971 
  def __init__(self, success=None,):
16972 
    self.success = success
16973 
 
16974 
  def read(self, iprot):
16975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16977 
      return
16978 
    iprot.readStructBegin()
16979 
    while True:
16980 
      (fname, ftype, fid) = iprot.readFieldBegin()
16981 
      if ftype == TType.STOP:
16982 
        break
16983 
      if fid == 0:
16984 
        if ftype == TType.LIST:
16985 
          self.success = []
16986 
          (_etype244, _size241) = iprot.readListBegin()
16987 
          for _i245 in xrange(_size241):
16988 
            _elem246 = User()
16989 
            _elem246.read(iprot)
16990 
            self.success.append(_elem246)
16991 
          iprot.readListEnd()
16992 
        else:
16993 
          iprot.skip(ftype)
16994 
      else:
16995 
        iprot.skip(ftype)
16996 
      iprot.readFieldEnd()
16997 
    iprot.readStructEnd()
16998 
 
16999 
  def write(self, oprot):
17000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17002 
      return
17003 
    oprot.writeStructBegin('getAllUsersByCounter_result')
17004 
    if self.success is not None:
17005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17007 
      for iter247 in self.success:
17008 
        iter247.write(oprot)
17009 
      oprot.writeListEnd()
17010 
      oprot.writeFieldEnd()
17011 
    oprot.writeFieldStop()
17012 
    oprot.writeStructEnd()
17013 
 
17014 
  def validate(self):
17015 
    return
17016 
 
17017 
 
17018 
  def __repr__(self):
17019 
    L = ['%s=%r' % (key, value)
17020 
      for key, value in self.__dict__.iteritems()]
17021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17022 
 
17023 
  def __eq__(self, other):
17024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17025 
 
17026 
  def __ne__(self, other):
17027 
    return not (self == other)
15251 manish.sha 17028 
 
17029 
class getActiveAccessTokenForUser_args:
17030 
  """
17031 
  Attributes:
17032 
   - userId
17033 
   - source
17034 
  """
17035 
 
17036 
  thrift_spec = (
17037 
    None, # 0
17038 
    (1, TType.I64, 'userId', None, None, ), # 1
17039 
    (2, TType.STRING, 'source', None, None, ), # 2
17040 
  )
17041 
 
17042 
  def __init__(self, userId=None, source=None,):
17043 
    self.userId = userId
17044 
    self.source = source
17045 
 
17046 
  def read(self, iprot):
17047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17049 
      return
17050 
    iprot.readStructBegin()
17051 
    while True:
17052 
      (fname, ftype, fid) = iprot.readFieldBegin()
17053 
      if ftype == TType.STOP:
17054 
        break
17055 
      if fid == 1:
17056 
        if ftype == TType.I64:
17057 
          self.userId = iprot.readI64();
17058 
        else:
17059 
          iprot.skip(ftype)
17060 
      elif fid == 2:
17061 
        if ftype == TType.STRING:
17062 
          self.source = iprot.readString();
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      else:
17066 
        iprot.skip(ftype)
17067 
      iprot.readFieldEnd()
17068 
    iprot.readStructEnd()
17069 
 
17070 
  def write(self, oprot):
17071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17073 
      return
17074 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
17075 
    if self.userId is not None:
17076 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17077 
      oprot.writeI64(self.userId)
17078 
      oprot.writeFieldEnd()
17079 
    if self.source is not None:
17080 
      oprot.writeFieldBegin('source', TType.STRING, 2)
17081 
      oprot.writeString(self.source)
17082 
      oprot.writeFieldEnd()
17083 
    oprot.writeFieldStop()
17084 
    oprot.writeStructEnd()
17085 
 
17086 
  def validate(self):
17087 
    return
17088 
 
17089 
 
17090 
  def __repr__(self):
17091 
    L = ['%s=%r' % (key, value)
17092 
      for key, value in self.__dict__.iteritems()]
17093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17094 
 
17095 
  def __eq__(self, other):
17096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17097 
 
17098 
  def __ne__(self, other):
17099 
    return not (self == other)
17100 
 
17101 
class getActiveAccessTokenForUser_result:
17102 
  """
17103 
  Attributes:
17104 
   - success
17105 
  """
17106 
 
17107 
  thrift_spec = (
17108 
    (0, TType.STRING, 'success', None, None, ), # 0
17109 
  )
17110 
 
17111 
  def __init__(self, success=None,):
17112 
    self.success = success
17113 
 
17114 
  def read(self, iprot):
17115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17117 
      return
17118 
    iprot.readStructBegin()
17119 
    while True:
17120 
      (fname, ftype, fid) = iprot.readFieldBegin()
17121 
      if ftype == TType.STOP:
17122 
        break
17123 
      if fid == 0:
17124 
        if ftype == TType.STRING:
17125 
          self.success = iprot.readString();
17126 
        else:
17127 
          iprot.skip(ftype)
17128 
      else:
17129 
        iprot.skip(ftype)
17130 
      iprot.readFieldEnd()
17131 
    iprot.readStructEnd()
17132 
 
17133 
  def write(self, oprot):
17134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17136 
      return
17137 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
17138 
    if self.success is not None:
17139 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17140 
      oprot.writeString(self.success)
17141 
      oprot.writeFieldEnd()
17142 
    oprot.writeFieldStop()
17143 
    oprot.writeStructEnd()
17144 
 
17145 
  def validate(self):
17146 
    return
17147 
 
17148 
 
17149 
  def __repr__(self):
17150 
    L = ['%s=%r' % (key, value)
17151 
      for key, value in self.__dict__.iteritems()]
17152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17153 
 
17154 
  def __eq__(self, other):
17155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17156 
 
17157 
  def __ne__(self, other):
17158 
    return not (self == other)
17159 
 
17160 
class validateAccessToken_args:
17161 
  """
17162 
  Attributes:
17163 
   - accessToken
17164 
  """
17165 
 
17166 
  thrift_spec = (
17167 
    None, # 0
17168 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
17169 
  )
17170 
 
17171 
  def __init__(self, accessToken=None,):
17172 
    self.accessToken = accessToken
17173 
 
17174 
  def read(self, iprot):
17175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17177 
      return
17178 
    iprot.readStructBegin()
17179 
    while True:
17180 
      (fname, ftype, fid) = iprot.readFieldBegin()
17181 
      if ftype == TType.STOP:
17182 
        break
17183 
      if fid == 1:
17184 
        if ftype == TType.STRING:
17185 
          self.accessToken = iprot.readString();
17186 
        else:
17187 
          iprot.skip(ftype)
17188 
      else:
17189 
        iprot.skip(ftype)
17190 
      iprot.readFieldEnd()
17191 
    iprot.readStructEnd()
17192 
 
17193 
  def write(self, oprot):
17194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17196 
      return
17197 
    oprot.writeStructBegin('validateAccessToken_args')
17198 
    if self.accessToken is not None:
17199 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
17200 
      oprot.writeString(self.accessToken)
17201 
      oprot.writeFieldEnd()
17202 
    oprot.writeFieldStop()
17203 
    oprot.writeStructEnd()
17204 
 
17205 
  def validate(self):
17206 
    return
17207 
 
17208 
 
17209 
  def __repr__(self):
17210 
    L = ['%s=%r' % (key, value)
17211 
      for key, value in self.__dict__.iteritems()]
17212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17213 
 
17214 
  def __eq__(self, other):
17215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17216 
 
17217 
  def __ne__(self, other):
17218 
    return not (self == other)
17219 
 
17220 
class validateAccessToken_result:
17221 
  """
17222 
  Attributes:
17223 
   - success
17224 
  """
17225 
 
17226 
  thrift_spec = (
17227 
    (0, TType.BOOL, 'success', None, None, ), # 0
17228 
  )
17229 
 
17230 
  def __init__(self, success=None,):
17231 
    self.success = success
17232 
 
17233 
  def read(self, iprot):
17234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17236 
      return
17237 
    iprot.readStructBegin()
17238 
    while True:
17239 
      (fname, ftype, fid) = iprot.readFieldBegin()
17240 
      if ftype == TType.STOP:
17241 
        break
17242 
      if fid == 0:
17243 
        if ftype == TType.BOOL:
17244 
          self.success = iprot.readBool();
17245 
        else:
17246 
          iprot.skip(ftype)
17247 
      else:
17248 
        iprot.skip(ftype)
17249 
      iprot.readFieldEnd()
17250 
    iprot.readStructEnd()
17251 
 
17252 
  def write(self, oprot):
17253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17255 
      return
17256 
    oprot.writeStructBegin('validateAccessToken_result')
17257 
    if self.success is not None:
17258 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17259 
      oprot.writeBool(self.success)
17260 
      oprot.writeFieldEnd()
17261 
    oprot.writeFieldStop()
17262 
    oprot.writeStructEnd()
17263 
 
17264 
  def validate(self):
17265 
    return
17266 
 
17267 
 
17268 
  def __repr__(self):
17269 
    L = ['%s=%r' % (key, value)
17270 
      for key, value in self.__dict__.iteritems()]
17271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17272 
 
17273 
  def __eq__(self, other):
17274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17275 
 
17276 
  def __ne__(self, other):
17277 
    return not (self == other)
17782 amit.gupta 17278 
 
17279 
class addItemsToCart_args:
17280 
  """
17281 
  Attributes:
17282 
   - cartId
17283 
   - itemQty
17284 
   - couponCode
17285 
  """
17286 
 
17287 
  thrift_spec = (
17288 
    None, # 0
17289 
    (1, TType.I64, 'cartId', None, None, ), # 1
17290 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
17291 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
17292 
  )
17293 
 
17294 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
17295 
    self.cartId = cartId
17296 
    self.itemQty = itemQty
17297 
    self.couponCode = couponCode
17298 
 
17299 
  def read(self, iprot):
17300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17302 
      return
17303 
    iprot.readStructBegin()
17304 
    while True:
17305 
      (fname, ftype, fid) = iprot.readFieldBegin()
17306 
      if ftype == TType.STOP:
17307 
        break
17308 
      if fid == 1:
17309 
        if ftype == TType.I64:
17310 
          self.cartId = iprot.readI64();
17311 
        else:
17312 
          iprot.skip(ftype)
17313 
      elif fid == 2:
17314 
        if ftype == TType.LIST:
17315 
          self.itemQty = []
17316 
          (_etype251, _size248) = iprot.readListBegin()
17317 
          for _i252 in xrange(_size248):
17318 
            _elem253 = ItemQuantity()
17319 
            _elem253.read(iprot)
17320 
            self.itemQty.append(_elem253)
17321 
          iprot.readListEnd()
17322 
        else:
17323 
          iprot.skip(ftype)
17324 
      elif fid == 3:
17325 
        if ftype == TType.STRING:
17326 
          self.couponCode = iprot.readString();
17327 
        else:
17328 
          iprot.skip(ftype)
17329 
      else:
17330 
        iprot.skip(ftype)
17331 
      iprot.readFieldEnd()
17332 
    iprot.readStructEnd()
17333 
 
17334 
  def write(self, oprot):
17335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17337 
      return
17338 
    oprot.writeStructBegin('addItemsToCart_args')
17339 
    if self.cartId is not None:
17340 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17341 
      oprot.writeI64(self.cartId)
17342 
      oprot.writeFieldEnd()
17343 
    if self.itemQty is not None:
17344 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
17345 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
17346 
      for iter254 in self.itemQty:
17347 
        iter254.write(oprot)
17348 
      oprot.writeListEnd()
17349 
      oprot.writeFieldEnd()
17350 
    if self.couponCode is not None:
17351 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
17352 
      oprot.writeString(self.couponCode)
17353 
      oprot.writeFieldEnd()
17354 
    oprot.writeFieldStop()
17355 
    oprot.writeStructEnd()
17356 
 
17357 
  def validate(self):
17358 
    return
17359 
 
17360 
 
17361 
  def __repr__(self):
17362 
    L = ['%s=%r' % (key, value)
17363 
      for key, value in self.__dict__.iteritems()]
17364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17365 
 
17366 
  def __eq__(self, other):
17367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17368 
 
17369 
  def __ne__(self, other):
17370 
    return not (self == other)
17371 
 
17372 
class addItemsToCart_result:
17373 
  """
17374 
  Attributes:
17375 
   - success
17376 
  """
17377 
 
17378 
  thrift_spec = (
17379 
    (0, TType.BOOL, 'success', None, None, ), # 0
17380 
  )
17381 
 
17382 
  def __init__(self, success=None,):
17383 
    self.success = success
17384 
 
17385 
  def read(self, iprot):
17386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17388 
      return
17389 
    iprot.readStructBegin()
17390 
    while True:
17391 
      (fname, ftype, fid) = iprot.readFieldBegin()
17392 
      if ftype == TType.STOP:
17393 
        break
17394 
      if fid == 0:
17395 
        if ftype == TType.BOOL:
17396 
          self.success = iprot.readBool();
17397 
        else:
17398 
          iprot.skip(ftype)
17399 
      else:
17400 
        iprot.skip(ftype)
17401 
      iprot.readFieldEnd()
17402 
    iprot.readStructEnd()
17403 
 
17404 
  def write(self, oprot):
17405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17407 
      return
17408 
    oprot.writeStructBegin('addItemsToCart_result')
17409 
    if self.success is not None:
17410 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17411 
      oprot.writeBool(self.success)
17412 
      oprot.writeFieldEnd()
17413 
    oprot.writeFieldStop()
17414 
    oprot.writeStructEnd()
17415 
 
17416 
  def validate(self):
17417 
    return
17418 
 
17419 
 
17420 
  def __repr__(self):
17421 
    L = ['%s=%r' % (key, value)
17422 
      for key, value in self.__dict__.iteritems()]
17423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17424 
 
17425 
  def __eq__(self, other):
17426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17427 
 
17428 
  def __ne__(self, other):
17429 
    return not (self == other)
17430 
 
17431 
class validateCartNew_args:
17432 
  """
17433 
  Attributes:
17434 
   - cartId
17435 
   - pinCode
17436 
   - sourceId
17437 
  """
17438 
 
17439 
  thrift_spec = (
17440 
    None, # 0
17441 
    (1, TType.I64, 'cartId', None, None, ), # 1
17442 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
17443 
    (3, TType.I64, 'sourceId', None, None, ), # 3
17444 
  )
17445 
 
17446 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
17447 
    self.cartId = cartId
17448 
    self.pinCode = pinCode
17449 
    self.sourceId = sourceId
17450 
 
17451 
  def read(self, iprot):
17452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17454 
      return
17455 
    iprot.readStructBegin()
17456 
    while True:
17457 
      (fname, ftype, fid) = iprot.readFieldBegin()
17458 
      if ftype == TType.STOP:
17459 
        break
17460 
      if fid == 1:
17461 
        if ftype == TType.I64:
17462 
          self.cartId = iprot.readI64();
17463 
        else:
17464 
          iprot.skip(ftype)
17465 
      elif fid == 2:
17466 
        if ftype == TType.STRING:
17467 
          self.pinCode = iprot.readString();
17468 
        else:
17469 
          iprot.skip(ftype)
17470 
      elif fid == 3:
17471 
        if ftype == TType.I64:
17472 
          self.sourceId = iprot.readI64();
17473 
        else:
17474 
          iprot.skip(ftype)
17475 
      else:
17476 
        iprot.skip(ftype)
17477 
      iprot.readFieldEnd()
17478 
    iprot.readStructEnd()
17479 
 
17480 
  def write(self, oprot):
17481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17483 
      return
17484 
    oprot.writeStructBegin('validateCartNew_args')
17485 
    if self.cartId is not None:
17486 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17487 
      oprot.writeI64(self.cartId)
17488 
      oprot.writeFieldEnd()
17489 
    if self.pinCode is not None:
17490 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17491 
      oprot.writeString(self.pinCode)
17492 
      oprot.writeFieldEnd()
17493 
    if self.sourceId is not None:
17494 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17495 
      oprot.writeI64(self.sourceId)
17496 
      oprot.writeFieldEnd()
17497 
    oprot.writeFieldStop()
17498 
    oprot.writeStructEnd()
17499 
 
17500 
  def validate(self):
17501 
    return
17502 
 
17503 
 
17504 
  def __repr__(self):
17505 
    L = ['%s=%r' % (key, value)
17506 
      for key, value in self.__dict__.iteritems()]
17507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17508 
 
17509 
  def __eq__(self, other):
17510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17511 
 
17512 
  def __ne__(self, other):
17513 
    return not (self == other)
17514 
 
17515 
class validateCartNew_result:
17516 
  """
17517 
  Attributes:
17518 
   - success
17519 
  """
17520 
 
17521 
  thrift_spec = (
17522 
    (0, TType.STRING, 'success', None, None, ), # 0
17523 
  )
17524 
 
17525 
  def __init__(self, success=None,):
17526 
    self.success = success
17527 
 
17528 
  def read(self, iprot):
17529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17531 
      return
17532 
    iprot.readStructBegin()
17533 
    while True:
17534 
      (fname, ftype, fid) = iprot.readFieldBegin()
17535 
      if ftype == TType.STOP:
17536 
        break
17537 
      if fid == 0:
17538 
        if ftype == TType.STRING:
17539 
          self.success = iprot.readString();
17540 
        else:
17541 
          iprot.skip(ftype)
17542 
      else:
17543 
        iprot.skip(ftype)
17544 
      iprot.readFieldEnd()
17545 
    iprot.readStructEnd()
17546 
 
17547 
  def write(self, oprot):
17548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17550 
      return
17551 
    oprot.writeStructBegin('validateCartNew_result')
17552 
    if self.success is not None:
17553 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17554 
      oprot.writeString(self.success)
17555 
      oprot.writeFieldEnd()
17556 
    oprot.writeFieldStop()
17557 
    oprot.writeStructEnd()
17558 
 
17559 
  def validate(self):
17560 
    return
17561 
 
17562 
 
17563 
  def __repr__(self):
17564 
    L = ['%s=%r' % (key, value)
17565 
      for key, value in self.__dict__.iteritems()]
17566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17567 
 
17568 
  def __eq__(self, other):
17569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17570 
 
17571 
  def __ne__(self, other):
17572 
    return not (self == other)
18530 manish.sha 17573 
 
18644 manish.sha 17574 
class isAddressEditableForCounter_args:
18530 manish.sha 17575 
  """
17576 
  Attributes:
17577 
   - userId
17578 
  """
17579 
 
17580 
  thrift_spec = (
17581 
    None, # 0
17582 
    (1, TType.I64, 'userId', None, None, ), # 1
17583 
  )
17584 
 
17585 
  def __init__(self, userId=None,):
17586 
    self.userId = userId
17587 
 
17588 
  def read(self, iprot):
17589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17591 
      return
17592 
    iprot.readStructBegin()
17593 
    while True:
17594 
      (fname, ftype, fid) = iprot.readFieldBegin()
17595 
      if ftype == TType.STOP:
17596 
        break
17597 
      if fid == 1:
17598 
        if ftype == TType.I64:
17599 
          self.userId = iprot.readI64();
17600 
        else:
17601 
          iprot.skip(ftype)
17602 
      else:
17603 
        iprot.skip(ftype)
17604 
      iprot.readFieldEnd()
17605 
    iprot.readStructEnd()
17606 
 
17607 
  def write(self, oprot):
17608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17610 
      return
18644 manish.sha 17611 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17612 
    if self.userId is not None:
17613 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17614 
      oprot.writeI64(self.userId)
17615 
      oprot.writeFieldEnd()
17616 
    oprot.writeFieldStop()
17617 
    oprot.writeStructEnd()
17618 
 
17619 
  def validate(self):
17620 
    return
17621 
 
17622 
 
17623 
  def __repr__(self):
17624 
    L = ['%s=%r' % (key, value)
17625 
      for key, value in self.__dict__.iteritems()]
17626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17627 
 
17628 
  def __eq__(self, other):
17629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17630 
 
17631 
  def __ne__(self, other):
17632 
    return not (self == other)
17633 
 
18644 manish.sha 17634 
class isAddressEditableForCounter_result:
18530 manish.sha 17635 
  """
17636 
  Attributes:
17637 
   - success
17638 
  """
17639 
 
17640 
  thrift_spec = (
17641 
    (0, TType.BOOL, 'success', None, None, ), # 0
17642 
  )
17643 
 
17644 
  def __init__(self, success=None,):
17645 
    self.success = success
17646 
 
17647 
  def read(self, iprot):
17648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17650 
      return
17651 
    iprot.readStructBegin()
17652 
    while True:
17653 
      (fname, ftype, fid) = iprot.readFieldBegin()
17654 
      if ftype == TType.STOP:
17655 
        break
17656 
      if fid == 0:
17657 
        if ftype == TType.BOOL:
17658 
          self.success = iprot.readBool();
17659 
        else:
17660 
          iprot.skip(ftype)
17661 
      else:
17662 
        iprot.skip(ftype)
17663 
      iprot.readFieldEnd()
17664 
    iprot.readStructEnd()
17665 
 
17666 
  def write(self, oprot):
17667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17669 
      return
18644 manish.sha 17670 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17671 
    if self.success is not None:
17672 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17673 
      oprot.writeBool(self.success)
17674 
      oprot.writeFieldEnd()
17675 
    oprot.writeFieldStop()
17676 
    oprot.writeStructEnd()
17677 
 
17678 
  def validate(self):
17679 
    return
17680 
 
17681 
 
17682 
  def __repr__(self):
17683 
    L = ['%s=%r' % (key, value)
17684 
      for key, value in self.__dict__.iteritems()]
17685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17686 
 
17687 
  def __eq__(self, other):
17688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17689 
 
17690 
  def __ne__(self, other):
17691 
    return not (self == other)
17692 
 
17693 
class getBillingAddressForUser_args:
17694 
  """
17695 
  Attributes:
17696 
   - userId
17697 
  """
17698 
 
17699 
  thrift_spec = (
17700 
    None, # 0
17701 
    (1, TType.I64, 'userId', None, None, ), # 1
17702 
  )
17703 
 
17704 
  def __init__(self, userId=None,):
17705 
    self.userId = userId
17706 
 
17707 
  def read(self, iprot):
17708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17710 
      return
17711 
    iprot.readStructBegin()
17712 
    while True:
17713 
      (fname, ftype, fid) = iprot.readFieldBegin()
17714 
      if ftype == TType.STOP:
17715 
        break
17716 
      if fid == 1:
17717 
        if ftype == TType.I64:
17718 
          self.userId = iprot.readI64();
17719 
        else:
17720 
          iprot.skip(ftype)
17721 
      else:
17722 
        iprot.skip(ftype)
17723 
      iprot.readFieldEnd()
17724 
    iprot.readStructEnd()
17725 
 
17726 
  def write(self, oprot):
17727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17729 
      return
17730 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17731 
    if self.userId is not None:
17732 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17733 
      oprot.writeI64(self.userId)
17734 
      oprot.writeFieldEnd()
17735 
    oprot.writeFieldStop()
17736 
    oprot.writeStructEnd()
17737 
 
17738 
  def validate(self):
17739 
    return
17740 
 
17741 
 
17742 
  def __repr__(self):
17743 
    L = ['%s=%r' % (key, value)
17744 
      for key, value in self.__dict__.iteritems()]
17745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17746 
 
17747 
  def __eq__(self, other):
17748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17749 
 
17750 
  def __ne__(self, other):
17751 
    return not (self == other)
17752 
 
17753 
class getBillingAddressForUser_result:
17754 
  """
17755 
  Attributes:
17756 
   - success
17757 
  """
17758 
 
17759 
  thrift_spec = (
17760 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17761 
  )
17762 
 
17763 
  def __init__(self, success=None,):
17764 
    self.success = success
17765 
 
17766 
  def read(self, iprot):
17767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17769 
      return
17770 
    iprot.readStructBegin()
17771 
    while True:
17772 
      (fname, ftype, fid) = iprot.readFieldBegin()
17773 
      if ftype == TType.STOP:
17774 
        break
17775 
      if fid == 0:
17776 
        if ftype == TType.STRUCT:
17777 
          self.success = Address()
17778 
          self.success.read(iprot)
17779 
        else:
17780 
          iprot.skip(ftype)
17781 
      else:
17782 
        iprot.skip(ftype)
17783 
      iprot.readFieldEnd()
17784 
    iprot.readStructEnd()
17785 
 
17786 
  def write(self, oprot):
17787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17789 
      return
17790 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17791 
    if self.success is not None:
17792 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17793 
      self.success.write(oprot)
17794 
      oprot.writeFieldEnd()
17795 
    oprot.writeFieldStop()
17796 
    oprot.writeStructEnd()
17797 
 
17798 
  def validate(self):
17799 
    return
17800 
 
17801 
 
17802 
  def __repr__(self):
17803 
    L = ['%s=%r' % (key, value)
17804 
      for key, value in self.__dict__.iteritems()]
17805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17806 
 
17807 
  def __eq__(self, other):
17808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17809 
 
17810 
  def __ne__(self, other):
17811 
    return not (self == other)
18590 manish.sha 17812 
 
17813 
class isCreditorAssigned_args:
17814 
  """
17815 
  Attributes:
17816 
   - userId
17817 
  """
17818 
 
17819 
  thrift_spec = (
17820 
    None, # 0
17821 
    (1, TType.I64, 'userId', None, None, ), # 1
17822 
  )
17823 
 
17824 
  def __init__(self, userId=None,):
17825 
    self.userId = userId
17826 
 
17827 
  def read(self, iprot):
17828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17830 
      return
17831 
    iprot.readStructBegin()
17832 
    while True:
17833 
      (fname, ftype, fid) = iprot.readFieldBegin()
17834 
      if ftype == TType.STOP:
17835 
        break
17836 
      if fid == 1:
17837 
        if ftype == TType.I64:
17838 
          self.userId = iprot.readI64();
17839 
        else:
17840 
          iprot.skip(ftype)
17841 
      else:
17842 
        iprot.skip(ftype)
17843 
      iprot.readFieldEnd()
17844 
    iprot.readStructEnd()
17845 
 
17846 
  def write(self, oprot):
17847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17849 
      return
17850 
    oprot.writeStructBegin('isCreditorAssigned_args')
17851 
    if self.userId is not None:
17852 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17853 
      oprot.writeI64(self.userId)
17854 
      oprot.writeFieldEnd()
17855 
    oprot.writeFieldStop()
17856 
    oprot.writeStructEnd()
17857 
 
17858 
  def validate(self):
17859 
    return
17860 
 
17861 
 
17862 
  def __repr__(self):
17863 
    L = ['%s=%r' % (key, value)
17864 
      for key, value in self.__dict__.iteritems()]
17865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17866 
 
17867 
  def __eq__(self, other):
17868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17869 
 
17870 
  def __ne__(self, other):
17871 
    return not (self == other)
17872 
 
17873 
class isCreditorAssigned_result:
17874 
  """
17875 
  Attributes:
17876 
   - success
17877 
  """
17878 
 
17879 
  thrift_spec = (
17880 
    (0, TType.BOOL, 'success', None, None, ), # 0
17881 
  )
17882 
 
17883 
  def __init__(self, success=None,):
17884 
    self.success = success
17885 
 
17886 
  def read(self, iprot):
17887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17889 
      return
17890 
    iprot.readStructBegin()
17891 
    while True:
17892 
      (fname, ftype, fid) = iprot.readFieldBegin()
17893 
      if ftype == TType.STOP:
17894 
        break
17895 
      if fid == 0:
17896 
        if ftype == TType.BOOL:
17897 
          self.success = iprot.readBool();
17898 
        else:
17899 
          iprot.skip(ftype)
17900 
      else:
17901 
        iprot.skip(ftype)
17902 
      iprot.readFieldEnd()
17903 
    iprot.readStructEnd()
17904 
 
17905 
  def write(self, oprot):
17906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17908 
      return
17909 
    oprot.writeStructBegin('isCreditorAssigned_result')
17910 
    if self.success is not None:
17911 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17912 
      oprot.writeBool(self.success)
17913 
      oprot.writeFieldEnd()
17914 
    oprot.writeFieldStop()
17915 
    oprot.writeStructEnd()
17916 
 
17917 
  def validate(self):
17918 
    return
17919 
 
17920 
 
17921 
  def __repr__(self):
17922 
    L = ['%s=%r' % (key, value)
17923 
      for key, value in self.__dict__.iteritems()]
17924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17925 
 
17926 
  def __eq__(self, other):
17927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17928 
 
17929 
  def __ne__(self, other):
17930 
    return not (self == other)
18735 manish.sha 17931 
 
17932 
class isTaxInvoiceEnabledUser_args:
17933 
  """
17934 
  Attributes:
17935 
   - userId
17936 
  """
17937 
 
17938 
  thrift_spec = (
17939 
    None, # 0
17940 
    (1, TType.I64, 'userId', None, None, ), # 1
17941 
  )
17942 
 
17943 
  def __init__(self, userId=None,):
17944 
    self.userId = userId
17945 
 
17946 
  def read(self, iprot):
17947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17949 
      return
17950 
    iprot.readStructBegin()
17951 
    while True:
17952 
      (fname, ftype, fid) = iprot.readFieldBegin()
17953 
      if ftype == TType.STOP:
17954 
        break
17955 
      if fid == 1:
17956 
        if ftype == TType.I64:
17957 
          self.userId = iprot.readI64();
17958 
        else:
17959 
          iprot.skip(ftype)
17960 
      else:
17961 
        iprot.skip(ftype)
17962 
      iprot.readFieldEnd()
17963 
    iprot.readStructEnd()
17964 
 
17965 
  def write(self, oprot):
17966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17968 
      return
17969 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17970 
    if self.userId is not None:
17971 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17972 
      oprot.writeI64(self.userId)
17973 
      oprot.writeFieldEnd()
17974 
    oprot.writeFieldStop()
17975 
    oprot.writeStructEnd()
17976 
 
17977 
  def validate(self):
17978 
    return
17979 
 
17980 
 
17981 
  def __repr__(self):
17982 
    L = ['%s=%r' % (key, value)
17983 
      for key, value in self.__dict__.iteritems()]
17984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17985 
 
17986 
  def __eq__(self, other):
17987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17988 
 
17989 
  def __ne__(self, other):
17990 
    return not (self == other)
17991 
 
17992 
class isTaxInvoiceEnabledUser_result:
17993 
  """
17994 
  Attributes:
17995 
   - success
17996 
  """
17997 
 
17998 
  thrift_spec = (
17999 
    (0, TType.BOOL, 'success', None, None, ), # 0
18000 
  )
18001 
 
18002 
  def __init__(self, success=None,):
18003 
    self.success = success
18004 
 
18005 
  def read(self, iprot):
18006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18008 
      return
18009 
    iprot.readStructBegin()
18010 
    while True:
18011 
      (fname, ftype, fid) = iprot.readFieldBegin()
18012 
      if ftype == TType.STOP:
18013 
        break
18014 
      if fid == 0:
18015 
        if ftype == TType.BOOL:
18016 
          self.success = iprot.readBool();
18017 
        else:
18018 
          iprot.skip(ftype)
18019 
      else:
18020 
        iprot.skip(ftype)
18021 
      iprot.readFieldEnd()
18022 
    iprot.readStructEnd()
18023 
 
18024 
  def write(self, oprot):
18025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18027 
      return
18028 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
18029 
    if self.success is not None:
18030 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18031 
      oprot.writeBool(self.success)
18032 
      oprot.writeFieldEnd()
18033 
    oprot.writeFieldStop()
18034 
    oprot.writeStructEnd()
18035 
 
18036 
  def validate(self):
18037 
    return
18038 
 
18039 
 
18040 
  def __repr__(self):
18041 
    L = ['%s=%r' % (key, value)
18042 
      for key, value in self.__dict__.iteritems()]
18043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18044 
 
18045 
  def __eq__(self, other):
18046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18047 
 
18048 
  def __ne__(self, other):
18049 
    return not (self == other)
18764 kshitij.so 18050 
 
19182 amit.gupta 18051 
class taxInvoiceAvailable_args:
18052 
  """
18053 
  Attributes:
18054 
   - addressId
18055 
  """
18056 
 
18057 
  thrift_spec = (
18058 
    None, # 0
18059 
    (1, TType.I64, 'addressId', None, None, ), # 1
18060 
  )
18061 
 
18062 
  def __init__(self, addressId=None,):
18063 
    self.addressId = addressId
18064 
 
18065 
  def read(self, iprot):
18066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18068 
      return
18069 
    iprot.readStructBegin()
18070 
    while True:
18071 
      (fname, ftype, fid) = iprot.readFieldBegin()
18072 
      if ftype == TType.STOP:
18073 
        break
18074 
      if fid == 1:
18075 
        if ftype == TType.I64:
18076 
          self.addressId = iprot.readI64();
18077 
        else:
18078 
          iprot.skip(ftype)
18079 
      else:
18080 
        iprot.skip(ftype)
18081 
      iprot.readFieldEnd()
18082 
    iprot.readStructEnd()
18083 
 
18084 
  def write(self, oprot):
18085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18087 
      return
18088 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
18089 
    if self.addressId is not None:
18090 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
18091 
      oprot.writeI64(self.addressId)
18092 
      oprot.writeFieldEnd()
18093 
    oprot.writeFieldStop()
18094 
    oprot.writeStructEnd()
18095 
 
18096 
  def validate(self):
18097 
    return
18098 
 
18099 
 
18100 
  def __repr__(self):
18101 
    L = ['%s=%r' % (key, value)
18102 
      for key, value in self.__dict__.iteritems()]
18103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18104 
 
18105 
  def __eq__(self, other):
18106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18107 
 
18108 
  def __ne__(self, other):
18109 
    return not (self == other)
18110 
 
18111 
class taxInvoiceAvailable_result:
18112 
  """
18113 
  Attributes:
18114 
   - success
18115 
  """
18116 
 
18117 
  thrift_spec = (
18118 
    (0, TType.BOOL, 'success', None, None, ), # 0
18119 
  )
18120 
 
18121 
  def __init__(self, success=None,):
18122 
    self.success = success
18123 
 
18124 
  def read(self, iprot):
18125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18127 
      return
18128 
    iprot.readStructBegin()
18129 
    while True:
18130 
      (fname, ftype, fid) = iprot.readFieldBegin()
18131 
      if ftype == TType.STOP:
18132 
        break
18133 
      if fid == 0:
18134 
        if ftype == TType.BOOL:
18135 
          self.success = iprot.readBool();
18136 
        else:
18137 
          iprot.skip(ftype)
18138 
      else:
18139 
        iprot.skip(ftype)
18140 
      iprot.readFieldEnd()
18141 
    iprot.readStructEnd()
18142 
 
18143 
  def write(self, oprot):
18144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18146 
      return
18147 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
18148 
    if self.success is not None:
18149 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18150 
      oprot.writeBool(self.success)
18151 
      oprot.writeFieldEnd()
18152 
    oprot.writeFieldStop()
18153 
    oprot.writeStructEnd()
18154 
 
18155 
  def validate(self):
18156 
    return
18157 
 
18158 
 
18159 
  def __repr__(self):
18160 
    L = ['%s=%r' % (key, value)
18161 
      for key, value in self.__dict__.iteritems()]
18162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18163 
 
18164 
  def __eq__(self, other):
18165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18166 
 
18167 
  def __ne__(self, other):
18168 
    return not (self == other)
18169 
 
18764 kshitij.so 18170 
class getCartByValue_args:
18171 
  """
18172 
  Attributes:
18173 
   - cartIds
18174 
  """
18175 
 
18176 
  thrift_spec = (
18177 
    None, # 0
18178 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
18179 
  )
18180 
 
18181 
  def __init__(self, cartIds=None,):
18182 
    self.cartIds = cartIds
18183 
 
18184 
  def read(self, iprot):
18185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18187 
      return
18188 
    iprot.readStructBegin()
18189 
    while True:
18190 
      (fname, ftype, fid) = iprot.readFieldBegin()
18191 
      if ftype == TType.STOP:
18192 
        break
18193 
      if fid == 1:
18194 
        if ftype == TType.LIST:
18195 
          self.cartIds = []
18196 
          (_etype258, _size255) = iprot.readListBegin()
18197 
          for _i259 in xrange(_size255):
18198 
            _elem260 = iprot.readI64();
18199 
            self.cartIds.append(_elem260)
18200 
          iprot.readListEnd()
18201 
        else:
18202 
          iprot.skip(ftype)
18203 
      else:
18204 
        iprot.skip(ftype)
18205 
      iprot.readFieldEnd()
18206 
    iprot.readStructEnd()
18207 
 
18208 
  def write(self, oprot):
18209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18211 
      return
18212 
    oprot.writeStructBegin('getCartByValue_args')
18213 
    if self.cartIds is not None:
18214 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
18215 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
18216 
      for iter261 in self.cartIds:
18217 
        oprot.writeI64(iter261)
18218 
      oprot.writeListEnd()
18219 
      oprot.writeFieldEnd()
18220 
    oprot.writeFieldStop()
18221 
    oprot.writeStructEnd()
18222 
 
18223 
  def validate(self):
18224 
    return
18225 
 
18226 
 
18227 
  def __repr__(self):
18228 
    L = ['%s=%r' % (key, value)
18229 
      for key, value in self.__dict__.iteritems()]
18230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18231 
 
18232 
  def __eq__(self, other):
18233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18234 
 
18235 
  def __ne__(self, other):
18236 
    return not (self == other)
18237 
 
18238 
class getCartByValue_result:
18239 
  """
18240 
  Attributes:
18241 
   - success
18242 
  """
18243 
 
18244 
  thrift_spec = (
18245 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
18246 
  )
18247 
 
18248 
  def __init__(self, success=None,):
18249 
    self.success = success
18250 
 
18251 
  def read(self, iprot):
18252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18254 
      return
18255 
    iprot.readStructBegin()
18256 
    while True:
18257 
      (fname, ftype, fid) = iprot.readFieldBegin()
18258 
      if ftype == TType.STOP:
18259 
        break
18260 
      if fid == 0:
18261 
        if ftype == TType.MAP:
18262 
          self.success = {}
18263 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
18264 
          for _i266 in xrange(_size262):
18265 
            _key267 = iprot.readI64();
18266 
            _val268 = []
18267 
            (_etype272, _size269) = iprot.readListBegin()
18268 
            for _i273 in xrange(_size269):
18269 
              _elem274 = Line()
18270 
              _elem274.read(iprot)
18271 
              _val268.append(_elem274)
18272 
            iprot.readListEnd()
18273 
            self.success[_key267] = _val268
18274 
          iprot.readMapEnd()
18275 
        else:
18276 
          iprot.skip(ftype)
18277 
      else:
18278 
        iprot.skip(ftype)
18279 
      iprot.readFieldEnd()
18280 
    iprot.readStructEnd()
18281 
 
18282 
  def write(self, oprot):
18283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18285 
      return
18286 
    oprot.writeStructBegin('getCartByValue_result')
18287 
    if self.success is not None:
18288 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18289 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
18290 
      for kiter275,viter276 in self.success.items():
18291 
        oprot.writeI64(kiter275)
18292 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
18293 
        for iter277 in viter276:
18294 
          iter277.write(oprot)
18295 
        oprot.writeListEnd()
18296 
      oprot.writeMapEnd()
18297 
      oprot.writeFieldEnd()
18298 
    oprot.writeFieldStop()
18299 
    oprot.writeStructEnd()
18300 
 
18301 
  def validate(self):
18302 
    return
18303 
 
18304 
 
18305 
  def __repr__(self):
18306 
    L = ['%s=%r' % (key, value)
18307 
      for key, value in self.__dict__.iteritems()]
18308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18309 
 
18310 
  def __eq__(self, other):
18311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18312 
 
18313 
  def __ne__(self, other):
18314 
    return not (self == other)
19889 manas 18315 
 
18316 
class getCounterName_args:
18317 
  """
18318 
  Attributes:
18319 
   - userIds
18320 
  """
18321 
 
18322 
  thrift_spec = (
18323 
    None, # 0
18324 
    (1, TType.LIST, 'userIds', (TType.I64,None), None, ), # 1
18325 
  )
18326 
 
18327 
  def __init__(self, userIds=None,):
18328 
    self.userIds = userIds
18329 
 
18330 
  def read(self, iprot):
18331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18333 
      return
18334 
    iprot.readStructBegin()
18335 
    while True:
18336 
      (fname, ftype, fid) = iprot.readFieldBegin()
18337 
      if ftype == TType.STOP:
18338 
        break
18339 
      if fid == 1:
18340 
        if ftype == TType.LIST:
18341 
          self.userIds = []
18342 
          (_etype281, _size278) = iprot.readListBegin()
18343 
          for _i282 in xrange(_size278):
18344 
            _elem283 = iprot.readI64();
18345 
            self.userIds.append(_elem283)
18346 
          iprot.readListEnd()
18347 
        else:
18348 
          iprot.skip(ftype)
18349 
      else:
18350 
        iprot.skip(ftype)
18351 
      iprot.readFieldEnd()
18352 
    iprot.readStructEnd()
18353 
 
18354 
  def write(self, oprot):
18355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18357 
      return
18358 
    oprot.writeStructBegin('getCounterName_args')
18359 
    if self.userIds is not None:
18360 
      oprot.writeFieldBegin('userIds', TType.LIST, 1)
18361 
      oprot.writeListBegin(TType.I64, len(self.userIds))
18362 
      for iter284 in self.userIds:
18363 
        oprot.writeI64(iter284)
18364 
      oprot.writeListEnd()
18365 
      oprot.writeFieldEnd()
18366 
    oprot.writeFieldStop()
18367 
    oprot.writeStructEnd()
18368 
 
18369 
  def validate(self):
18370 
    return
18371 
 
18372 
 
18373 
  def __repr__(self):
18374 
    L = ['%s=%r' % (key, value)
18375 
      for key, value in self.__dict__.iteritems()]
18376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18377 
 
18378 
  def __eq__(self, other):
18379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18380 
 
18381 
  def __ne__(self, other):
18382 
    return not (self == other)
18383 
 
18384 
class getCounterName_result:
18385 
  """
18386 
  Attributes:
18387 
   - success
18388 
  """
18389 
 
18390 
  thrift_spec = (
18391 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18392 
  )
18393 
 
18394 
  def __init__(self, success=None,):
18395 
    self.success = success
18396 
 
18397 
  def read(self, iprot):
18398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18400 
      return
18401 
    iprot.readStructBegin()
18402 
    while True:
18403 
      (fname, ftype, fid) = iprot.readFieldBegin()
18404 
      if ftype == TType.STOP:
18405 
        break
18406 
      if fid == 0:
18407 
        if ftype == TType.MAP:
18408 
          self.success = {}
18409 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
18410 
          for _i289 in xrange(_size285):
18411 
            _key290 = iprot.readI64();
18412 
            _val291 = iprot.readString();
18413 
            self.success[_key290] = _val291
18414 
          iprot.readMapEnd()
18415 
        else:
18416 
          iprot.skip(ftype)
18417 
      else:
18418 
        iprot.skip(ftype)
18419 
      iprot.readFieldEnd()
18420 
    iprot.readStructEnd()
18421 
 
18422 
  def write(self, oprot):
18423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18425 
      return
18426 
    oprot.writeStructBegin('getCounterName_result')
18427 
    if self.success is not None:
18428 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18429 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
18430 
      for kiter292,viter293 in self.success.items():
18431 
        oprot.writeI64(kiter292)
18432 
        oprot.writeString(viter293)
18433 
      oprot.writeMapEnd()
18434 
      oprot.writeFieldEnd()
18435 
    oprot.writeFieldStop()
18436 
    oprot.writeStructEnd()
18437 
 
18438 
  def validate(self):
18439 
    return
18440 
 
18441 
 
18442 
  def __repr__(self):
18443 
    L = ['%s=%r' % (key, value)
18444 
      for key, value in self.__dict__.iteritems()]
18445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18446 
 
18447 
  def __eq__(self, other):
18448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18449 
 
18450 
  def __ne__(self, other):
18451 
    return not (self == other)
20873 kshitij.so 18452 
 
18453 
class setWalletAmountInCart_args:
18454 
  """
18455 
  Attributes:
18456 
   - cartId
18457 
   - wallet_amount
18458 
  """
18459 
 
18460 
  thrift_spec = (
18461 
    None, # 0
18462 
    (1, TType.I64, 'cartId', None, None, ), # 1
18463 
    (2, TType.DOUBLE, 'wallet_amount', None, None, ), # 2
18464 
  )
18465 
 
18466 
  def __init__(self, cartId=None, wallet_amount=None,):
18467 
    self.cartId = cartId
18468 
    self.wallet_amount = wallet_amount
18469 
 
18470 
  def read(self, iprot):
18471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18473 
      return
18474 
    iprot.readStructBegin()
18475 
    while True:
18476 
      (fname, ftype, fid) = iprot.readFieldBegin()
18477 
      if ftype == TType.STOP:
18478 
        break
18479 
      if fid == 1:
18480 
        if ftype == TType.I64:
18481 
          self.cartId = iprot.readI64();
18482 
        else:
18483 
          iprot.skip(ftype)
18484 
      elif fid == 2:
18485 
        if ftype == TType.DOUBLE:
18486 
          self.wallet_amount = iprot.readDouble();
18487 
        else:
18488 
          iprot.skip(ftype)
18489 
      else:
18490 
        iprot.skip(ftype)
18491 
      iprot.readFieldEnd()
18492 
    iprot.readStructEnd()
18493 
 
18494 
  def write(self, oprot):
18495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18497 
      return
18498 
    oprot.writeStructBegin('setWalletAmountInCart_args')
18499 
    if self.cartId is not None:
18500 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
18501 
      oprot.writeI64(self.cartId)
18502 
      oprot.writeFieldEnd()
18503 
    if self.wallet_amount is not None:
18504 
      oprot.writeFieldBegin('wallet_amount', TType.DOUBLE, 2)
18505 
      oprot.writeDouble(self.wallet_amount)
18506 
      oprot.writeFieldEnd()
18507 
    oprot.writeFieldStop()
18508 
    oprot.writeStructEnd()
18509 
 
18510 
  def validate(self):
18511 
    return
18512 
 
18513 
 
18514 
  def __repr__(self):
18515 
    L = ['%s=%r' % (key, value)
18516 
      for key, value in self.__dict__.iteritems()]
18517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18518 
 
18519 
  def __eq__(self, other):
18520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18521 
 
18522 
  def __ne__(self, other):
18523 
    return not (self == other)
18524 
 
18525 
class setWalletAmountInCart_result:
18526 
  """
18527 
  Attributes:
18528 
   - success
18529 
  """
18530 
 
18531 
  thrift_spec = (
18532 
    (0, TType.BOOL, 'success', None, None, ), # 0
18533 
  )
18534 
 
18535 
  def __init__(self, success=None,):
18536 
    self.success = success
18537 
 
18538 
  def read(self, iprot):
18539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18541 
      return
18542 
    iprot.readStructBegin()
18543 
    while True:
18544 
      (fname, ftype, fid) = iprot.readFieldBegin()
18545 
      if ftype == TType.STOP:
18546 
        break
18547 
      if fid == 0:
18548 
        if ftype == TType.BOOL:
18549 
          self.success = iprot.readBool();
18550 
        else:
18551 
          iprot.skip(ftype)
18552 
      else:
18553 
        iprot.skip(ftype)
18554 
      iprot.readFieldEnd()
18555 
    iprot.readStructEnd()
18556 
 
18557 
  def write(self, oprot):
18558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18560 
      return
18561 
    oprot.writeStructBegin('setWalletAmountInCart_result')
18562 
    if self.success is not None:
18563 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18564 
      oprot.writeBool(self.success)
18565 
      oprot.writeFieldEnd()
18566 
    oprot.writeFieldStop()
18567 
    oprot.writeStructEnd()
18568 
 
18569 
  def validate(self):
18570 
    return
18571 
 
18572 
 
18573 
  def __repr__(self):
18574 
    L = ['%s=%r' % (key, value)
18575 
      for key, value in self.__dict__.iteritems()]
18576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18577 
 
18578 
  def __eq__(self, other):
18579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18580 
 
18581 
  def __ne__(self, other):
18582 
    return not (self == other)