Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
18977 amit.gupta 713 
  def getCounterByUserId(self, userId):
714 
    """
715 
    Parameters:
716 
     - userId
717 
    """
718 
    pass
719 
 
12722 amit.gupta 720 
  def getAllUsersByCounter(self, counterId):
721 
    """
722 
    Parameters:
723 
     - counterId
724 
    """
725 
    pass
726 
 
15251 manish.sha 727 
  def getActiveAccessTokenForUser(self, userId, source):
728 
    """
729 
    Parameters:
730 
     - userId
731 
     - source
732 
    """
733 
    pass
12722 amit.gupta 734 
 
15251 manish.sha 735 
  def validateAccessToken(self, accessToken):
736 
    """
737 
    Parameters:
738 
     - accessToken
739 
    """
740 
    pass
741 
 
17782 amit.gupta 742 
  def addItemsToCart(self, cartId, itemQty, couponCode):
743 
    """
744 
    Parameters:
745 
     - cartId
746 
     - itemQty
747 
     - couponCode
748 
    """
749 
    pass
15251 manish.sha 750 
 
17782 amit.gupta 751 
  def validateCartNew(self, cartId, pinCode, sourceId):
752 
    """
753 
    Parameters:
754 
     - cartId
755 
     - pinCode
756 
     - sourceId
757 
    """
758 
    pass
759 
 
18644 manish.sha 760 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 761 
    """
762 
    Parameters:
763 
     - userId
764 
    """
765 
    pass
17782 amit.gupta 766 
 
18530 manish.sha 767 
  def getBillingAddressForUser(self, userId):
768 
    """
769 
    Parameters:
770 
     - userId
771 
    """
772 
    pass
773 
 
18590 manish.sha 774 
  def isCreditorAssigned(self, userId):
775 
    """
776 
    Parameters:
777 
     - userId
778 
    """
779 
    pass
18530 manish.sha 780 
 
18735 manish.sha 781 
  def isTaxInvoiceEnabledUser(self, userId):
782 
    """
783 
    Parameters:
784 
     - userId
785 
    """
786 
    pass
18590 manish.sha 787 
 
19182 amit.gupta 788 
  def taxInvoiceAvailable(self, addressId):
789 
    """
790 
    Parameters:
791 
     - addressId
792 
    """
793 
    pass
794 
 
18764 kshitij.so 795 
  def getCartByValue(self, cartIds):
796 
    """
797 
    Parameters:
798 
     - cartIds
799 
    """
800 
    pass
18735 manish.sha 801 
 
19889 manas 802 
  def getCounterName(self, userIds):
803 
    """
804 
    Parameters:
805 
     - userIds
806 
    """
807 
    pass
18764 kshitij.so 808 
 
19889 manas 809 
 
3376 rajveer 810 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 811 
  """
812 
  service
813 
  """
814 
  def __init__(self, iprot, oprot=None):
3376 rajveer 815 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 816 
 
559 chandransh 817 
  def createAnonymousUser(self, jsessionId):
94 ashish 818 
    """
819 
    Parameters:
559 chandransh 820 
     - jsessionId
94 ashish 821 
    """
559 chandransh 822 
    self.send_createAnonymousUser(jsessionId)
823 
    return self.recv_createAnonymousUser()
94 ashish 824 
 
559 chandransh 825 
  def send_createAnonymousUser(self, jsessionId):
826 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
827 
    args = createAnonymousUser_args()
828 
    args.jsessionId = jsessionId
94 ashish 829 
    args.write(self._oprot)
830 
    self._oprot.writeMessageEnd()
831 
    self._oprot.trans.flush()
832 
 
559 chandransh 833 
  def recv_createAnonymousUser(self, ):
94 ashish 834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
835 
    if mtype == TMessageType.EXCEPTION:
836 
      x = TApplicationException()
837 
      x.read(self._iprot)
838 
      self._iprot.readMessageEnd()
839 
      raise x
559 chandransh 840 
    result = createAnonymousUser_result()
94 ashish 841 
    result.read(self._iprot)
842 
    self._iprot.readMessageEnd()
3431 rajveer 843 
    if result.success is not None:
94 ashish 844 
      return result.success
3431 rajveer 845 
    if result.ucex is not None:
559 chandransh 846 
      raise result.ucex
847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 848 
 
559 chandransh 849 
  def getUserById(self, userId):
94 ashish 850 
    """
851 
    Parameters:
852 
     - userId
853 
    """
559 chandransh 854 
    self.send_getUserById(userId)
855 
    return self.recv_getUserById()
94 ashish 856 
 
559 chandransh 857 
  def send_getUserById(self, userId):
858 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
859 
    args = getUserById_args()
94 ashish 860 
    args.userId = userId
861 
    args.write(self._oprot)
862 
    self._oprot.writeMessageEnd()
863 
    self._oprot.trans.flush()
864 
 
559 chandransh 865 
  def recv_getUserById(self, ):
94 ashish 866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
867 
    if mtype == TMessageType.EXCEPTION:
868 
      x = TApplicationException()
869 
      x.read(self._iprot)
870 
      self._iprot.readMessageEnd()
871 
      raise x
559 chandransh 872 
    result = getUserById_result()
94 ashish 873 
    result.read(self._iprot)
874 
    self._iprot.readMessageEnd()
3431 rajveer 875 
    if result.success is not None:
94 ashish 876 
      return result.success
3431 rajveer 877 
    if result.ucex is not None:
559 chandransh 878 
      raise result.ucex
879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 880 
 
5326 rajveer 881 
  def getUserByCartId(self, cartId):
882 
    """
883 
    Parameters:
884 
     - cartId
885 
    """
886 
    self.send_getUserByCartId(cartId)
887 
    return self.recv_getUserByCartId()
888 
 
889 
  def send_getUserByCartId(self, cartId):
890 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
891 
    args = getUserByCartId_args()
892 
    args.cartId = cartId
893 
    args.write(self._oprot)
894 
    self._oprot.writeMessageEnd()
895 
    self._oprot.trans.flush()
896 
 
897 
  def recv_getUserByCartId(self, ):
898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
899 
    if mtype == TMessageType.EXCEPTION:
900 
      x = TApplicationException()
901 
      x.read(self._iprot)
902 
      self._iprot.readMessageEnd()
903 
      raise x
904 
    result = getUserByCartId_result()
905 
    result.read(self._iprot)
906 
    self._iprot.readMessageEnd()
907 
    if result.success is not None:
908 
      return result.success
909 
    if result.ucex is not None:
910 
      raise result.ucex
911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
912 
 
1491 vikas 913 
  def getUserByEmail(self, email):
914 
    """
915 
    Parameters:
916 
     - email
917 
    """
918 
    self.send_getUserByEmail(email)
919 
    return self.recv_getUserByEmail()
920 
 
921 
  def send_getUserByEmail(self, email):
922 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
923 
    args = getUserByEmail_args()
924 
    args.email = email
925 
    args.write(self._oprot)
926 
    self._oprot.writeMessageEnd()
927 
    self._oprot.trans.flush()
928 
 
929 
  def recv_getUserByEmail(self, ):
930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
931 
    if mtype == TMessageType.EXCEPTION:
932 
      x = TApplicationException()
933 
      x.read(self._iprot)
934 
      self._iprot.readMessageEnd()
935 
      raise x
936 
    result = getUserByEmail_result()
937 
    result.read(self._iprot)
938 
    self._iprot.readMessageEnd()
3431 rajveer 939 
    if result.success is not None:
1491 vikas 940 
      return result.success
3431 rajveer 941 
    if result.ucex is not None:
1491 vikas 942 
      raise result.ucex
943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
944 
 
3032 mandeep.dh 945 
  def getUserByMobileNumber(self, mobileNumber):
946 
    """
947 
    Parameters:
948 
     - mobileNumber
949 
    """
950 
    self.send_getUserByMobileNumber(mobileNumber)
951 
    return self.recv_getUserByMobileNumber()
952 
 
953 
  def send_getUserByMobileNumber(self, mobileNumber):
954 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
955 
    args = getUserByMobileNumber_args()
956 
    args.mobileNumber = mobileNumber
957 
    args.write(self._oprot)
958 
    self._oprot.writeMessageEnd()
959 
    self._oprot.trans.flush()
960 
 
961 
  def recv_getUserByMobileNumber(self, ):
962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
963 
    if mtype == TMessageType.EXCEPTION:
964 
      x = TApplicationException()
965 
      x.read(self._iprot)
966 
      self._iprot.readMessageEnd()
967 
      raise x
968 
    result = getUserByMobileNumber_result()
969 
    result.read(self._iprot)
970 
    self._iprot.readMessageEnd()
3431 rajveer 971 
    if result.success is not None:
3032 mandeep.dh 972 
      return result.success
3431 rajveer 973 
    if result.ucex is not None:
3032 mandeep.dh 974 
      raise result.ucex
975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
976 
 
559 chandransh 977 
  def createUser(self, user):
94 ashish 978 
    """
979 
    Parameters:
559 chandransh 980 
     - user
94 ashish 981 
    """
559 chandransh 982 
    self.send_createUser(user)
983 
    return self.recv_createUser()
94 ashish 984 
 
559 chandransh 985 
  def send_createUser(self, user):
986 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
987 
    args = createUser_args()
988 
    args.user = user
94 ashish 989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
559 chandransh 993 
  def recv_createUser(self, ):
94 ashish 994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
559 chandransh 1000 
    result = createUser_result()
94 ashish 1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
3431 rajveer 1003 
    if result.success is not None:
94 ashish 1004 
      return result.success
3431 rajveer 1005 
    if result.ucex is not None:
559 chandransh 1006 
      raise result.ucex
1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1008 
 
559 chandransh 1009 
  def updateUser(self, user):
94 ashish 1010 
    """
1011 
    Parameters:
559 chandransh 1012 
     - user
94 ashish 1013 
    """
559 chandransh 1014 
    self.send_updateUser(user)
1015 
    return self.recv_updateUser()
94 ashish 1016 
 
559 chandransh 1017 
  def send_updateUser(self, user):
1018 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1019 
    args = updateUser_args()
1020 
    args.user = user
94 ashish 1021 
    args.write(self._oprot)
1022 
    self._oprot.writeMessageEnd()
1023 
    self._oprot.trans.flush()
1024 
 
559 chandransh 1025 
  def recv_updateUser(self, ):
94 ashish 1026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1027 
    if mtype == TMessageType.EXCEPTION:
1028 
      x = TApplicationException()
1029 
      x.read(self._iprot)
1030 
      self._iprot.readMessageEnd()
1031 
      raise x
559 chandransh 1032 
    result = updateUser_result()
94 ashish 1033 
    result.read(self._iprot)
1034 
    self._iprot.readMessageEnd()
3431 rajveer 1035 
    if result.success is not None:
94 ashish 1036 
      return result.success
3431 rajveer 1037 
    if result.ucex is not None:
559 chandransh 1038 
      raise result.ucex
1039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1040 
 
559 chandransh 1041 
  def authenticateUser(self, email, password):
94 ashish 1042 
    """
1043 
    Parameters:
1044 
     - email
1045 
     - password
1046 
    """
559 chandransh 1047 
    self.send_authenticateUser(email, password)
122 ashish 1048 
    return self.recv_authenticateUser()
1049 
 
559 chandransh 1050 
  def send_authenticateUser(self, email, password):
122 ashish 1051 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1052 
    args = authenticateUser_args()
559 chandransh 1053 
    args.email = email
122 ashish 1054 
    args.password = password
1055 
    args.write(self._oprot)
1056 
    self._oprot.writeMessageEnd()
1057 
    self._oprot.trans.flush()
1058 
 
1059 
  def recv_authenticateUser(self, ):
1060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1061 
    if mtype == TMessageType.EXCEPTION:
1062 
      x = TApplicationException()
1063 
      x.read(self._iprot)
1064 
      self._iprot.readMessageEnd()
1065 
      raise x
1066 
    result = authenticateUser_result()
1067 
    result.read(self._iprot)
1068 
    self._iprot.readMessageEnd()
3431 rajveer 1069 
    if result.success is not None:
122 ashish 1070 
      return result.success
3431 rajveer 1071 
    if result.auex is not None:
559 chandransh 1072 
      raise result.auex
122 ashish 1073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1074 
 
94 ashish 1075 
  def userExists(self, email):
1076 
    """
1077 
    Parameters:
1078 
     - email
1079 
    """
1080 
    self.send_userExists(email)
1081 
    return self.recv_userExists()
1082 
 
1083 
  def send_userExists(self, email):
1084 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1085 
    args = userExists_args()
1086 
    args.email = email
1087 
    args.write(self._oprot)
1088 
    self._oprot.writeMessageEnd()
1089 
    self._oprot.trans.flush()
1090 
 
1091 
  def recv_userExists(self, ):
1092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1093 
    if mtype == TMessageType.EXCEPTION:
1094 
      x = TApplicationException()
1095 
      x.read(self._iprot)
1096 
      self._iprot.readMessageEnd()
1097 
      raise x
1098 
    result = userExists_result()
1099 
    result.read(self._iprot)
1100 
    self._iprot.readMessageEnd()
3431 rajveer 1101 
    if result.success is not None:
94 ashish 1102 
      return result.success
3431 rajveer 1103 
    if result.ucx is not None:
94 ashish 1104 
      raise result.ucx
1105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1106 
 
567 rajveer 1107 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1108 
    """
1109 
    Parameters:
1110 
     - userId
1111 
     - address
513 rajveer 1112 
     - setDefault
94 ashish 1113 
    """
567 rajveer 1114 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1115 
    return self.recv_addAddressForUser()
1116 
 
567 rajveer 1117 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1118 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1119 
    args = addAddressForUser_args()
559 chandransh 1120 
    args.userId = userId
94 ashish 1121 
    args.address = address
513 rajveer 1122 
    args.setDefault = setDefault
94 ashish 1123 
    args.write(self._oprot)
1124 
    self._oprot.writeMessageEnd()
1125 
    self._oprot.trans.flush()
1126 
 
1127 
  def recv_addAddressForUser(self, ):
1128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1129 
    if mtype == TMessageType.EXCEPTION:
1130 
      x = TApplicationException()
1131 
      x.read(self._iprot)
1132 
      self._iprot.readMessageEnd()
1133 
      raise x
1134 
    result = addAddressForUser_result()
1135 
    result.read(self._iprot)
1136 
    self._iprot.readMessageEnd()
3431 rajveer 1137 
    if result.success is not None:
94 ashish 1138 
      return result.success
3431 rajveer 1139 
    if result.ucx is not None:
94 ashish 1140 
      raise result.ucx
1141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1142 
 
1143 
  def removeAddressForUser(self, userid, addressId):
1144 
    """
1145 
    Parameters:
1146 
     - userid
1147 
     - addressId
1148 
    """
1149 
    self.send_removeAddressForUser(userid, addressId)
1150 
    return self.recv_removeAddressForUser()
1151 
 
1152 
  def send_removeAddressForUser(self, userid, addressId):
1153 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1154 
    args = removeAddressForUser_args()
1155 
    args.userid = userid
1156 
    args.addressId = addressId
1157 
    args.write(self._oprot)
1158 
    self._oprot.writeMessageEnd()
1159 
    self._oprot.trans.flush()
1160 
 
1161 
  def recv_removeAddressForUser(self, ):
1162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1163 
    if mtype == TMessageType.EXCEPTION:
1164 
      x = TApplicationException()
1165 
      x.read(self._iprot)
1166 
      self._iprot.readMessageEnd()
1167 
      raise x
1168 
    result = removeAddressForUser_result()
1169 
    result.read(self._iprot)
1170 
    self._iprot.readMessageEnd()
3431 rajveer 1171 
    if result.success is not None:
94 ashish 1172 
      return result.success
3431 rajveer 1173 
    if result.ucx is not None:
94 ashish 1174 
      raise result.ucx
1175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1176 
 
1177 
  def setUserAsLoggedIn(self, userId, timestamp):
1178 
    """
1179 
    Parameters:
1180 
     - userId
1181 
     - timestamp
1182 
    """
1183 
    self.send_setUserAsLoggedIn(userId, timestamp)
1184 
    return self.recv_setUserAsLoggedIn()
1185 
 
1186 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1187 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1188 
    args = setUserAsLoggedIn_args()
1189 
    args.userId = userId
1190 
    args.timestamp = timestamp
1191 
    args.write(self._oprot)
1192 
    self._oprot.writeMessageEnd()
1193 
    self._oprot.trans.flush()
1194 
 
1195 
  def recv_setUserAsLoggedIn(self, ):
1196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1197 
    if mtype == TMessageType.EXCEPTION:
1198 
      x = TApplicationException()
1199 
      x.read(self._iprot)
1200 
      self._iprot.readMessageEnd()
1201 
      raise x
1202 
    result = setUserAsLoggedIn_result()
1203 
    result.read(self._iprot)
1204 
    self._iprot.readMessageEnd()
3431 rajveer 1205 
    if result.success is not None:
94 ashish 1206 
      return result.success
3431 rajveer 1207 
    if result.ucx is not None:
94 ashish 1208 
      raise result.ucx
1209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1210 
 
1211 
  def setUserAsLoggedOut(self, userid, timestamp):
1212 
    """
1213 
    Parameters:
1214 
     - userid
1215 
     - timestamp
1216 
    """
1217 
    self.send_setUserAsLoggedOut(userid, timestamp)
1218 
    return self.recv_setUserAsLoggedOut()
1219 
 
1220 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1221 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1222 
    args = setUserAsLoggedOut_args()
1223 
    args.userid = userid
1224 
    args.timestamp = timestamp
1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_setUserAsLoggedOut(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = setUserAsLoggedOut_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
3431 rajveer 1239 
    if result.success is not None:
94 ashish 1240 
      return result.success
3431 rajveer 1241 
    if result.ucx is not None:
94 ashish 1242 
      raise result.ucx
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1244 
 
504 rajveer 1245 
  def setDefaultAddress(self, userid, addressId):
1246 
    """
1247 
    Parameters:
1248 
     - userid
1249 
     - addressId
1250 
    """
1251 
    self.send_setDefaultAddress(userid, addressId)
1252 
    return self.recv_setDefaultAddress()
1253 
 
1254 
  def send_setDefaultAddress(self, userid, addressId):
1255 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1256 
    args = setDefaultAddress_args()
1257 
    args.userid = userid
1258 
    args.addressId = addressId
1259 
    args.write(self._oprot)
1260 
    self._oprot.writeMessageEnd()
1261 
    self._oprot.trans.flush()
1262 
 
1263 
  def recv_setDefaultAddress(self, ):
1264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1265 
    if mtype == TMessageType.EXCEPTION:
1266 
      x = TApplicationException()
1267 
      x.read(self._iprot)
1268 
      self._iprot.readMessageEnd()
1269 
      raise x
1270 
    result = setDefaultAddress_result()
1271 
    result.read(self._iprot)
1272 
    self._iprot.readMessageEnd()
3431 rajveer 1273 
    if result.success is not None:
504 rajveer 1274 
      return result.success
3431 rajveer 1275 
    if result.ucx is not None:
504 rajveer 1276 
      raise result.ucx
1277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1278 
 
594 rajveer 1279 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1280 
    """
1281 
    Parameters:
1282 
     - userid
594 rajveer 1283 
     - oldPassword
1284 
     - newPassword
94 ashish 1285 
    """
594 rajveer 1286 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1287 
    return self.recv_updatePassword()
1288 
 
594 rajveer 1289 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1290 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1291 
    args = updatePassword_args()
1292 
    args.userid = userid
594 rajveer 1293 
    args.oldPassword = oldPassword
1294 
    args.newPassword = newPassword
94 ashish 1295 
    args.write(self._oprot)
1296 
    self._oprot.writeMessageEnd()
1297 
    self._oprot.trans.flush()
1298 
 
1299 
  def recv_updatePassword(self, ):
1300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1301 
    if mtype == TMessageType.EXCEPTION:
1302 
      x = TApplicationException()
1303 
      x.read(self._iprot)
1304 
      self._iprot.readMessageEnd()
1305 
      raise x
1306 
    result = updatePassword_result()
1307 
    result.read(self._iprot)
1308 
    self._iprot.readMessageEnd()
3431 rajveer 1309 
    if result.success is not None:
94 ashish 1310 
      return result.success
3431 rajveer 1311 
    if result.ucx is not None:
94 ashish 1312 
      raise result.ucx
1313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1314 
 
884 rajveer 1315 
  def forgotPassword(self, email, newPassword):
581 rajveer 1316 
    """
1317 
    Parameters:
1318 
     - email
884 rajveer 1319 
     - newPassword
581 rajveer 1320 
    """
884 rajveer 1321 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1322 
    return self.recv_forgotPassword()
1323 
 
884 rajveer 1324 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1325 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1326 
    args = forgotPassword_args()
1327 
    args.email = email
884 rajveer 1328 
    args.newPassword = newPassword
581 rajveer 1329 
    args.write(self._oprot)
1330 
    self._oprot.writeMessageEnd()
1331 
    self._oprot.trans.flush()
1332 
 
1333 
  def recv_forgotPassword(self, ):
1334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1335 
    if mtype == TMessageType.EXCEPTION:
1336 
      x = TApplicationException()
1337 
      x.read(self._iprot)
1338 
      self._iprot.readMessageEnd()
1339 
      raise x
1340 
    result = forgotPassword_result()
1341 
    result.read(self._iprot)
1342 
    self._iprot.readMessageEnd()
3431 rajveer 1343 
    if result.success is not None:
581 rajveer 1344 
      return result.success
3431 rajveer 1345 
    if result.ucx is not None:
581 rajveer 1346 
      raise result.ucx
1347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1348 
 
594 rajveer 1349 
  def getAllAddressesForUser(self, userId):
1350 
    """
1351 
    Parameters:
1352 
     - userId
1353 
    """
1354 
    self.send_getAllAddressesForUser(userId)
1355 
    return self.recv_getAllAddressesForUser()
1356 
 
1357 
  def send_getAllAddressesForUser(self, userId):
1358 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1359 
    args = getAllAddressesForUser_args()
1360 
    args.userId = userId
1361 
    args.write(self._oprot)
1362 
    self._oprot.writeMessageEnd()
1363 
    self._oprot.trans.flush()
1364 
 
1365 
  def recv_getAllAddressesForUser(self, ):
1366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1367 
    if mtype == TMessageType.EXCEPTION:
1368 
      x = TApplicationException()
1369 
      x.read(self._iprot)
1370 
      self._iprot.readMessageEnd()
1371 
      raise x
1372 
    result = getAllAddressesForUser_result()
1373 
    result.read(self._iprot)
1374 
    self._iprot.readMessageEnd()
3431 rajveer 1375 
    if result.success is not None:
594 rajveer 1376 
      return result.success
3431 rajveer 1377 
    if result.ucx is not None:
594 rajveer 1378 
      raise result.ucx
1379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1380 
 
1894 vikas 1381 
  def getAddressById(self, addressId):
1382 
    """
1383 
    Parameters:
1384 
     - addressId
1385 
    """
1386 
    self.send_getAddressById(addressId)
1387 
    return self.recv_getAddressById()
1388 
 
1389 
  def send_getAddressById(self, addressId):
1390 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1391 
    args = getAddressById_args()
1392 
    args.addressId = addressId
1393 
    args.write(self._oprot)
1394 
    self._oprot.writeMessageEnd()
1395 
    self._oprot.trans.flush()
1396 
 
1397 
  def recv_getAddressById(self, ):
1398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1399 
    if mtype == TMessageType.EXCEPTION:
1400 
      x = TApplicationException()
1401 
      x.read(self._iprot)
1402 
      self._iprot.readMessageEnd()
1403 
      raise x
1404 
    result = getAddressById_result()
1405 
    result.read(self._iprot)
1406 
    self._iprot.readMessageEnd()
3431 rajveer 1407 
    if result.success is not None:
1894 vikas 1408 
      return result.success
3431 rajveer 1409 
    if result.ucx is not None:
1894 vikas 1410 
      raise result.ucx
1411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1412 
 
594 rajveer 1413 
  def getDefaultAddressId(self, userId):
1414 
    """
1415 
    Parameters:
1416 
     - userId
1417 
    """
1418 
    self.send_getDefaultAddressId(userId)
1419 
    return self.recv_getDefaultAddressId()
1420 
 
1421 
  def send_getDefaultAddressId(self, userId):
1422 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1423 
    args = getDefaultAddressId_args()
1424 
    args.userId = userId
1425 
    args.write(self._oprot)
1426 
    self._oprot.writeMessageEnd()
1427 
    self._oprot.trans.flush()
1428 
 
1429 
  def recv_getDefaultAddressId(self, ):
1430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1431 
    if mtype == TMessageType.EXCEPTION:
1432 
      x = TApplicationException()
1433 
      x.read(self._iprot)
1434 
      self._iprot.readMessageEnd()
1435 
      raise x
1436 
    result = getDefaultAddressId_result()
1437 
    result.read(self._iprot)
1438 
    self._iprot.readMessageEnd()
3431 rajveer 1439 
    if result.success is not None:
594 rajveer 1440 
      return result.success
3431 rajveer 1441 
    if result.ucx is not None:
594 rajveer 1442 
      raise result.ucx
1443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1444 
 
785 rajveer 1445 
  def getDefaultPincode(self, userId):
1446 
    """
1447 
    Parameters:
1448 
     - userId
1449 
    """
1450 
    self.send_getDefaultPincode(userId)
1451 
    return self.recv_getDefaultPincode()
1452 
 
1453 
  def send_getDefaultPincode(self, userId):
1454 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1455 
    args = getDefaultPincode_args()
1456 
    args.userId = userId
1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_getDefaultPincode(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = getDefaultPincode_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
3431 rajveer 1471 
    if result.success is not None:
785 rajveer 1472 
      return result.success
3431 rajveer 1473 
    if result.ucx is not None:
785 rajveer 1474 
      raise result.ucx
1475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1476 
 
1274 varun.gupt 1477 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1478 
    """
1479 
    Parameters:
1480 
     - userId
1481 
     - replyTo
1482 
     - communicationType
1483 
     - orderId
1484 
     - airwaybillNo
1485 
     - productName
1486 
     - subject
1487 
     - message
1488 
    """
1489 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1490 
    return self.recv_saveUserCommunication()
1491 
 
1492 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1493 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1494 
    args = saveUserCommunication_args()
1495 
    args.userId = userId
1496 
    args.replyTo = replyTo
1497 
    args.communicationType = communicationType
1498 
    args.orderId = orderId
1499 
    args.airwaybillNo = airwaybillNo
1500 
    args.productName = productName
1501 
    args.subject = subject
1502 
    args.message = message
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_saveUserCommunication(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = saveUserCommunication_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
3431 rajveer 1517 
    if result.success is not None:
1274 varun.gupt 1518 
      return result.success
3431 rajveer 1519 
    if result.ucx is not None:
1274 varun.gupt 1520 
      raise result.ucx
1521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1522 
 
1590 varun.gupt 1523 
  def getUserCommunicationById(self, id):
1524 
    """
1525 
    Parameters:
1526 
     - id
1527 
    """
1528 
    self.send_getUserCommunicationById(id)
1529 
    return self.recv_getUserCommunicationById()
1530 
 
1531 
  def send_getUserCommunicationById(self, id):
1532 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1533 
    args = getUserCommunicationById_args()
1534 
    args.id = id
1535 
    args.write(self._oprot)
1536 
    self._oprot.writeMessageEnd()
1537 
    self._oprot.trans.flush()
1538 
 
1539 
  def recv_getUserCommunicationById(self, ):
1540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1541 
    if mtype == TMessageType.EXCEPTION:
1542 
      x = TApplicationException()
1543 
      x.read(self._iprot)
1544 
      self._iprot.readMessageEnd()
1545 
      raise x
1546 
    result = getUserCommunicationById_result()
1547 
    result.read(self._iprot)
1548 
    self._iprot.readMessageEnd()
3431 rajveer 1549 
    if result.success is not None:
1590 varun.gupt 1550 
      return result.success
3431 rajveer 1551 
    if result.ucx is not None:
1590 varun.gupt 1552 
      raise result.ucx
1553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1554 
 
1555 
  def getUserCommunicationByUser(self, userId):
1556 
    """
1557 
    Parameters:
1558 
     - userId
1559 
    """
1560 
    self.send_getUserCommunicationByUser(userId)
1561 
    return self.recv_getUserCommunicationByUser()
1562 
 
1563 
  def send_getUserCommunicationByUser(self, userId):
1564 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1565 
    args = getUserCommunicationByUser_args()
1566 
    args.userId = userId
1567 
    args.write(self._oprot)
1568 
    self._oprot.writeMessageEnd()
1569 
    self._oprot.trans.flush()
1570 
 
1571 
  def recv_getUserCommunicationByUser(self, ):
1572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1573 
    if mtype == TMessageType.EXCEPTION:
1574 
      x = TApplicationException()
1575 
      x.read(self._iprot)
1576 
      self._iprot.readMessageEnd()
1577 
      raise x
1578 
    result = getUserCommunicationByUser_result()
1579 
    result.read(self._iprot)
1580 
    self._iprot.readMessageEnd()
3431 rajveer 1581 
    if result.success is not None:
1590 varun.gupt 1582 
      return result.success
3431 rajveer 1583 
    if result.ucx is not None:
1590 varun.gupt 1584 
      raise result.ucx
1585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1586 
 
1587 
  def getAllUserCommunications(self, ):
1588 
    self.send_getAllUserCommunications()
1589 
    return self.recv_getAllUserCommunications()
1590 
 
1591 
  def send_getAllUserCommunications(self, ):
1592 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1593 
    args = getAllUserCommunications_args()
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_getAllUserCommunications(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = getAllUserCommunications_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
3431 rajveer 1608 
    if result.success is not None:
1590 varun.gupt 1609 
      return result.success
3431 rajveer 1610 
    if result.ucx is not None:
1590 varun.gupt 1611 
      raise result.ucx
1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1613 
 
5407 amar.kumar 1614 
  def removeUserCommunication(self, id):
1615 
    """
1616 
    Parameters:
1617 
     - id
1618 
    """
1619 
    self.send_removeUserCommunication(id)
1620 
    self.recv_removeUserCommunication()
1621 
 
1622 
  def send_removeUserCommunication(self, id):
1623 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1624 
    args = removeUserCommunication_args()
1625 
    args.id = id
1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_removeUserCommunication(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = removeUserCommunication_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
1640 
    if result.ucx is not None:
1641 
      raise result.ucx
1642 
    return
1643 
 
1859 vikas 1644 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1645 
    """
1646 
    Parameters:
1647 
     - name
1859 vikas 1648 
     - addedOn
1845 vikas 1649 
    """
1859 vikas 1650 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1651 
    return self.recv_createMasterAffiliate()
1652 
 
1859 vikas 1653 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1654 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1655 
    args = createMasterAffiliate_args()
1656 
    args.name = name
1859 vikas 1657 
    args.addedOn = addedOn
1845 vikas 1658 
    args.write(self._oprot)
1659 
    self._oprot.writeMessageEnd()
1660 
    self._oprot.trans.flush()
1661 
 
1662 
  def recv_createMasterAffiliate(self, ):
1663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1664 
    if mtype == TMessageType.EXCEPTION:
1665 
      x = TApplicationException()
1666 
      x.read(self._iprot)
1667 
      self._iprot.readMessageEnd()
1668 
      raise x
1669 
    result = createMasterAffiliate_result()
1670 
    result.read(self._iprot)
1671 
    self._iprot.readMessageEnd()
3431 rajveer 1672 
    if result.success is not None:
1845 vikas 1673 
      return result.success
3431 rajveer 1674 
    if result.utx is not None:
1845 vikas 1675 
      raise result.utx
1676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1677 
 
1899 vikas 1678 
  def getAllMasterAffiliates(self, ):
1679 
    self.send_getAllMasterAffiliates()
1680 
    return self.recv_getAllMasterAffiliates()
1681 
 
1682 
  def send_getAllMasterAffiliates(self, ):
1683 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1684 
    args = getAllMasterAffiliates_args()
1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
1689 
  def recv_getAllMasterAffiliates(self, ):
1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
1696 
    result = getAllMasterAffiliates_result()
1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
3431 rajveer 1699 
    if result.success is not None:
1899 vikas 1700 
      return result.success
3431 rajveer 1701 
    if result.utx is not None:
1899 vikas 1702 
      raise result.utx
1703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1704 
 
1845 vikas 1705 
  def getMasterAffiliateById(self, id):
1706 
    """
1707 
    Parameters:
1708 
     - id
1709 
    """
1710 
    self.send_getMasterAffiliateById(id)
1711 
    return self.recv_getMasterAffiliateById()
1712 
 
1713 
  def send_getMasterAffiliateById(self, id):
1714 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1715 
    args = getMasterAffiliateById_args()
1716 
    args.id = id
1717 
    args.write(self._oprot)
1718 
    self._oprot.writeMessageEnd()
1719 
    self._oprot.trans.flush()
1720 
 
1721 
  def recv_getMasterAffiliateById(self, ):
1722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1723 
    if mtype == TMessageType.EXCEPTION:
1724 
      x = TApplicationException()
1725 
      x.read(self._iprot)
1726 
      self._iprot.readMessageEnd()
1727 
      raise x
1728 
    result = getMasterAffiliateById_result()
1729 
    result.read(self._iprot)
1730 
    self._iprot.readMessageEnd()
3431 rajveer 1731 
    if result.success is not None:
1845 vikas 1732 
      return result.success
3431 rajveer 1733 
    if result.utx is not None:
1845 vikas 1734 
      raise result.utx
1735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1736 
 
1737 
  def getMasterAffiliateByName(self, name):
1738 
    """
1739 
    Parameters:
1740 
     - name
1741 
    """
1742 
    self.send_getMasterAffiliateByName(name)
1743 
    return self.recv_getMasterAffiliateByName()
1744 
 
1745 
  def send_getMasterAffiliateByName(self, name):
1746 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1747 
    args = getMasterAffiliateByName_args()
1748 
    args.name = name
1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getMasterAffiliateByName(self, ):
1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
1760 
    result = getMasterAffiliateByName_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
3431 rajveer 1763 
    if result.success is not None:
1845 vikas 1764 
      return result.success
3431 rajveer 1765 
    if result.utx is not None:
1845 vikas 1766 
      raise result.utx
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1768 
 
1859 vikas 1769 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1770 
    """
1771 
    Parameters:
1772 
     - name
1773 
     - url
1774 
     - masterAffiliateId
1859 vikas 1775 
     - addedOn
1845 vikas 1776 
    """
1859 vikas 1777 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1778 
    return self.recv_createAffiliate()
1779 
 
1859 vikas 1780 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1781 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1782 
    args = createAffiliate_args()
1783 
    args.name = name
1784 
    args.url = url
1785 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1786 
    args.addedOn = addedOn
1845 vikas 1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1791 
  def recv_createAffiliate(self, ):
1792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1793 
    if mtype == TMessageType.EXCEPTION:
1794 
      x = TApplicationException()
1795 
      x.read(self._iprot)
1796 
      self._iprot.readMessageEnd()
1797 
      raise x
1798 
    result = createAffiliate_result()
1799 
    result.read(self._iprot)
1800 
    self._iprot.readMessageEnd()
3431 rajveer 1801 
    if result.success is not None:
1845 vikas 1802 
      return result.success
3431 rajveer 1803 
    if result.utx is not None:
1845 vikas 1804 
      raise result.utx
1805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1806 
 
1807 
  def getAffiliateById(self, id):
1808 
    """
1809 
    Parameters:
1810 
     - id
1811 
    """
1812 
    self.send_getAffiliateById(id)
1813 
    return self.recv_getAffiliateById()
1814 
 
1815 
  def send_getAffiliateById(self, id):
1816 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1817 
    args = getAffiliateById_args()
1818 
    args.id = id
1819 
    args.write(self._oprot)
1820 
    self._oprot.writeMessageEnd()
1821 
    self._oprot.trans.flush()
1822 
 
1823 
  def recv_getAffiliateById(self, ):
1824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1825 
    if mtype == TMessageType.EXCEPTION:
1826 
      x = TApplicationException()
1827 
      x.read(self._iprot)
1828 
      self._iprot.readMessageEnd()
1829 
      raise x
1830 
    result = getAffiliateById_result()
1831 
    result.read(self._iprot)
1832 
    self._iprot.readMessageEnd()
3431 rajveer 1833 
    if result.success is not None:
1845 vikas 1834 
      return result.success
3431 rajveer 1835 
    if result.utx is not None:
1845 vikas 1836 
      raise result.utx
1837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1838 
 
1839 
  def getAffiliateByName(self, name):
1840 
    """
1841 
    Parameters:
1842 
     - name
1843 
    """
1844 
    self.send_getAffiliateByName(name)
1845 
    return self.recv_getAffiliateByName()
1846 
 
1847 
  def send_getAffiliateByName(self, name):
1848 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1849 
    args = getAffiliateByName_args()
1850 
    args.name = name
1851 
    args.write(self._oprot)
1852 
    self._oprot.writeMessageEnd()
1853 
    self._oprot.trans.flush()
1854 
 
1855 
  def recv_getAffiliateByName(self, ):
1856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1857 
    if mtype == TMessageType.EXCEPTION:
1858 
      x = TApplicationException()
1859 
      x.read(self._iprot)
1860 
      self._iprot.readMessageEnd()
1861 
      raise x
1862 
    result = getAffiliateByName_result()
1863 
    result.read(self._iprot)
1864 
    self._iprot.readMessageEnd()
3431 rajveer 1865 
    if result.success is not None:
1845 vikas 1866 
      return result.success
3431 rajveer 1867 
    if result.utx is not None:
1845 vikas 1868 
      raise result.utx
1869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1870 
 
1996 vikas 1871 
  def getTrackerById(self, id):
1845 vikas 1872 
    """
1873 
    Parameters:
1874 
     - id
1875 
    """
1996 vikas 1876 
    self.send_getTrackerById(id)
1845 vikas 1877 
    return self.recv_getTrackerById()
1878 
 
1996 vikas 1879 
  def send_getTrackerById(self, id):
1845 vikas 1880 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1881 
    args = getTrackerById_args()
1996 vikas 1882 
    args.id = id
1845 vikas 1883 
    args.write(self._oprot)
1884 
    self._oprot.writeMessageEnd()
1885 
    self._oprot.trans.flush()
1886 
 
1887 
  def recv_getTrackerById(self, ):
1888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1889 
    if mtype == TMessageType.EXCEPTION:
1890 
      x = TApplicationException()
1891 
      x.read(self._iprot)
1892 
      self._iprot.readMessageEnd()
1893 
      raise x
1894 
    result = getTrackerById_result()
1895 
    result.read(self._iprot)
1896 
    self._iprot.readMessageEnd()
3431 rajveer 1897 
    if result.success is not None:
1845 vikas 1898 
      return result.success
3431 rajveer 1899 
    if result.utx is not None:
1845 vikas 1900 
      raise result.utx
1901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1902 
 
1996 vikas 1903 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1904 
    """
1905 
    Parameters:
1996 vikas 1906 
     - id
1845 vikas 1907 
    """
1996 vikas 1908 
    self.send_getAffiliatesByMasterAffiliate(id)
1909 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1910 
 
1996 vikas 1911 
  def send_getAffiliatesByMasterAffiliate(self, id):
1912 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1913 
    args = getAffiliatesByMasterAffiliate_args()
1914 
    args.id = id
1845 vikas 1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
1996 vikas 1919 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
1996 vikas 1926 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
3431 rajveer 1929 
    if result.success is not None:
1845 vikas 1930 
      return result.success
3431 rajveer 1931 
    if result.utx is not None:
1845 vikas 1932 
      raise result.utx
1996 vikas 1933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1934 
 
1996 vikas 1935 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1936 
    """
1937 
    Parameters:
1996 vikas 1938 
     - affiliateId
1845 vikas 1939 
     - userId
1940 
     - event
1941 
     - url
1942 
     - data
1859 vikas 1943 
     - addedOn
1845 vikas 1944 
    """
1996 vikas 1945 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1946 
    return self.recv_addTrackLog()
1947 
 
1996 vikas 1948 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1949 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1950 
    args = addTrackLog_args()
1996 vikas 1951 
    args.affiliateId = affiliateId
1845 vikas 1952 
    args.userId = userId
1953 
    args.event = event
1954 
    args.url = url
1955 
    args.data = data
1859 vikas 1956 
    args.addedOn = addedOn
1845 vikas 1957 
    args.write(self._oprot)
1958 
    self._oprot.writeMessageEnd()
1959 
    self._oprot.trans.flush()
1960 
 
1961 
  def recv_addTrackLog(self, ):
1962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1963 
    if mtype == TMessageType.EXCEPTION:
1964 
      x = TApplicationException()
1965 
      x.read(self._iprot)
1966 
      self._iprot.readMessageEnd()
1967 
      raise x
1968 
    result = addTrackLog_result()
1969 
    result.read(self._iprot)
1970 
    self._iprot.readMessageEnd()
3431 rajveer 1971 
    if result.success is not None:
1845 vikas 1972 
      return result.success
3431 rajveer 1973 
    if result.utx is not None:
1845 vikas 1974 
      raise result.utx
1975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1976 
 
1977 
  def getTrackLogById(self, id):
1978 
    """
1979 
    Parameters:
1980 
     - id
1981 
    """
1982 
    self.send_getTrackLogById(id)
1983 
    return self.recv_getTrackLogById()
1984 
 
1985 
  def send_getTrackLogById(self, id):
1986 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1987 
    args = getTrackLogById_args()
1988 
    args.id = id
1989 
    args.write(self._oprot)
1990 
    self._oprot.writeMessageEnd()
1991 
    self._oprot.trans.flush()
1992 
 
1993 
  def recv_getTrackLogById(self, ):
1994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1995 
    if mtype == TMessageType.EXCEPTION:
1996 
      x = TApplicationException()
1997 
      x.read(self._iprot)
1998 
      self._iprot.readMessageEnd()
1999 
      raise x
2000 
    result = getTrackLogById_result()
2001 
    result.read(self._iprot)
2002 
    self._iprot.readMessageEnd()
3431 rajveer 2003 
    if result.success is not None:
1845 vikas 2004 
      return result.success
3431 rajveer 2005 
    if result.utx is not None:
1845 vikas 2006 
      raise result.utx
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2008 
 
3293 vikas 2009 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2010 
    """
2011 
    Parameters:
1996 vikas 2012 
     - affiliateId
3293 vikas 2013 
     - startDate
2014 
     - endDate
1845 vikas 2015 
    """
3293 vikas 2016 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2017 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2018 
 
3293 vikas 2019 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2020 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2021 
    args = getTrackLogsByAffiliate_args()
2022 
    args.affiliateId = affiliateId
3293 vikas 2023 
    args.startDate = startDate
2024 
    args.endDate = endDate
1845 vikas 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
1996 vikas 2029 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
1996 vikas 2036 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
1845 vikas 2040 
      return result.success
3431 rajveer 2041 
    if result.utx is not None:
1845 vikas 2042 
      raise result.utx
1996 vikas 2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2044 
 
2045 
  def getTrackLogsByUser(self, userId):
2046 
    """
2047 
    Parameters:
2048 
     - userId
2049 
    """
2050 
    self.send_getTrackLogsByUser(userId)
2051 
    return self.recv_getTrackLogsByUser()
2052 
 
2053 
  def send_getTrackLogsByUser(self, userId):
2054 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2055 
    args = getTrackLogsByUser_args()
2056 
    args.userId = userId
2057 
    args.write(self._oprot)
2058 
    self._oprot.writeMessageEnd()
2059 
    self._oprot.trans.flush()
2060 
 
2061 
  def recv_getTrackLogsByUser(self, ):
2062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2063 
    if mtype == TMessageType.EXCEPTION:
2064 
      x = TApplicationException()
2065 
      x.read(self._iprot)
2066 
      self._iprot.readMessageEnd()
2067 
      raise x
2068 
    result = getTrackLogsByUser_result()
2069 
    result.read(self._iprot)
2070 
    self._iprot.readMessageEnd()
3431 rajveer 2071 
    if result.success is not None:
1845 vikas 2072 
      return result.success
3431 rajveer 2073 
    if result.utx is not None:
1845 vikas 2074 
      raise result.utx
2075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2076 
 
1996 vikas 2077 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2078 
    """
2079 
    Parameters:
2080 
     - userId
2081 
     - event
2082 
     - url
2083 
    """
1996 vikas 2084 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2085 
    return self.recv_getTrackLogs()
2086 
 
1996 vikas 2087 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2088 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2089 
    args = getTrackLogs_args()
2090 
    args.userId = userId
2091 
    args.event = event
2092 
    args.url = url
2093 
    args.write(self._oprot)
2094 
    self._oprot.writeMessageEnd()
2095 
    self._oprot.trans.flush()
2096 
 
2097 
  def recv_getTrackLogs(self, ):
2098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2099 
    if mtype == TMessageType.EXCEPTION:
2100 
      x = TApplicationException()
2101 
      x.read(self._iprot)
2102 
      self._iprot.readMessageEnd()
2103 
      raise x
2104 
    result = getTrackLogs_result()
2105 
    result.read(self._iprot)
2106 
    self._iprot.readMessageEnd()
3431 rajveer 2107 
    if result.success is not None:
1845 vikas 2108 
      return result.success
3431 rajveer 2109 
    if result.utx is not None:
1845 vikas 2110 
      raise result.utx
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2112 
 
559 chandransh 2113 
  def getCurrentCart(self, userId):
94 ashish 2114 
    """
2115 
    Parameters:
559 chandransh 2116 
     - userId
94 ashish 2117 
    """
559 chandransh 2118 
    self.send_getCurrentCart(userId)
2119 
    return self.recv_getCurrentCart()
94 ashish 2120 
 
559 chandransh 2121 
  def send_getCurrentCart(self, userId):
2122 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2123 
    args = getCurrentCart_args()
2124 
    args.userId = userId
94 ashish 2125 
    args.write(self._oprot)
2126 
    self._oprot.writeMessageEnd()
2127 
    self._oprot.trans.flush()
2128 
 
559 chandransh 2129 
  def recv_getCurrentCart(self, ):
94 ashish 2130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2131 
    if mtype == TMessageType.EXCEPTION:
2132 
      x = TApplicationException()
2133 
      x.read(self._iprot)
2134 
      self._iprot.readMessageEnd()
2135 
      raise x
559 chandransh 2136 
    result = getCurrentCart_result()
94 ashish 2137 
    result.read(self._iprot)
2138 
    self._iprot.readMessageEnd()
3431 rajveer 2139 
    if result.success is not None:
94 ashish 2140 
      return result.success
3431 rajveer 2141 
    if result.scx is not None:
559 chandransh 2142 
      raise result.scx
2143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2144 
 
559 chandransh 2145 
  def getCart(self, cartId):
94 ashish 2146 
    """
2147 
    Parameters:
559 chandransh 2148 
     - cartId
94 ashish 2149 
    """
559 chandransh 2150 
    self.send_getCart(cartId)
2151 
    return self.recv_getCart()
94 ashish 2152 
 
559 chandransh 2153 
  def send_getCart(self, cartId):
2154 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2155 
    args = getCart_args()
2156 
    args.cartId = cartId
94 ashish 2157 
    args.write(self._oprot)
2158 
    self._oprot.writeMessageEnd()
2159 
    self._oprot.trans.flush()
2160 
 
559 chandransh 2161 
  def recv_getCart(self, ):
94 ashish 2162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2163 
    if mtype == TMessageType.EXCEPTION:
2164 
      x = TApplicationException()
2165 
      x.read(self._iprot)
2166 
      self._iprot.readMessageEnd()
2167 
      raise x
559 chandransh 2168 
    result = getCart_result()
94 ashish 2169 
    result.read(self._iprot)
2170 
    self._iprot.readMessageEnd()
3431 rajveer 2171 
    if result.success is not None:
94 ashish 2172 
      return result.success
3431 rajveer 2173 
    if result.scx is not None:
559 chandransh 2174 
      raise result.scx
2175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2176 
 
559 chandransh 2177 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2178 
    """
2179 
    Parameters:
559 chandransh 2180 
     - from_time
2181 
     - to_time
2182 
     - status
94 ashish 2183 
    """
559 chandransh 2184 
    self.send_getCartsByTime(from_time, to_time, status)
2185 
    return self.recv_getCartsByTime()
94 ashish 2186 
 
559 chandransh 2187 
  def send_getCartsByTime(self, from_time, to_time, status):
2188 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2189 
    args = getCartsByTime_args()
2190 
    args.from_time = from_time
2191 
    args.to_time = to_time
2192 
    args.status = status
94 ashish 2193 
    args.write(self._oprot)
2194 
    self._oprot.writeMessageEnd()
2195 
    self._oprot.trans.flush()
2196 
 
559 chandransh 2197 
  def recv_getCartsByTime(self, ):
94 ashish 2198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2199 
    if mtype == TMessageType.EXCEPTION:
2200 
      x = TApplicationException()
2201 
      x.read(self._iprot)
2202 
      self._iprot.readMessageEnd()
2203 
      raise x
559 chandransh 2204 
    result = getCartsByTime_result()
94 ashish 2205 
    result.read(self._iprot)
2206 
    self._iprot.readMessageEnd()
3431 rajveer 2207 
    if result.success is not None:
94 ashish 2208 
      return result.success
3431 rajveer 2209 
    if result.scx is not None:
559 chandransh 2210 
      raise result.scx
2211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2212 
 
3557 rajveer 2213 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2214 
    """
2215 
    Parameters:
2216 
     - cartId
2217 
     - itemId
2218 
     - quantity
3557 rajveer 2219 
     - sourceId
559 chandransh 2220 
    """
3557 rajveer 2221 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2222 
    return self.recv_addItemToCart()
559 chandransh 2223 
 
3557 rajveer 2224 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2225 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2226 
    args = addItemToCart_args()
2227 
    args.cartId = cartId
2228 
    args.itemId = itemId
2229 
    args.quantity = quantity
3557 rajveer 2230 
    args.sourceId = sourceId
559 chandransh 2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_addItemToCart(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = addItemToCart_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
3431 rajveer 2245 
    if result.success is not None:
2035 rajveer 2246 
      return result.success
3431 rajveer 2247 
    if result.scx is not None:
559 chandransh 2248 
      raise result.scx
2035 rajveer 2249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2250 
 
2251 
  def deleteItemFromCart(self, cartId, itemId):
2252 
    """
2253 
    Parameters:
2254 
     - cartId
2255 
     - itemId
2256 
    """
2257 
    self.send_deleteItemFromCart(cartId, itemId)
2258 
    self.recv_deleteItemFromCart()
2259 
 
2260 
  def send_deleteItemFromCart(self, cartId, itemId):
2261 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2262 
    args = deleteItemFromCart_args()
2263 
    args.cartId = cartId
2264 
    args.itemId = itemId
2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
2269 
  def recv_deleteItemFromCart(self, ):
2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
2276 
    result = deleteItemFromCart_result()
2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
3431 rajveer 2279 
    if result.scx is not None:
559 chandransh 2280 
      raise result.scx
2281 
    return
2282 
 
2283 
  def addAddressToCart(self, cartId, addressId):
2284 
    """
2285 
    Parameters:
2286 
     - cartId
2287 
     - addressId
2288 
    """
2289 
    self.send_addAddressToCart(cartId, addressId)
2290 
    self.recv_addAddressToCart()
2291 
 
2292 
  def send_addAddressToCart(self, cartId, addressId):
2293 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2294 
    args = addAddressToCart_args()
2295 
    args.cartId = cartId
2296 
    args.addressId = addressId
2297 
    args.write(self._oprot)
2298 
    self._oprot.writeMessageEnd()
2299 
    self._oprot.trans.flush()
2300 
 
2301 
  def recv_addAddressToCart(self, ):
2302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2303 
    if mtype == TMessageType.EXCEPTION:
2304 
      x = TApplicationException()
2305 
      x.read(self._iprot)
2306 
      self._iprot.readMessageEnd()
2307 
      raise x
2308 
    result = addAddressToCart_result()
2309 
    result.read(self._iprot)
2310 
    self._iprot.readMessageEnd()
3431 rajveer 2311 
    if result.scx is not None:
575 chandransh 2312 
      raise result.scx
559 chandransh 2313 
    return
2314 
 
5553 rajveer 2315 
  def addStoreToCart(self, cartId, storeId):
2316 
    """
2317 
    Parameters:
2318 
     - cartId
2319 
     - storeId
2320 
    """
2321 
    self.send_addStoreToCart(cartId, storeId)
2322 
    self.recv_addStoreToCart()
2323 
 
2324 
  def send_addStoreToCart(self, cartId, storeId):
2325 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2326 
    args = addStoreToCart_args()
2327 
    args.cartId = cartId
2328 
    args.storeId = storeId
2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
2333 
  def recv_addStoreToCart(self, ):
2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
2340 
    result = addStoreToCart_result()
2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
2343 
    if result.scx is not None:
2344 
      raise result.scx
2345 
    return
2346 
 
6922 anupam.sin 2347 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2348 
    """
2349 
    Parameters:
6922 anupam.sin 2350 
     - cart
1976 varun.gupt 2351 
     - couponCode
2352 
    """
6922 anupam.sin 2353 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2354 
    self.recv_applyCouponToCart()
2355 
 
6922 anupam.sin 2356 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2357 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2358 
    args = applyCouponToCart_args()
6922 anupam.sin 2359 
    args.cart = cart
1976 varun.gupt 2360 
    args.couponCode = couponCode
2361 
    args.write(self._oprot)
2362 
    self._oprot.writeMessageEnd()
2363 
    self._oprot.trans.flush()
2364 
 
2365 
  def recv_applyCouponToCart(self, ):
2366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2367 
    if mtype == TMessageType.EXCEPTION:
2368 
      x = TApplicationException()
2369 
      x.read(self._iprot)
2370 
      self._iprot.readMessageEnd()
2371 
      raise x
2372 
    result = applyCouponToCart_result()
2373 
    result.read(self._iprot)
2374 
    self._iprot.readMessageEnd()
3431 rajveer 2375 
    if result.scx is not None:
1976 varun.gupt 2376 
      raise result.scx
2377 
    return
2378 
 
2379 
  def removeCoupon(self, cartId):
2380 
    """
2381 
    Parameters:
2382 
     - cartId
2383 
    """
2384 
    self.send_removeCoupon(cartId)
2385 
    self.recv_removeCoupon()
2386 
 
2387 
  def send_removeCoupon(self, cartId):
2388 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2389 
    args = removeCoupon_args()
2390 
    args.cartId = cartId
2391 
    args.write(self._oprot)
2392 
    self._oprot.writeMessageEnd()
2393 
    self._oprot.trans.flush()
2394 
 
2395 
  def recv_removeCoupon(self, ):
2396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2397 
    if mtype == TMessageType.EXCEPTION:
2398 
      x = TApplicationException()
2399 
      x.read(self._iprot)
2400 
      self._iprot.readMessageEnd()
2401 
      raise x
2402 
    result = removeCoupon_result()
2403 
    result.read(self._iprot)
2404 
    self._iprot.readMessageEnd()
3431 rajveer 2405 
    if result.scx is not None:
1976 varun.gupt 2406 
      raise result.scx
2407 
    return
2408 
 
3554 varun.gupt 2409 
  def deleteDiscountsFromCart(self, cartId):
2410 
    """
2411 
    Deletes all the discounts associated with the cart
2412 
 
2413 
    Parameters:
2414 
     - cartId
2415 
    """
2416 
    self.send_deleteDiscountsFromCart(cartId)
2417 
    self.recv_deleteDiscountsFromCart()
2418 
 
2419 
  def send_deleteDiscountsFromCart(self, cartId):
2420 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2421 
    args = deleteDiscountsFromCart_args()
2422 
    args.cartId = cartId
2423 
    args.write(self._oprot)
2424 
    self._oprot.writeMessageEnd()
2425 
    self._oprot.trans.flush()
2426 
 
2427 
  def recv_deleteDiscountsFromCart(self, ):
2428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2429 
    if mtype == TMessageType.EXCEPTION:
2430 
      x = TApplicationException()
2431 
      x.read(self._iprot)
2432 
      self._iprot.readMessageEnd()
2433 
      raise x
2434 
    result = deleteDiscountsFromCart_result()
2435 
    result.read(self._iprot)
2436 
    self._iprot.readMessageEnd()
2437 
    if result.scx is not None:
2438 
      raise result.scx
2439 
    return
2440 
 
2441 
  def saveDiscounts(self, discounts):
2442 
    """
2443 
    Accepts a list of thrift objects of Discount type and saves them
2444 
 
2445 
    Parameters:
2446 
     - discounts
2447 
    """
2448 
    self.send_saveDiscounts(discounts)
2449 
    self.recv_saveDiscounts()
2450 
 
2451 
  def send_saveDiscounts(self, discounts):
2452 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2453 
    args = saveDiscounts_args()
2454 
    args.discounts = discounts
2455 
    args.write(self._oprot)
2456 
    self._oprot.writeMessageEnd()
2457 
    self._oprot.trans.flush()
2458 
 
2459 
  def recv_saveDiscounts(self, ):
2460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2461 
    if mtype == TMessageType.EXCEPTION:
2462 
      x = TApplicationException()
2463 
      x.read(self._iprot)
2464 
      self._iprot.readMessageEnd()
2465 
      raise x
2466 
    result = saveDiscounts_result()
2467 
    result.read(self._iprot)
2468 
    self._iprot.readMessageEnd()
2469 
    if result.scx is not None:
2470 
      raise result.scx
2471 
    return
2472 
 
11526 amit.gupta 2473 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2474 
    """
690 chandransh 2475 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2476 
 
559 chandransh 2477 
    Parameters:
2478 
     - cartId
2815 vikas 2479 
     - sessionSource
2480 
     - sessionStartTime
3858 vikas 2481 
     - firstSource
2482 
     - firstSourceTime
5326 rajveer 2483 
     - userId
6389 rajveer 2484 
     - schemeId
11526 amit.gupta 2485 
     - orderSource
559 chandransh 2486 
    """
11526 amit.gupta 2487 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2488 
    return self.recv_createOrders()
559 chandransh 2489 
 
11526 amit.gupta 2490 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2491 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2492 
    args = createOrders_args()
559 chandransh 2493 
    args.cartId = cartId
2815 vikas 2494 
    args.sessionSource = sessionSource
2495 
    args.sessionStartTime = sessionStartTime
3858 vikas 2496 
    args.firstSource = firstSource
2497 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2498 
    args.userId = userId
6389 rajveer 2499 
    args.schemeId = schemeId
11526 amit.gupta 2500 
    args.orderSource = orderSource
559 chandransh 2501 
    args.write(self._oprot)
2502 
    self._oprot.writeMessageEnd()
2503 
    self._oprot.trans.flush()
2504 
 
690 chandransh 2505 
  def recv_createOrders(self, ):
559 chandransh 2506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2507 
    if mtype == TMessageType.EXCEPTION:
2508 
      x = TApplicationException()
2509 
      x.read(self._iprot)
2510 
      self._iprot.readMessageEnd()
2511 
      raise x
690 chandransh 2512 
    result = createOrders_result()
559 chandransh 2513 
    result.read(self._iprot)
2514 
    self._iprot.readMessageEnd()
3431 rajveer 2515 
    if result.success is not None:
130 ashish 2516 
      return result.success
3431 rajveer 2517 
    if result.scx is not None:
559 chandransh 2518 
      raise result.scx
690 chandransh 2519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2520 
 
3557 rajveer 2521 
  def validateCart(self, cartId, sourceId):
130 ashish 2522 
    """
690 chandransh 2523 
    Validates that:
2524 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2525 
    2. All of the lines in the cart are active items.
690 chandransh 2526 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2527 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2528 
 
130 ashish 2529 
    Parameters:
559 chandransh 2530 
     - cartId
3557 rajveer 2531 
     - sourceId
130 ashish 2532 
    """
3557 rajveer 2533 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2534 
    return self.recv_validateCart()
130 ashish 2535 
 
3557 rajveer 2536 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2537 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2538 
    args = validateCart_args()
2539 
    args.cartId = cartId
3557 rajveer 2540 
    args.sourceId = sourceId
130 ashish 2541 
    args.write(self._oprot)
2542 
    self._oprot.writeMessageEnd()
2543 
    self._oprot.trans.flush()
2544 
 
559 chandransh 2545 
  def recv_validateCart(self, ):
130 ashish 2546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2547 
    if mtype == TMessageType.EXCEPTION:
2548 
      x = TApplicationException()
2549 
      x.read(self._iprot)
2550 
      self._iprot.readMessageEnd()
2551 
      raise x
559 chandransh 2552 
    result = validateCart_result()
130 ashish 2553 
    result.read(self._iprot)
2554 
    self._iprot.readMessageEnd()
3431 rajveer 2555 
    if result.success is not None:
130 ashish 2556 
      return result.success
3431 rajveer 2557 
    if result.scex is not None:
575 chandransh 2558 
      raise result.scex
559 chandransh 2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2560 
 
11980 amit.gupta 2561 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2562 
    """
2563 
    Validates that:
2564 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2565 
    2. All of the lines in the cart are active items.
2566 
    3. The estimate for any of the lines in cart doesn't change.
2567 
    If all three are true, returns empty string; else returns appropriate message.
2568 
 
2569 
    Parameters:
2570 
     - cartId
2571 
     - sourceId
2572 
     - dealCoupon
2573 
    """
2574 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2575 
    return self.recv_validateCartWithDealerCoupon()
2576 
 
2577 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2578 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2579 
    args = validateCartWithDealerCoupon_args()
2580 
    args.cartId = cartId
2581 
    args.sourceId = sourceId
2582 
    args.dealCoupon = dealCoupon
2583 
    args.write(self._oprot)
2584 
    self._oprot.writeMessageEnd()
2585 
    self._oprot.trans.flush()
2586 
 
2587 
  def recv_validateCartWithDealerCoupon(self, ):
2588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2589 
    if mtype == TMessageType.EXCEPTION:
2590 
      x = TApplicationException()
2591 
      x.read(self._iprot)
2592 
      self._iprot.readMessageEnd()
2593 
      raise x
2594 
    result = validateCartWithDealerCoupon_result()
2595 
    result.read(self._iprot)
2596 
    self._iprot.readMessageEnd()
2597 
    if result.success is not None:
2598 
      return result.success
2599 
    if result.scex is not None:
2600 
      raise result.scex
2601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2602 
 
690 chandransh 2603 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2604 
    """
690 chandransh 2605 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2606 
 
575 chandransh 2607 
    Parameters:
690 chandransh 2608 
     - fromCartId
2609 
     - toCartId
2610 
    """
2611 
    self.send_mergeCart(fromCartId, toCartId)
2612 
    self.recv_mergeCart()
2613 
 
2614 
  def send_mergeCart(self, fromCartId, toCartId):
2615 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2616 
    args = mergeCart_args()
2617 
    args.fromCartId = fromCartId
2618 
    args.toCartId = toCartId
2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_mergeCart(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = mergeCart_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
2633 
    return
2634 
 
2635 
  def checkOut(self, cartId):
2636 
    """
2637 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2638 
 
690 chandransh 2639 
    Parameters:
575 chandransh 2640 
     - cartId
2641 
    """
690 chandransh 2642 
    self.send_checkOut(cartId)
2643 
    return self.recv_checkOut()
575 chandransh 2644 
 
690 chandransh 2645 
  def send_checkOut(self, cartId):
2646 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2647 
    args = checkOut_args()
575 chandransh 2648 
    args.cartId = cartId
2649 
    args.write(self._oprot)
2650 
    self._oprot.writeMessageEnd()
2651 
    self._oprot.trans.flush()
2652 
 
690 chandransh 2653 
  def recv_checkOut(self, ):
575 chandransh 2654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2655 
    if mtype == TMessageType.EXCEPTION:
2656 
      x = TApplicationException()
2657 
      x.read(self._iprot)
2658 
      self._iprot.readMessageEnd()
2659 
      raise x
690 chandransh 2660 
    result = checkOut_result()
575 chandransh 2661 
    result.read(self._iprot)
2662 
    self._iprot.readMessageEnd()
3431 rajveer 2663 
    if result.success is not None:
575 chandransh 2664 
      return result.success
3431 rajveer 2665 
    if result.scex is not None:
575 chandransh 2666 
      raise result.scex
690 chandransh 2667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2668 
 
690 chandransh 2669 
  def resetCart(self, cartId, items):
559 chandransh 2670 
    """
690 chandransh 2671 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2672 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2673 
 
559 chandransh 2674 
    Parameters:
690 chandransh 2675 
     - cartId
2676 
     - items
559 chandransh 2677 
    """
690 chandransh 2678 
    self.send_resetCart(cartId, items)
2679 
    return self.recv_resetCart()
130 ashish 2680 
 
690 chandransh 2681 
  def send_resetCart(self, cartId, items):
2682 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2683 
    args = resetCart_args()
2684 
    args.cartId = cartId
2685 
    args.items = items
559 chandransh 2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
690 chandransh 2690 
  def recv_resetCart(self, ):
559 chandransh 2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
690 chandransh 2697 
    result = resetCart_result()
559 chandransh 2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
3431 rajveer 2700 
    if result.success is not None:
690 chandransh 2701 
      return result.success
3431 rajveer 2702 
    if result.scex is not None:
690 chandransh 2703 
      raise result.scex
2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2705 
 
2981 rajveer 2706 
  def getUserCount(self, userType):
559 chandransh 2707 
    """
2981 rajveer 2708 
    Returns number of registered users.
2709 
    If userType = null, then it returns count of all users, including anonymous
2710 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2711 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2712 
 
559 chandransh 2713 
    Parameters:
2981 rajveer 2714 
     - userType
559 chandransh 2715 
    """
2981 rajveer 2716 
    self.send_getUserCount(userType)
2717 
    return self.recv_getUserCount()
559 chandransh 2718 
 
2981 rajveer 2719 
  def send_getUserCount(self, userType):
2720 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2721 
    args = getUserCount_args()
2722 
    args.userType = userType
559 chandransh 2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
2981 rajveer 2727 
  def recv_getUserCount(self, ):
559 chandransh 2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
2981 rajveer 2734 
    result = getUserCount_result()
559 chandransh 2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
3431 rajveer 2737 
    if result.success is not None:
559 chandransh 2738 
      return result.success
2981 rajveer 2739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2740 
 
2981 rajveer 2741 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2742 
    """
2981 rajveer 2743 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2744 
    If any of startDate or endDate is -1, then that filter is ignored.
2745 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2746 
 
2747 
 
559 chandransh 2748 
    Parameters:
2981 rajveer 2749 
     - userType
2750 
     - startDate
2751 
     - endDate
559 chandransh 2752 
    """
2981 rajveer 2753 
    self.send_getAllUsers(userType, startDate, endDate)
2754 
    return self.recv_getAllUsers()
559 chandransh 2755 
 
2981 rajveer 2756 
  def send_getAllUsers(self, userType, startDate, endDate):
2757 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2758 
    args = getAllUsers_args()
2759 
    args.userType = userType
2760 
    args.startDate = startDate
2761 
    args.endDate = endDate
559 chandransh 2762 
    args.write(self._oprot)
2763 
    self._oprot.writeMessageEnd()
2764 
    self._oprot.trans.flush()
2765 
 
2981 rajveer 2766 
  def recv_getAllUsers(self, ):
559 chandransh 2767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2768 
    if mtype == TMessageType.EXCEPTION:
2769 
      x = TApplicationException()
2770 
      x.read(self._iprot)
2771 
      self._iprot.readMessageEnd()
2772 
      raise x
2981 rajveer 2773 
    result = getAllUsers_result()
559 chandransh 2774 
    result.read(self._iprot)
2775 
    self._iprot.readMessageEnd()
3431 rajveer 2776 
    if result.success is not None:
559 chandransh 2777 
      return result.success
2981 rajveer 2778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2779 
 
2981 rajveer 2780 
  def getMyResearchItems(self, userId):
559 chandransh 2781 
    """
2981 rajveer 2782 
    Returns list of item ids in myresearch for the user
3431 rajveer 2783 
 
559 chandransh 2784 
    Parameters:
772 rajveer 2785 
     - userId
559 chandransh 2786 
    """
2981 rajveer 2787 
    self.send_getMyResearchItems(userId)
2788 
    return self.recv_getMyResearchItems()
559 chandransh 2789 
 
2981 rajveer 2790 
  def send_getMyResearchItems(self, userId):
2791 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2792 
    args = getMyResearchItems_args()
772 rajveer 2793 
    args.userId = userId
559 chandransh 2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
2981 rajveer 2798 
  def recv_getMyResearchItems(self, ):
559 chandransh 2799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2800 
    if mtype == TMessageType.EXCEPTION:
2801 
      x = TApplicationException()
2802 
      x.read(self._iprot)
2803 
      self._iprot.readMessageEnd()
2804 
      raise x
2981 rajveer 2805 
    result = getMyResearchItems_result()
559 chandransh 2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
3431 rajveer 2808 
    if result.success is not None:
559 chandransh 2809 
      return result.success
3431 rajveer 2810 
    if result.scx is not None:
559 chandransh 2811 
      raise result.scx
2981 rajveer 2812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2813 
 
2981 rajveer 2814 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2815 
    """
2981 rajveer 2816 
    add item to my research for a user
3431 rajveer 2817 
 
559 chandransh 2818 
    Parameters:
2981 rajveer 2819 
     - userId
2820 
     - itemId
559 chandransh 2821 
    """
2981 rajveer 2822 
    self.send_updateMyResearch(userId, itemId)
2823 
    return self.recv_updateMyResearch()
559 chandransh 2824 
 
2981 rajveer 2825 
  def send_updateMyResearch(self, userId, itemId):
2826 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2827 
    args = updateMyResearch_args()
2828 
    args.userId = userId
2829 
    args.itemId = itemId
559 chandransh 2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2981 rajveer 2834 
  def recv_updateMyResearch(self, ):
559 chandransh 2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2981 rajveer 2841 
    result = updateMyResearch_result()
559 chandransh 2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
3431 rajveer 2844 
    if result.success is not None:
2981 rajveer 2845 
      return result.success
3431 rajveer 2846 
    if result.scx is not None:
2981 rajveer 2847 
      raise result.scx
2848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2849 
 
2981 rajveer 2850 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2851 
    """
2981 rajveer 2852 
    delete item from my research for a user
3431 rajveer 2853 
 
1596 ankur.sing 2854 
    Parameters:
2981 rajveer 2855 
     - userId
2856 
     - itemId
1596 ankur.sing 2857 
    """
2981 rajveer 2858 
    self.send_deleteItemFromMyResearch(userId, itemId)
2859 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2860 
 
2981 rajveer 2861 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2862 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2863 
    args = deleteItemFromMyResearch_args()
2864 
    args.userId = userId
2865 
    args.itemId = itemId
1596 ankur.sing 2866 
    args.write(self._oprot)
2867 
    self._oprot.writeMessageEnd()
2868 
    self._oprot.trans.flush()
2869 
 
2981 rajveer 2870 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2872 
    if mtype == TMessageType.EXCEPTION:
2873 
      x = TApplicationException()
2874 
      x.read(self._iprot)
2875 
      self._iprot.readMessageEnd()
2876 
      raise x
2981 rajveer 2877 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2878 
    result.read(self._iprot)
2879 
    self._iprot.readMessageEnd()
3431 rajveer 2880 
    if result.scx is not None:
2981 rajveer 2881 
      raise result.scx
2882 
    return
1596 ankur.sing 2883 
 
2981 rajveer 2884 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2885 
    """
2981 rajveer 2886 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2887 
 
1673 ankur.sing 2888 
    Parameters:
2981 rajveer 2889 
     - userId
1673 ankur.sing 2890 
    """
2981 rajveer 2891 
    self.send_getBrowseHistoryItems(userId)
2892 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2893 
 
2981 rajveer 2894 
  def send_getBrowseHistoryItems(self, userId):
2895 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2896 
    args = getBrowseHistoryItems_args()
2897 
    args.userId = userId
1673 ankur.sing 2898 
    args.write(self._oprot)
2899 
    self._oprot.writeMessageEnd()
2900 
    self._oprot.trans.flush()
2901 
 
2981 rajveer 2902 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2904 
    if mtype == TMessageType.EXCEPTION:
2905 
      x = TApplicationException()
2906 
      x.read(self._iprot)
2907 
      self._iprot.readMessageEnd()
2908 
      raise x
2981 rajveer 2909 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2910 
    result.read(self._iprot)
2911 
    self._iprot.readMessageEnd()
3431 rajveer 2912 
    if result.success is not None:
1673 ankur.sing 2913 
      return result.success
3431 rajveer 2914 
    if result.scx is not None:
2981 rajveer 2915 
      raise result.scx
2916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2917 
 
2981 rajveer 2918 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2919 
    """
2981 rajveer 2920 
    add item to browse history for a user
3431 rajveer 2921 
 
2642 varun.gupt 2922 
    Parameters:
2981 rajveer 2923 
     - userId
2924 
     - itemId
2642 varun.gupt 2925 
    """
2981 rajveer 2926 
    self.send_updateBrowseHistory(userId, itemId)
2927 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2928 
 
2981 rajveer 2929 
  def send_updateBrowseHistory(self, userId, itemId):
2930 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2931 
    args = updateBrowseHistory_args()
2932 
    args.userId = userId
2933 
    args.itemId = itemId
2642 varun.gupt 2934 
    args.write(self._oprot)
2935 
    self._oprot.writeMessageEnd()
2936 
    self._oprot.trans.flush()
2937 
 
2981 rajveer 2938 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2940 
    if mtype == TMessageType.EXCEPTION:
2941 
      x = TApplicationException()
2942 
      x.read(self._iprot)
2943 
      self._iprot.readMessageEnd()
2944 
      raise x
2981 rajveer 2945 
    result = updateBrowseHistory_result()
2642 varun.gupt 2946 
    result.read(self._iprot)
2947 
    self._iprot.readMessageEnd()
2948 
    return
2949 
 
3385 varun.gupt 2950 
  def getCartsWithCouponCount(self, couponCode):
2951 
    """
2952 
    Returns count of Carts with given coupon applied
3431 rajveer 2953 
 
3385 varun.gupt 2954 
    Parameters:
2955 
     - couponCode
2956 
    """
2957 
    self.send_getCartsWithCouponCount(couponCode)
2958 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2959 
 
3385 varun.gupt 2960 
  def send_getCartsWithCouponCount(self, couponCode):
2961 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2962 
    args = getCartsWithCouponCount_args()
2963 
    args.couponCode = couponCode
2964 
    args.write(self._oprot)
2965 
    self._oprot.writeMessageEnd()
2966 
    self._oprot.trans.flush()
2967 
 
2968 
  def recv_getCartsWithCouponCount(self, ):
2969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2970 
    if mtype == TMessageType.EXCEPTION:
2971 
      x = TApplicationException()
2972 
      x.read(self._iprot)
2973 
      self._iprot.readMessageEnd()
2974 
      raise x
2975 
    result = getCartsWithCouponCount_result()
2976 
    result.read(self._iprot)
2977 
    self._iprot.readMessageEnd()
3431 rajveer 2978 
    if result.success is not None:
3385 varun.gupt 2979 
      return result.success
2980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2981 
 
3499 mandeep.dh 2982 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2983 
    """
2984 
    Updates COD trust level of a user
3385 varun.gupt 2985 
 
3499 mandeep.dh 2986 
    Parameters:
2987 
     - userId
2988 
     - trustLevelDelta
2989 
    """
2990 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2991 
 
2992 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2993 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2994 
    args = increaseTrustLevel_args()
2995 
    args.userId = userId
2996 
    args.trustLevelDelta = trustLevelDelta
2997 
    args.write(self._oprot)
2998 
    self._oprot.writeMessageEnd()
2999 
    self._oprot.trans.flush()
5407 amar.kumar 3000 
  def getTrustLevel(self, userId):
3001 
    """
3002 
    Get trust level of a user
3003 
 
3004 
    Parameters:
3005 
     - userId
3006 
    """
3007 
    self.send_getTrustLevel(userId)
3008 
    return self.recv_getTrustLevel()
3009 
 
3010 
  def send_getTrustLevel(self, userId):
3011 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3012 
    args = getTrustLevel_args()
3013 
    args.userId = userId
3014 
    args.write(self._oprot)
3015 
    self._oprot.writeMessageEnd()
3016 
    self._oprot.trans.flush()
3017 
 
3018 
  def recv_getTrustLevel(self, ):
3019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3020 
    if mtype == TMessageType.EXCEPTION:
3021 
      x = TApplicationException()
3022 
      x.read(self._iprot)
3023 
      self._iprot.readMessageEnd()
3024 
      raise x
3025 
    result = getTrustLevel_result()
3026 
    result.read(self._iprot)
3027 
    self._iprot.readMessageEnd()
3028 
    if result.success is not None:
3029 
      return result.success
3030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3031 
 
4668 varun.gupt 3032 
  def showCODOption(self, cartId, sourceId, pincode):
3033 
    """
3034 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3035 
 
4668 varun.gupt 3036 
    Parameters:
3037 
     - cartId
3038 
     - sourceId
3039 
     - pincode
3040 
    """
3041 
    self.send_showCODOption(cartId, sourceId, pincode)
3042 
    return self.recv_showCODOption()
3043 
 
3044 
  def send_showCODOption(self, cartId, sourceId, pincode):
3045 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3046 
    args = showCODOption_args()
3047 
    args.cartId = cartId
3048 
    args.sourceId = sourceId
3049 
    args.pincode = pincode
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_showCODOption(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = showCODOption_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    if result.success is not None:
3065 
      return result.success
3066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3067 
 
5623 anupam.sin 3068 
  def getUserEmails(self, startDate, endDate):
3069 
    """
3070 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3071 
 
5623 anupam.sin 3072 
    Parameters:
3073 
     - startDate
3074 
     - endDate
3075 
    """
3076 
    self.send_getUserEmails(startDate, endDate)
3077 
    return self.recv_getUserEmails()
3078 
 
3079 
  def send_getUserEmails(self, startDate, endDate):
3080 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3081 
    args = getUserEmails_args()
3082 
    args.startDate = startDate
3083 
    args.endDate = endDate
3084 
    args.write(self._oprot)
3085 
    self._oprot.writeMessageEnd()
3086 
    self._oprot.trans.flush()
3087 
 
3088 
  def recv_getUserEmails(self, ):
3089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3090 
    if mtype == TMessageType.EXCEPTION:
3091 
      x = TApplicationException()
3092 
      x.read(self._iprot)
3093 
      self._iprot.readMessageEnd()
3094 
      raise x
3095 
    result = getUserEmails_result()
3096 
    result.read(self._iprot)
3097 
    self._iprot.readMessageEnd()
3098 
    if result.success is not None:
3099 
      return result.success
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3101 
 
9299 kshitij.so 3102 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3103 
    """
3104 
    Mark a cart lineitem as insured. Returns true/false.
3105 
 
3106 
    Parameters:
3107 
     - itemId
3108 
     - cartId
3109 
     - toInsure
9299 kshitij.so 3110 
     - insurerType
6903 anupam.sin 3111 
    """
9299 kshitij.so 3112 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3113 
    return self.recv_insureItem()
3114 
 
9299 kshitij.so 3115 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3116 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3117 
    args = insureItem_args()
3118 
    args.itemId = itemId
3119 
    args.cartId = cartId
3120 
    args.toInsure = toInsure
9299 kshitij.so 3121 
    args.insurerType = insurerType
6903 anupam.sin 3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_insureItem(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = insureItem_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.success is not None:
3137 
      return result.success
3138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3139 
 
3140 
  def cancelInsurance(self, cartId):
3141 
    """
3142 
    Cancel insurance for all items in the cart
3143 
 
3144 
    Parameters:
3145 
     - cartId
3146 
    """
3147 
    self.send_cancelInsurance(cartId)
3148 
    return self.recv_cancelInsurance()
3149 
 
3150 
  def send_cancelInsurance(self, cartId):
3151 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3152 
    args = cancelInsurance_args()
3153 
    args.cartId = cartId
3154 
    args.write(self._oprot)
3155 
    self._oprot.writeMessageEnd()
3156 
    self._oprot.trans.flush()
3157 
 
3158 
  def recv_cancelInsurance(self, ):
3159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3160 
    if mtype == TMessageType.EXCEPTION:
3161 
      x = TApplicationException()
3162 
      x.read(self._iprot)
3163 
      self._iprot.readMessageEnd()
3164 
      raise x
3165 
    result = cancelInsurance_result()
3166 
    result.read(self._iprot)
3167 
    self._iprot.readMessageEnd()
3168 
    if result.success is not None:
3169 
      return result.success
3170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3171 
 
3172 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3173 
    """
3174 
    Stores insurance specific details like date of birth and guardianName
3175 
 
3176 
    Parameters:
3177 
     - addressId
3178 
     - dob
3179 
     - guardianName
3180 
    """
3181 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3182 
    return self.recv_storeInsuranceSpecificDetails()
3183 
 
3184 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3185 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3186 
    args = storeInsuranceSpecificDetails_args()
3187 
    args.addressId = addressId
3188 
    args.dob = dob
3189 
    args.guardianName = guardianName
3190 
    args.write(self._oprot)
3191 
    self._oprot.writeMessageEnd()
3192 
    self._oprot.trans.flush()
3193 
 
3194 
  def recv_storeInsuranceSpecificDetails(self, ):
3195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3196 
    if mtype == TMessageType.EXCEPTION:
3197 
      x = TApplicationException()
3198 
      x.read(self._iprot)
3199 
      self._iprot.readMessageEnd()
3200 
      raise x
3201 
    result = storeInsuranceSpecificDetails_result()
3202 
    result.read(self._iprot)
3203 
    self._iprot.readMessageEnd()
3204 
    if result.success is not None:
3205 
      return result.success
3206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3207 
 
3208 
  def isInsuranceDetailPresent(self, addressId):
3209 
    """
3210 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3211 
 
3212 
    Parameters:
3213 
     - addressId
3214 
    """
3215 
    self.send_isInsuranceDetailPresent(addressId)
3216 
    return self.recv_isInsuranceDetailPresent()
3217 
 
3218 
  def send_isInsuranceDetailPresent(self, addressId):
3219 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3220 
    args = isInsuranceDetailPresent_args()
3221 
    args.addressId = addressId
3222 
    args.write(self._oprot)
3223 
    self._oprot.writeMessageEnd()
3224 
    self._oprot.trans.flush()
3225 
 
3226 
  def recv_isInsuranceDetailPresent(self, ):
3227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3228 
    if mtype == TMessageType.EXCEPTION:
3229 
      x = TApplicationException()
3230 
      x.read(self._iprot)
3231 
      self._iprot.readMessageEnd()
3232 
      raise x
3233 
    result = isInsuranceDetailPresent_result()
3234 
    result.read(self._iprot)
3235 
    self._iprot.readMessageEnd()
3236 
    if result.success is not None:
3237 
      return result.success
3238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3239 
 
9791 rajveer 3240 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3241 
    """
9791 rajveer 3242 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3243 
 
6821 amar.kumar 3244 
    Parameters:
3245 
     - startDate
3246 
     - endDate
3247 
    """
9791 rajveer 3248 
    self.send_getProductsAddedToCart(startDate, endDate)
3249 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3250 
 
9791 rajveer 3251 
  def send_getProductsAddedToCart(self, startDate, endDate):
3252 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3253 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3254 
    args.startDate = startDate
3255 
    args.endDate = endDate
3256 
    args.write(self._oprot)
3257 
    self._oprot.writeMessageEnd()
3258 
    self._oprot.trans.flush()
3259 
 
9791 rajveer 3260 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3262 
    if mtype == TMessageType.EXCEPTION:
3263 
      x = TApplicationException()
3264 
      x.read(self._iprot)
3265 
      self._iprot.readMessageEnd()
3266 
      raise x
9791 rajveer 3267 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3268 
    result.read(self._iprot)
3269 
    self._iprot.readMessageEnd()
3270 
    if result.success is not None:
3271 
      return result.success
9791 rajveer 3272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3273 
 
11980 amit.gupta 3274 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3275 
    """
3276 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3277 
 
11592 amit.gupta 3278 
    Parameters:
3279 
     - cartId
3280 
     - sourceId
11980 amit.gupta 3281 
     - dealerCoupon
11592 amit.gupta 3282 
    """
11980 amit.gupta 3283 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3284 
    return self.recv_validateCartPlus()
3285 
 
11980 amit.gupta 3286 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3287 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3288 
    args = validateCartPlus_args()
3289 
    args.cartId = cartId
3290 
    args.sourceId = sourceId
11980 amit.gupta 3291 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3292 
    args.write(self._oprot)
3293 
    self._oprot.writeMessageEnd()
3294 
    self._oprot.trans.flush()
3295 
 
3296 
  def recv_validateCartPlus(self, ):
3297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3298 
    if mtype == TMessageType.EXCEPTION:
3299 
      x = TApplicationException()
3300 
      x.read(self._iprot)
3301 
      self._iprot.readMessageEnd()
3302 
      raise x
3303 
    result = validateCartPlus_result()
3304 
    result.read(self._iprot)
3305 
    self._iprot.readMessageEnd()
3306 
    if result.success is not None:
3307 
      return result.success
3308 
    if result.scex is not None:
3309 
      raise result.scex
3310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3311 
 
11679 vikram.rag 3312 
  def isPrivateDealUser(self, userId):
3313 
    """
3314 
    Parameters:
3315 
     - userId
3316 
    """
3317 
    self.send_isPrivateDealUser(userId)
3318 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3319 
 
11679 vikram.rag 3320 
  def send_isPrivateDealUser(self, userId):
3321 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3322 
    args = isPrivateDealUser_args()
3323 
    args.userId = userId
3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3328 
  def recv_isPrivateDealUser(self, ):
3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3335 
    result = isPrivateDealUser_result()
3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3338 
    if result.success is not None:
3339 
      return result.success
3340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3341 
 
11890 kshitij.so 3342 
  def addPrivateDealUser(self, userId):
3343 
    """
3344 
    Parameters:
3345 
     - userId
3346 
    """
3347 
    self.send_addPrivateDealUser(userId)
3348 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3349 
 
11890 kshitij.so 3350 
  def send_addPrivateDealUser(self, userId):
3351 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3352 
    args = addPrivateDealUser_args()
3353 
    args.userId = userId
3354 
    args.write(self._oprot)
3355 
    self._oprot.writeMessageEnd()
3356 
    self._oprot.trans.flush()
3357 
 
3358 
  def recv_addPrivateDealUser(self, ):
3359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3360 
    if mtype == TMessageType.EXCEPTION:
3361 
      x = TApplicationException()
3362 
      x.read(self._iprot)
3363 
      self._iprot.readMessageEnd()
3364 
      raise x
3365 
    result = addPrivateDealUser_result()
3366 
    result.read(self._iprot)
3367 
    self._iprot.readMessageEnd()
3368 
    if result.success is not None:
3369 
      return result.success
3370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3371 
 
3372 
  def changePrivateDealUserStatus(self, userId, isActive):
3373 
    """
3374 
    Parameters:
3375 
     - userId
3376 
     - isActive
3377 
    """
3378 
    self.send_changePrivateDealUserStatus(userId, isActive)
3379 
    return self.recv_changePrivateDealUserStatus()
3380 
 
3381 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3382 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3383 
    args = changePrivateDealUserStatus_args()
3384 
    args.userId = userId
3385 
    args.isActive = isActive
3386 
    args.write(self._oprot)
3387 
    self._oprot.writeMessageEnd()
3388 
    self._oprot.trans.flush()
3389 
 
3390 
  def recv_changePrivateDealUserStatus(self, ):
3391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3392 
    if mtype == TMessageType.EXCEPTION:
3393 
      x = TApplicationException()
3394 
      x.read(self._iprot)
3395 
      self._iprot.readMessageEnd()
3396 
      raise x
3397 
    result = changePrivateDealUserStatus_result()
3398 
    result.read(self._iprot)
3399 
    self._iprot.readMessageEnd()
3400 
    if result.success is not None:
3401 
      return result.success
3402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3403 
 
3404 
  def getPrivateDealUser(self, userId):
3405 
    """
3406 
    Parameters:
3407 
     - userId
3408 
    """
3409 
    self.send_getPrivateDealUser(userId)
3410 
    return self.recv_getPrivateDealUser()
3411 
 
3412 
  def send_getPrivateDealUser(self, userId):
3413 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3414 
    args = getPrivateDealUser_args()
3415 
    args.userId = userId
3416 
    args.write(self._oprot)
3417 
    self._oprot.writeMessageEnd()
3418 
    self._oprot.trans.flush()
3419 
 
3420 
  def recv_getPrivateDealUser(self, ):
3421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3422 
    if mtype == TMessageType.EXCEPTION:
3423 
      x = TApplicationException()
3424 
      x.read(self._iprot)
3425 
      self._iprot.readMessageEnd()
3426 
      raise x
3427 
    result = getPrivateDealUser_result()
3428 
    result.read(self._iprot)
3429 
    self._iprot.readMessageEnd()
3430 
    if result.success is not None:
3431 
      return result.success
3432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3433 
 
12696 amit.gupta 3434 
  def registerCounter(self, counter, userId):
3435 
    """
3436 
    Parameters:
3437 
     - counter
3438 
     - userId
3439 
    """
3440 
    self.send_registerCounter(counter, userId)
3441 
    return self.recv_registerCounter()
11890 kshitij.so 3442 
 
12696 amit.gupta 3443 
  def send_registerCounter(self, counter, userId):
3444 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3445 
    args = registerCounter_args()
3446 
    args.counter = counter
3447 
    args.userId = userId
3448 
    args.write(self._oprot)
3449 
    self._oprot.writeMessageEnd()
3450 
    self._oprot.trans.flush()
3451 
 
3452 
  def recv_registerCounter(self, ):
3453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3454 
    if mtype == TMessageType.EXCEPTION:
3455 
      x = TApplicationException()
3456 
      x.read(self._iprot)
3457 
      self._iprot.readMessageEnd()
3458 
      raise x
3459 
    result = registerCounter_result()
3460 
    result.read(self._iprot)
3461 
    self._iprot.readMessageEnd()
3462 
    if result.success is not None:
3463 
      return result.success
3464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3465 
 
12722 amit.gupta 3466 
  def searchCounter(self, type1, searchString):
3467 
    """
3468 
    Parameters:
3469 
     - type1
3470 
     - searchString
3471 
    """
3472 
    self.send_searchCounter(type1, searchString)
3473 
    return self.recv_searchCounter()
12696 amit.gupta 3474 
 
12722 amit.gupta 3475 
  def send_searchCounter(self, type1, searchString):
3476 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3477 
    args = searchCounter_args()
3478 
    args.type1 = type1
3479 
    args.searchString = searchString
3480 
    args.write(self._oprot)
3481 
    self._oprot.writeMessageEnd()
3482 
    self._oprot.trans.flush()
3483 
 
3484 
  def recv_searchCounter(self, ):
3485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3486 
    if mtype == TMessageType.EXCEPTION:
3487 
      x = TApplicationException()
3488 
      x.read(self._iprot)
3489 
      self._iprot.readMessageEnd()
3490 
      raise x
3491 
    result = searchCounter_result()
3492 
    result.read(self._iprot)
3493 
    self._iprot.readMessageEnd()
3494 
    if result.success is not None:
3495 
      return result.success
3496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3497 
 
18977 amit.gupta 3498 
  def getCounterByUserId(self, userId):
3499 
    """
3500 
    Parameters:
3501 
     - userId
3502 
    """
3503 
    self.send_getCounterByUserId(userId)
3504 
    return self.recv_getCounterByUserId()
3505 
 
3506 
  def send_getCounterByUserId(self, userId):
3507 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3508 
    args = getCounterByUserId_args()
3509 
    args.userId = userId
3510 
    args.write(self._oprot)
3511 
    self._oprot.writeMessageEnd()
3512 
    self._oprot.trans.flush()
3513 
 
3514 
  def recv_getCounterByUserId(self, ):
3515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3516 
    if mtype == TMessageType.EXCEPTION:
3517 
      x = TApplicationException()
3518 
      x.read(self._iprot)
3519 
      self._iprot.readMessageEnd()
3520 
      raise x
3521 
    result = getCounterByUserId_result()
3522 
    result.read(self._iprot)
3523 
    self._iprot.readMessageEnd()
3524 
    if result.success is not None:
3525 
      return result.success
3526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3527 
 
12722 amit.gupta 3528 
  def getAllUsersByCounter(self, counterId):
3529 
    """
3530 
    Parameters:
3531 
     - counterId
3532 
    """
3533 
    self.send_getAllUsersByCounter(counterId)
3534 
    return self.recv_getAllUsersByCounter()
3535 
 
3536 
  def send_getAllUsersByCounter(self, counterId):
3537 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3538 
    args = getAllUsersByCounter_args()
3539 
    args.counterId = counterId
3540 
    args.write(self._oprot)
3541 
    self._oprot.writeMessageEnd()
3542 
    self._oprot.trans.flush()
3543 
 
3544 
  def recv_getAllUsersByCounter(self, ):
3545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3546 
    if mtype == TMessageType.EXCEPTION:
3547 
      x = TApplicationException()
3548 
      x.read(self._iprot)
3549 
      self._iprot.readMessageEnd()
3550 
      raise x
3551 
    result = getAllUsersByCounter_result()
3552 
    result.read(self._iprot)
3553 
    self._iprot.readMessageEnd()
3554 
    if result.success is not None:
3555 
      return result.success
3556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3557 
 
15251 manish.sha 3558 
  def getActiveAccessTokenForUser(self, userId, source):
3559 
    """
3560 
    Parameters:
3561 
     - userId
3562 
     - source
3563 
    """
3564 
    self.send_getActiveAccessTokenForUser(userId, source)
3565 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3566 
 
15251 manish.sha 3567 
  def send_getActiveAccessTokenForUser(self, userId, source):
3568 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3569 
    args = getActiveAccessTokenForUser_args()
3570 
    args.userId = userId
3571 
    args.source = source
3572 
    args.write(self._oprot)
3573 
    self._oprot.writeMessageEnd()
3574 
    self._oprot.trans.flush()
3575 
 
3576 
  def recv_getActiveAccessTokenForUser(self, ):
3577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3578 
    if mtype == TMessageType.EXCEPTION:
3579 
      x = TApplicationException()
3580 
      x.read(self._iprot)
3581 
      self._iprot.readMessageEnd()
3582 
      raise x
3583 
    result = getActiveAccessTokenForUser_result()
3584 
    result.read(self._iprot)
3585 
    self._iprot.readMessageEnd()
3586 
    if result.success is not None:
3587 
      return result.success
3588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3589 
 
3590 
  def validateAccessToken(self, accessToken):
3591 
    """
3592 
    Parameters:
3593 
     - accessToken
3594 
    """
3595 
    self.send_validateAccessToken(accessToken)
3596 
    return self.recv_validateAccessToken()
3597 
 
3598 
  def send_validateAccessToken(self, accessToken):
3599 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3600 
    args = validateAccessToken_args()
3601 
    args.accessToken = accessToken
3602 
    args.write(self._oprot)
3603 
    self._oprot.writeMessageEnd()
3604 
    self._oprot.trans.flush()
3605 
 
3606 
  def recv_validateAccessToken(self, ):
3607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3608 
    if mtype == TMessageType.EXCEPTION:
3609 
      x = TApplicationException()
3610 
      x.read(self._iprot)
3611 
      self._iprot.readMessageEnd()
3612 
      raise x
3613 
    result = validateAccessToken_result()
3614 
    result.read(self._iprot)
3615 
    self._iprot.readMessageEnd()
3616 
    if result.success is not None:
3617 
      return result.success
3618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3619 
 
17782 amit.gupta 3620 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3621 
    """
3622 
    Parameters:
3623 
     - cartId
3624 
     - itemQty
3625 
     - couponCode
3626 
    """
3627 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3628 
    return self.recv_addItemsToCart()
15251 manish.sha 3629 
 
17782 amit.gupta 3630 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3631 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3632 
    args = addItemsToCart_args()
3633 
    args.cartId = cartId
3634 
    args.itemQty = itemQty
3635 
    args.couponCode = couponCode
3636 
    args.write(self._oprot)
3637 
    self._oprot.writeMessageEnd()
3638 
    self._oprot.trans.flush()
3639 
 
3640 
  def recv_addItemsToCart(self, ):
3641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3642 
    if mtype == TMessageType.EXCEPTION:
3643 
      x = TApplicationException()
3644 
      x.read(self._iprot)
3645 
      self._iprot.readMessageEnd()
3646 
      raise x
3647 
    result = addItemsToCart_result()
3648 
    result.read(self._iprot)
3649 
    self._iprot.readMessageEnd()
3650 
    if result.success is not None:
3651 
      return result.success
3652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3653 
 
3654 
  def validateCartNew(self, cartId, pinCode, sourceId):
3655 
    """
3656 
    Parameters:
3657 
     - cartId
3658 
     - pinCode
3659 
     - sourceId
3660 
    """
3661 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3662 
    return self.recv_validateCartNew()
3663 
 
3664 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3665 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3666 
    args = validateCartNew_args()
3667 
    args.cartId = cartId
3668 
    args.pinCode = pinCode
3669 
    args.sourceId = sourceId
3670 
    args.write(self._oprot)
3671 
    self._oprot.writeMessageEnd()
3672 
    self._oprot.trans.flush()
3673 
 
3674 
  def recv_validateCartNew(self, ):
3675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3676 
    if mtype == TMessageType.EXCEPTION:
3677 
      x = TApplicationException()
3678 
      x.read(self._iprot)
3679 
      self._iprot.readMessageEnd()
3680 
      raise x
3681 
    result = validateCartNew_result()
3682 
    result.read(self._iprot)
3683 
    self._iprot.readMessageEnd()
3684 
    if result.success is not None:
3685 
      return result.success
3686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3687 
 
18644 manish.sha 3688 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3689 
    """
3690 
    Parameters:
3691 
     - userId
3692 
    """
18644 manish.sha 3693 
    self.send_isAddressEditableForCounter(userId)
3694 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3695 
 
18644 manish.sha 3696 
  def send_isAddressEditableForCounter(self, userId):
3697 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3698 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3699 
    args.userId = userId
3700 
    args.write(self._oprot)
3701 
    self._oprot.writeMessageEnd()
3702 
    self._oprot.trans.flush()
3703 
 
18644 manish.sha 3704 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3706 
    if mtype == TMessageType.EXCEPTION:
3707 
      x = TApplicationException()
3708 
      x.read(self._iprot)
3709 
      self._iprot.readMessageEnd()
3710 
      raise x
18644 manish.sha 3711 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3712 
    result.read(self._iprot)
3713 
    self._iprot.readMessageEnd()
3714 
    if result.success is not None:
3715 
      return result.success
18644 manish.sha 3716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3717 
 
3718 
  def getBillingAddressForUser(self, userId):
3719 
    """
3720 
    Parameters:
3721 
     - userId
3722 
    """
3723 
    self.send_getBillingAddressForUser(userId)
3724 
    return self.recv_getBillingAddressForUser()
3725 
 
3726 
  def send_getBillingAddressForUser(self, userId):
3727 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3728 
    args = getBillingAddressForUser_args()
3729 
    args.userId = userId
3730 
    args.write(self._oprot)
3731 
    self._oprot.writeMessageEnd()
3732 
    self._oprot.trans.flush()
3733 
 
3734 
  def recv_getBillingAddressForUser(self, ):
3735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3736 
    if mtype == TMessageType.EXCEPTION:
3737 
      x = TApplicationException()
3738 
      x.read(self._iprot)
3739 
      self._iprot.readMessageEnd()
3740 
      raise x
3741 
    result = getBillingAddressForUser_result()
3742 
    result.read(self._iprot)
3743 
    self._iprot.readMessageEnd()
3744 
    if result.success is not None:
3745 
      return result.success
3746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3747 
 
18590 manish.sha 3748 
  def isCreditorAssigned(self, userId):
3749 
    """
3750 
    Parameters:
3751 
     - userId
3752 
    """
3753 
    self.send_isCreditorAssigned(userId)
3754 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3755 
 
18590 manish.sha 3756 
  def send_isCreditorAssigned(self, userId):
3757 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3758 
    args = isCreditorAssigned_args()
3759 
    args.userId = userId
3760 
    args.write(self._oprot)
3761 
    self._oprot.writeMessageEnd()
3762 
    self._oprot.trans.flush()
3763 
 
3764 
  def recv_isCreditorAssigned(self, ):
3765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3766 
    if mtype == TMessageType.EXCEPTION:
3767 
      x = TApplicationException()
3768 
      x.read(self._iprot)
3769 
      self._iprot.readMessageEnd()
3770 
      raise x
3771 
    result = isCreditorAssigned_result()
3772 
    result.read(self._iprot)
3773 
    self._iprot.readMessageEnd()
3774 
    if result.success is not None:
3775 
      return result.success
3776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3777 
 
18735 manish.sha 3778 
  def isTaxInvoiceEnabledUser(self, userId):
3779 
    """
3780 
    Parameters:
3781 
     - userId
3782 
    """
3783 
    self.send_isTaxInvoiceEnabledUser(userId)
3784 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3785 
 
18735 manish.sha 3786 
  def send_isTaxInvoiceEnabledUser(self, userId):
3787 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3788 
    args = isTaxInvoiceEnabledUser_args()
3789 
    args.userId = userId
3790 
    args.write(self._oprot)
3791 
    self._oprot.writeMessageEnd()
3792 
    self._oprot.trans.flush()
3793 
 
3794 
  def recv_isTaxInvoiceEnabledUser(self, ):
3795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3796 
    if mtype == TMessageType.EXCEPTION:
3797 
      x = TApplicationException()
3798 
      x.read(self._iprot)
3799 
      self._iprot.readMessageEnd()
3800 
      raise x
3801 
    result = isTaxInvoiceEnabledUser_result()
3802 
    result.read(self._iprot)
3803 
    self._iprot.readMessageEnd()
3804 
    if result.success is not None:
3805 
      return result.success
3806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3807 
 
19182 amit.gupta 3808 
  def taxInvoiceAvailable(self, addressId):
3809 
    """
3810 
    Parameters:
3811 
     - addressId
3812 
    """
3813 
    self.send_taxInvoiceAvailable(addressId)
3814 
    return self.recv_taxInvoiceAvailable()
3815 
 
3816 
  def send_taxInvoiceAvailable(self, addressId):
3817 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3818 
    args = taxInvoiceAvailable_args()
3819 
    args.addressId = addressId
3820 
    args.write(self._oprot)
3821 
    self._oprot.writeMessageEnd()
3822 
    self._oprot.trans.flush()
3823 
 
3824 
  def recv_taxInvoiceAvailable(self, ):
3825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3826 
    if mtype == TMessageType.EXCEPTION:
3827 
      x = TApplicationException()
3828 
      x.read(self._iprot)
3829 
      self._iprot.readMessageEnd()
3830 
      raise x
3831 
    result = taxInvoiceAvailable_result()
3832 
    result.read(self._iprot)
3833 
    self._iprot.readMessageEnd()
3834 
    if result.success is not None:
3835 
      return result.success
3836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3837 
 
18764 kshitij.so 3838 
  def getCartByValue(self, cartIds):
3839 
    """
3840 
    Parameters:
3841 
     - cartIds
3842 
    """
3843 
    self.send_getCartByValue(cartIds)
3844 
    return self.recv_getCartByValue()
18735 manish.sha 3845 
 
18764 kshitij.so 3846 
  def send_getCartByValue(self, cartIds):
3847 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3848 
    args = getCartByValue_args()
3849 
    args.cartIds = cartIds
3850 
    args.write(self._oprot)
3851 
    self._oprot.writeMessageEnd()
3852 
    self._oprot.trans.flush()
3853 
 
3854 
  def recv_getCartByValue(self, ):
3855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3856 
    if mtype == TMessageType.EXCEPTION:
3857 
      x = TApplicationException()
3858 
      x.read(self._iprot)
3859 
      self._iprot.readMessageEnd()
3860 
      raise x
3861 
    result = getCartByValue_result()
3862 
    result.read(self._iprot)
3863 
    self._iprot.readMessageEnd()
3864 
    if result.success is not None:
3865 
      return result.success
3866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3867 
 
19889 manas 3868 
  def getCounterName(self, userIds):
3869 
    """
3870 
    Parameters:
3871 
     - userIds
3872 
    """
3873 
    self.send_getCounterName(userIds)
3874 
    return self.recv_getCounterName()
18764 kshitij.so 3875 
 
19889 manas 3876 
  def send_getCounterName(self, userIds):
3877 
    self._oprot.writeMessageBegin('getCounterName', TMessageType.CALL, self._seqid)
3878 
    args = getCounterName_args()
3879 
    args.userIds = userIds
3880 
    args.write(self._oprot)
3881 
    self._oprot.writeMessageEnd()
3882 
    self._oprot.trans.flush()
3883 
 
3884 
  def recv_getCounterName(self, ):
3885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3886 
    if mtype == TMessageType.EXCEPTION:
3887 
      x = TApplicationException()
3888 
      x.read(self._iprot)
3889 
      self._iprot.readMessageEnd()
3890 
      raise x
3891 
    result = getCounterName_result()
3892 
    result.read(self._iprot)
3893 
    self._iprot.readMessageEnd()
3894 
    if result.success is not None:
3895 
      return result.success
3896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterName failed: unknown result");
3897 
 
3898 
 
3376 rajveer 3899 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3900 
  def __init__(self, handler):
3376 rajveer 3901 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3902 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3903 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3904 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3905 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3906 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3907 
    self._processMap["createUser"] = Processor.process_createUser
3908 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3909 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3910 
    self._processMap["userExists"] = Processor.process_userExists
3911 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3912 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3913 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3914 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3915 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3916 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3917 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3918 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3919 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3920 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3921 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3922 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3923 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3924 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3925 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3926 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3927 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3928 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3929 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3930 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3931 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3932 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3933 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3934 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3935 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3936 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3937 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3938 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3939 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3940 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3941 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3942 
    self._processMap["getCart"] = Processor.process_getCart
3943 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3944 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3945 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3946 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3947 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3948 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3949 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3950 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3951 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3952 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3953 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3954 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3955 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3956 
    self._processMap["checkOut"] = Processor.process_checkOut
3957 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3958 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3959 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3960 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3961 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3962 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3963 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3964 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3965 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3966 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3967 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3968 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3969 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3970 
    self._processMap["insureItem"] = Processor.process_insureItem
3971 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3972 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3973 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3974 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3975 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3976 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3977 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3978 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3979 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3980 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3981 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 3982 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 3983 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3984 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3985 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3986 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3987 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 3988 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 3989 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 3990 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 3991 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 3992 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 3993 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
19889 manas 3994 
    self._processMap["getCounterName"] = Processor.process_getCounterName
94 ashish 3995 
 
3996 
  def process(self, iprot, oprot):
3997 
    (name, type, seqid) = iprot.readMessageBegin()
3998 
    if name not in self._processMap:
3999 
      iprot.skip(TType.STRUCT)
4000 
      iprot.readMessageEnd()
4001 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4002 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4003 
      x.write(oprot)
4004 
      oprot.writeMessageEnd()
4005 
      oprot.trans.flush()
4006 
      return
4007 
    else:
4008 
      self._processMap[name](self, seqid, iprot, oprot)
4009 
    return True
4010 
 
559 chandransh 4011 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
4012 
    args = createAnonymousUser_args()
94 ashish 4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
559 chandransh 4015 
    result = createAnonymousUser_result()
94 ashish 4016 
    try:
559 chandransh 4017 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
4018 
    except UserContextException, ucex:
4019 
      result.ucex = ucex
4020 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 4021 
    result.write(oprot)
4022 
    oprot.writeMessageEnd()
4023 
    oprot.trans.flush()
4024 
 
559 chandransh 4025 
  def process_getUserById(self, seqid, iprot, oprot):
4026 
    args = getUserById_args()
94 ashish 4027 
    args.read(iprot)
4028 
    iprot.readMessageEnd()
559 chandransh 4029 
    result = getUserById_result()
94 ashish 4030 
    try:
559 chandransh 4031 
      result.success = self._handler.getUserById(args.userId)
4032 
    except UserContextException, ucex:
4033 
      result.ucex = ucex
4034 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
5326 rajveer 4039 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4040 
    args = getUserByCartId_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = getUserByCartId_result()
4044 
    try:
4045 
      result.success = self._handler.getUserByCartId(args.cartId)
4046 
    except UserContextException, ucex:
4047 
      result.ucex = ucex
4048 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4049 
    result.write(oprot)
4050 
    oprot.writeMessageEnd()
4051 
    oprot.trans.flush()
4052 
 
1491 vikas 4053 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4054 
    args = getUserByEmail_args()
4055 
    args.read(iprot)
4056 
    iprot.readMessageEnd()
4057 
    result = getUserByEmail_result()
4058 
    try:
4059 
      result.success = self._handler.getUserByEmail(args.email)
4060 
    except UserContextException, ucex:
4061 
      result.ucex = ucex
4062 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
4066 
 
3032 mandeep.dh 4067 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4068 
    args = getUserByMobileNumber_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = getUserByMobileNumber_result()
4072 
    try:
4073 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4074 
    except UserContextException, ucex:
4075 
      result.ucex = ucex
4076 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4077 
    result.write(oprot)
4078 
    oprot.writeMessageEnd()
4079 
    oprot.trans.flush()
4080 
 
559 chandransh 4081 
  def process_createUser(self, seqid, iprot, oprot):
4082 
    args = createUser_args()
94 ashish 4083 
    args.read(iprot)
4084 
    iprot.readMessageEnd()
559 chandransh 4085 
    result = createUser_result()
94 ashish 4086 
    try:
559 chandransh 4087 
      result.success = self._handler.createUser(args.user)
4088 
    except UserContextException, ucex:
4089 
      result.ucex = ucex
4090 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4091 
    result.write(oprot)
4092 
    oprot.writeMessageEnd()
4093 
    oprot.trans.flush()
4094 
 
559 chandransh 4095 
  def process_updateUser(self, seqid, iprot, oprot):
4096 
    args = updateUser_args()
94 ashish 4097 
    args.read(iprot)
4098 
    iprot.readMessageEnd()
559 chandransh 4099 
    result = updateUser_result()
94 ashish 4100 
    try:
559 chandransh 4101 
      result.success = self._handler.updateUser(args.user)
4102 
    except UserContextException, ucex:
4103 
      result.ucex = ucex
4104 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
4108 
 
122 ashish 4109 
  def process_authenticateUser(self, seqid, iprot, oprot):
4110 
    args = authenticateUser_args()
4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
4113 
    result = authenticateUser_result()
4114 
    try:
559 chandransh 4115 
      result.success = self._handler.authenticateUser(args.email, args.password)
4116 
    except AuthenticationException, auex:
4117 
      result.auex = auex
122 ashish 4118 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4119 
    result.write(oprot)
4120 
    oprot.writeMessageEnd()
4121 
    oprot.trans.flush()
4122 
 
94 ashish 4123 
  def process_userExists(self, seqid, iprot, oprot):
4124 
    args = userExists_args()
4125 
    args.read(iprot)
4126 
    iprot.readMessageEnd()
4127 
    result = userExists_result()
4128 
    try:
4129 
      result.success = self._handler.userExists(args.email)
4130 
    except UserContextException, ucx:
4131 
      result.ucx = ucx
4132 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
4137 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4138 
    args = addAddressForUser_args()
4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
4141 
    result = addAddressForUser_result()
4142 
    try:
567 rajveer 4143 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4144 
    except UserContextException, ucx:
4145 
      result.ucx = ucx
4146 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4147 
    result.write(oprot)
4148 
    oprot.writeMessageEnd()
4149 
    oprot.trans.flush()
4150 
 
4151 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4152 
    args = removeAddressForUser_args()
4153 
    args.read(iprot)
4154 
    iprot.readMessageEnd()
4155 
    result = removeAddressForUser_result()
4156 
    try:
4157 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4158 
    except UserContextException, ucx:
4159 
      result.ucx = ucx
4160 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4161 
    result.write(oprot)
4162 
    oprot.writeMessageEnd()
4163 
    oprot.trans.flush()
4164 
 
4165 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4166 
    args = setUserAsLoggedIn_args()
4167 
    args.read(iprot)
4168 
    iprot.readMessageEnd()
4169 
    result = setUserAsLoggedIn_result()
4170 
    try:
4171 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4172 
    except UserContextException, ucx:
4173 
      result.ucx = ucx
4174 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4175 
    result.write(oprot)
4176 
    oprot.writeMessageEnd()
4177 
    oprot.trans.flush()
4178 
 
4179 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4180 
    args = setUserAsLoggedOut_args()
4181 
    args.read(iprot)
4182 
    iprot.readMessageEnd()
4183 
    result = setUserAsLoggedOut_result()
4184 
    try:
4185 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4186 
    except UserContextException, ucx:
4187 
      result.ucx = ucx
4188 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4189 
    result.write(oprot)
4190 
    oprot.writeMessageEnd()
4191 
    oprot.trans.flush()
4192 
 
504 rajveer 4193 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4194 
    args = setDefaultAddress_args()
4195 
    args.read(iprot)
4196 
    iprot.readMessageEnd()
4197 
    result = setDefaultAddress_result()
4198 
    try:
4199 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4200 
    except UserContextException, ucx:
4201 
      result.ucx = ucx
4202 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4203 
    result.write(oprot)
4204 
    oprot.writeMessageEnd()
4205 
    oprot.trans.flush()
4206 
 
94 ashish 4207 
  def process_updatePassword(self, seqid, iprot, oprot):
4208 
    args = updatePassword_args()
4209 
    args.read(iprot)
4210 
    iprot.readMessageEnd()
4211 
    result = updatePassword_result()
4212 
    try:
594 rajveer 4213 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4214 
    except UserContextException, ucx:
4215 
      result.ucx = ucx
4216 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4217 
    result.write(oprot)
4218 
    oprot.writeMessageEnd()
4219 
    oprot.trans.flush()
4220 
 
581 rajveer 4221 
  def process_forgotPassword(self, seqid, iprot, oprot):
4222 
    args = forgotPassword_args()
4223 
    args.read(iprot)
4224 
    iprot.readMessageEnd()
4225 
    result = forgotPassword_result()
4226 
    try:
884 rajveer 4227 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4228 
    except UserContextException, ucx:
4229 
      result.ucx = ucx
4230 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4231 
    result.write(oprot)
4232 
    oprot.writeMessageEnd()
4233 
    oprot.trans.flush()
4234 
 
594 rajveer 4235 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4236 
    args = getAllAddressesForUser_args()
4237 
    args.read(iprot)
4238 
    iprot.readMessageEnd()
4239 
    result = getAllAddressesForUser_result()
4240 
    try:
4241 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4242 
    except UserContextException, ucx:
4243 
      result.ucx = ucx
4244 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4245 
    result.write(oprot)
4246 
    oprot.writeMessageEnd()
4247 
    oprot.trans.flush()
4248 
 
1894 vikas 4249 
  def process_getAddressById(self, seqid, iprot, oprot):
4250 
    args = getAddressById_args()
4251 
    args.read(iprot)
4252 
    iprot.readMessageEnd()
4253 
    result = getAddressById_result()
4254 
    try:
4255 
      result.success = self._handler.getAddressById(args.addressId)
4256 
    except UserContextException, ucx:
4257 
      result.ucx = ucx
4258 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4259 
    result.write(oprot)
4260 
    oprot.writeMessageEnd()
4261 
    oprot.trans.flush()
4262 
 
594 rajveer 4263 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4264 
    args = getDefaultAddressId_args()
4265 
    args.read(iprot)
4266 
    iprot.readMessageEnd()
4267 
    result = getDefaultAddressId_result()
4268 
    try:
4269 
      result.success = self._handler.getDefaultAddressId(args.userId)
4270 
    except UserContextException, ucx:
4271 
      result.ucx = ucx
4272 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4273 
    result.write(oprot)
4274 
    oprot.writeMessageEnd()
4275 
    oprot.trans.flush()
4276 
 
785 rajveer 4277 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4278 
    args = getDefaultPincode_args()
4279 
    args.read(iprot)
4280 
    iprot.readMessageEnd()
4281 
    result = getDefaultPincode_result()
4282 
    try:
4283 
      result.success = self._handler.getDefaultPincode(args.userId)
4284 
    except UserContextException, ucx:
4285 
      result.ucx = ucx
4286 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4287 
    result.write(oprot)
4288 
    oprot.writeMessageEnd()
4289 
    oprot.trans.flush()
4290 
 
1274 varun.gupt 4291 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4292 
    args = saveUserCommunication_args()
4293 
    args.read(iprot)
4294 
    iprot.readMessageEnd()
4295 
    result = saveUserCommunication_result()
4296 
    try:
4297 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4298 
    except UserCommunicationException, ucx:
4299 
      result.ucx = ucx
4300 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4301 
    result.write(oprot)
4302 
    oprot.writeMessageEnd()
4303 
    oprot.trans.flush()
4304 
 
1590 varun.gupt 4305 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4306 
    args = getUserCommunicationById_args()
4307 
    args.read(iprot)
4308 
    iprot.readMessageEnd()
4309 
    result = getUserCommunicationById_result()
4310 
    try:
4311 
      result.success = self._handler.getUserCommunicationById(args.id)
4312 
    except UserCommunicationException, ucx:
4313 
      result.ucx = ucx
4314 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4315 
    result.write(oprot)
4316 
    oprot.writeMessageEnd()
4317 
    oprot.trans.flush()
4318 
 
4319 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4320 
    args = getUserCommunicationByUser_args()
4321 
    args.read(iprot)
4322 
    iprot.readMessageEnd()
4323 
    result = getUserCommunicationByUser_result()
4324 
    try:
4325 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4326 
    except UserCommunicationException, ucx:
4327 
      result.ucx = ucx
4328 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4329 
    result.write(oprot)
4330 
    oprot.writeMessageEnd()
4331 
    oprot.trans.flush()
4332 
 
4333 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4334 
    args = getAllUserCommunications_args()
4335 
    args.read(iprot)
4336 
    iprot.readMessageEnd()
4337 
    result = getAllUserCommunications_result()
4338 
    try:
4339 
      result.success = self._handler.getAllUserCommunications()
4340 
    except UserCommunicationException, ucx:
4341 
      result.ucx = ucx
4342 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4343 
    result.write(oprot)
4344 
    oprot.writeMessageEnd()
4345 
    oprot.trans.flush()
4346 
 
5407 amar.kumar 4347 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4348 
    args = removeUserCommunication_args()
4349 
    args.read(iprot)
4350 
    iprot.readMessageEnd()
4351 
    result = removeUserCommunication_result()
4352 
    try:
4353 
      self._handler.removeUserCommunication(args.id)
4354 
    except UserCommunicationException, ucx:
4355 
      result.ucx = ucx
4356 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4357 
    result.write(oprot)
4358 
    oprot.writeMessageEnd()
4359 
    oprot.trans.flush()
4360 
 
1845 vikas 4361 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4362 
    args = createMasterAffiliate_args()
4363 
    args.read(iprot)
4364 
    iprot.readMessageEnd()
4365 
    result = createMasterAffiliate_result()
4366 
    try:
1859 vikas 4367 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4368 
    except UserAffiliateException, utx:
1845 vikas 4369 
      result.utx = utx
4370 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4371 
    result.write(oprot)
4372 
    oprot.writeMessageEnd()
4373 
    oprot.trans.flush()
4374 
 
1899 vikas 4375 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4376 
    args = getAllMasterAffiliates_args()
4377 
    args.read(iprot)
4378 
    iprot.readMessageEnd()
4379 
    result = getAllMasterAffiliates_result()
4380 
    try:
4381 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4382 
    except UserAffiliateException, utx:
1899 vikas 4383 
      result.utx = utx
4384 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4385 
    result.write(oprot)
4386 
    oprot.writeMessageEnd()
4387 
    oprot.trans.flush()
4388 
 
1845 vikas 4389 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4390 
    args = getMasterAffiliateById_args()
4391 
    args.read(iprot)
4392 
    iprot.readMessageEnd()
4393 
    result = getMasterAffiliateById_result()
4394 
    try:
4395 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4396 
    except UserAffiliateException, utx:
1845 vikas 4397 
      result.utx = utx
4398 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4399 
    result.write(oprot)
4400 
    oprot.writeMessageEnd()
4401 
    oprot.trans.flush()
4402 
 
4403 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4404 
    args = getMasterAffiliateByName_args()
4405 
    args.read(iprot)
4406 
    iprot.readMessageEnd()
4407 
    result = getMasterAffiliateByName_result()
4408 
    try:
4409 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4410 
    except UserAffiliateException, utx:
1845 vikas 4411 
      result.utx = utx
4412 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4413 
    result.write(oprot)
4414 
    oprot.writeMessageEnd()
4415 
    oprot.trans.flush()
4416 
 
4417 
  def process_createAffiliate(self, seqid, iprot, oprot):
4418 
    args = createAffiliate_args()
4419 
    args.read(iprot)
4420 
    iprot.readMessageEnd()
4421 
    result = createAffiliate_result()
4422 
    try:
1859 vikas 4423 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4424 
    except UserAffiliateException, utx:
1845 vikas 4425 
      result.utx = utx
4426 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4427 
    result.write(oprot)
4428 
    oprot.writeMessageEnd()
4429 
    oprot.trans.flush()
4430 
 
4431 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4432 
    args = getAffiliateById_args()
4433 
    args.read(iprot)
4434 
    iprot.readMessageEnd()
4435 
    result = getAffiliateById_result()
4436 
    try:
4437 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4438 
    except UserAffiliateException, utx:
1845 vikas 4439 
      result.utx = utx
4440 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4441 
    result.write(oprot)
4442 
    oprot.writeMessageEnd()
4443 
    oprot.trans.flush()
4444 
 
4445 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4446 
    args = getAffiliateByName_args()
4447 
    args.read(iprot)
4448 
    iprot.readMessageEnd()
4449 
    result = getAffiliateByName_result()
4450 
    try:
4451 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4452 
    except UserAffiliateException, utx:
1845 vikas 4453 
      result.utx = utx
4454 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4455 
    result.write(oprot)
4456 
    oprot.writeMessageEnd()
4457 
    oprot.trans.flush()
4458 
 
4459 
  def process_getTrackerById(self, seqid, iprot, oprot):
4460 
    args = getTrackerById_args()
4461 
    args.read(iprot)
4462 
    iprot.readMessageEnd()
4463 
    result = getTrackerById_result()
4464 
    try:
1996 vikas 4465 
      result.success = self._handler.getTrackerById(args.id)
4466 
    except UserAffiliateException, utx:
1845 vikas 4467 
      result.utx = utx
4468 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4469 
    result.write(oprot)
4470 
    oprot.writeMessageEnd()
4471 
    oprot.trans.flush()
4472 
 
1996 vikas 4473 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4474 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4475 
    args.read(iprot)
4476 
    iprot.readMessageEnd()
1996 vikas 4477 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4478 
    try:
1996 vikas 4479 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4480 
    except UserAffiliateException, utx:
1845 vikas 4481 
      result.utx = utx
1996 vikas 4482 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4483 
    result.write(oprot)
4484 
    oprot.writeMessageEnd()
4485 
    oprot.trans.flush()
4486 
 
4487 
  def process_addTrackLog(self, seqid, iprot, oprot):
4488 
    args = addTrackLog_args()
4489 
    args.read(iprot)
4490 
    iprot.readMessageEnd()
4491 
    result = addTrackLog_result()
4492 
    try:
1996 vikas 4493 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4494 
    except UserAffiliateException, utx:
1845 vikas 4495 
      result.utx = utx
4496 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4497 
    result.write(oprot)
4498 
    oprot.writeMessageEnd()
4499 
    oprot.trans.flush()
4500 
 
4501 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4502 
    args = getTrackLogById_args()
4503 
    args.read(iprot)
4504 
    iprot.readMessageEnd()
4505 
    result = getTrackLogById_result()
4506 
    try:
4507 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4508 
    except UserAffiliateException, utx:
1845 vikas 4509 
      result.utx = utx
4510 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4511 
    result.write(oprot)
4512 
    oprot.writeMessageEnd()
4513 
    oprot.trans.flush()
4514 
 
1996 vikas 4515 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4516 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4517 
    args.read(iprot)
4518 
    iprot.readMessageEnd()
1996 vikas 4519 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4520 
    try:
3293 vikas 4521 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4522 
    except UserAffiliateException, utx:
1845 vikas 4523 
      result.utx = utx
1996 vikas 4524 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4525 
    result.write(oprot)
4526 
    oprot.writeMessageEnd()
4527 
    oprot.trans.flush()
4528 
 
4529 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4530 
    args = getTrackLogsByUser_args()
4531 
    args.read(iprot)
4532 
    iprot.readMessageEnd()
4533 
    result = getTrackLogsByUser_result()
4534 
    try:
4535 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4536 
    except UserAffiliateException, utx:
1845 vikas 4537 
      result.utx = utx
4538 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4539 
    result.write(oprot)
4540 
    oprot.writeMessageEnd()
4541 
    oprot.trans.flush()
4542 
 
4543 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4544 
    args = getTrackLogs_args()
4545 
    args.read(iprot)
4546 
    iprot.readMessageEnd()
4547 
    result = getTrackLogs_result()
4548 
    try:
1996 vikas 4549 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4550 
    except UserAffiliateException, utx:
1845 vikas 4551 
      result.utx = utx
4552 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4553 
    result.write(oprot)
4554 
    oprot.writeMessageEnd()
4555 
    oprot.trans.flush()
4556 
 
559 chandransh 4557 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4558 
    args = getCurrentCart_args()
94 ashish 4559 
    args.read(iprot)
4560 
    iprot.readMessageEnd()
559 chandransh 4561 
    result = getCurrentCart_result()
94 ashish 4562 
    try:
559 chandransh 4563 
      result.success = self._handler.getCurrentCart(args.userId)
4564 
    except ShoppingCartException, scx:
4565 
      result.scx = scx
4566 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4567 
    result.write(oprot)
4568 
    oprot.writeMessageEnd()
4569 
    oprot.trans.flush()
4570 
 
559 chandransh 4571 
  def process_getCart(self, seqid, iprot, oprot):
4572 
    args = getCart_args()
94 ashish 4573 
    args.read(iprot)
4574 
    iprot.readMessageEnd()
559 chandransh 4575 
    result = getCart_result()
94 ashish 4576 
    try:
559 chandransh 4577 
      result.success = self._handler.getCart(args.cartId)
4578 
    except ShoppingCartException, scx:
4579 
      result.scx = scx
4580 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
4584 
 
559 chandransh 4585 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4586 
    args = getCartsByTime_args()
94 ashish 4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
559 chandransh 4589 
    result = getCartsByTime_result()
94 ashish 4590 
    try:
559 chandransh 4591 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4592 
    except ShoppingCartException, scx:
4593 
      result.scx = scx
4594 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4595 
    result.write(oprot)
4596 
    oprot.writeMessageEnd()
4597 
    oprot.trans.flush()
4598 
 
559 chandransh 4599 
  def process_addItemToCart(self, seqid, iprot, oprot):
4600 
    args = addItemToCart_args()
130 ashish 4601 
    args.read(iprot)
4602 
    iprot.readMessageEnd()
559 chandransh 4603 
    result = addItemToCart_result()
130 ashish 4604 
    try:
3557 rajveer 4605 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4606 
    except ShoppingCartException, scx:
4607 
      result.scx = scx
4608 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
4612 
 
559 chandransh 4613 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4614 
    args = deleteItemFromCart_args()
4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
4617 
    result = deleteItemFromCart_result()
4618 
    try:
4619 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4620 
    except ShoppingCartException, scx:
4621 
      result.scx = scx
4622 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4623 
    result.write(oprot)
4624 
    oprot.writeMessageEnd()
4625 
    oprot.trans.flush()
130 ashish 4626 
 
559 chandransh 4627 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4628 
    args = addAddressToCart_args()
4629 
    args.read(iprot)
4630 
    iprot.readMessageEnd()
4631 
    result = addAddressToCart_result()
575 chandransh 4632 
    try:
4633 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4634 
    except ShoppingCartException, scx:
4635 
      result.scx = scx
559 chandransh 4636 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4637 
    result.write(oprot)
4638 
    oprot.writeMessageEnd()
4639 
    oprot.trans.flush()
4640 
 
5553 rajveer 4641 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4642 
    args = addStoreToCart_args()
4643 
    args.read(iprot)
4644 
    iprot.readMessageEnd()
4645 
    result = addStoreToCart_result()
4646 
    try:
4647 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4648 
    except ShoppingCartException, scx:
4649 
      result.scx = scx
4650 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
1976 varun.gupt 4655 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4656 
    args = applyCouponToCart_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = applyCouponToCart_result()
4660 
    try:
6922 anupam.sin 4661 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4662 
    except ShoppingCartException, scx:
4663 
      result.scx = scx
4664 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4665 
    result.write(oprot)
4666 
    oprot.writeMessageEnd()
4667 
    oprot.trans.flush()
4668 
 
4669 
  def process_removeCoupon(self, seqid, iprot, oprot):
4670 
    args = removeCoupon_args()
4671 
    args.read(iprot)
4672 
    iprot.readMessageEnd()
4673 
    result = removeCoupon_result()
4674 
    try:
4675 
      self._handler.removeCoupon(args.cartId)
4676 
    except ShoppingCartException, scx:
4677 
      result.scx = scx
4678 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4679 
    result.write(oprot)
4680 
    oprot.writeMessageEnd()
4681 
    oprot.trans.flush()
4682 
 
3554 varun.gupt 4683 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4684 
    args = deleteDiscountsFromCart_args()
4685 
    args.read(iprot)
4686 
    iprot.readMessageEnd()
4687 
    result = deleteDiscountsFromCart_result()
4688 
    try:
4689 
      self._handler.deleteDiscountsFromCart(args.cartId)
4690 
    except ShoppingCartException, scx:
4691 
      result.scx = scx
4692 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4693 
    result.write(oprot)
4694 
    oprot.writeMessageEnd()
4695 
    oprot.trans.flush()
4696 
 
4697 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4698 
    args = saveDiscounts_args()
4699 
    args.read(iprot)
4700 
    iprot.readMessageEnd()
4701 
    result = saveDiscounts_result()
4702 
    try:
4703 
      self._handler.saveDiscounts(args.discounts)
4704 
    except ShoppingCartException, scx:
4705 
      result.scx = scx
4706 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4707 
    result.write(oprot)
4708 
    oprot.writeMessageEnd()
4709 
    oprot.trans.flush()
4710 
 
690 chandransh 4711 
  def process_createOrders(self, seqid, iprot, oprot):
4712 
    args = createOrders_args()
559 chandransh 4713 
    args.read(iprot)
4714 
    iprot.readMessageEnd()
690 chandransh 4715 
    result = createOrders_result()
559 chandransh 4716 
    try:
11526 amit.gupta 4717 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4718 
    except ShoppingCartException, scx:
4719 
      result.scx = scx
690 chandransh 4720 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4721 
    result.write(oprot)
4722 
    oprot.writeMessageEnd()
4723 
    oprot.trans.flush()
4724 
 
4725 
  def process_validateCart(self, seqid, iprot, oprot):
4726 
    args = validateCart_args()
4727 
    args.read(iprot)
4728 
    iprot.readMessageEnd()
4729 
    result = validateCart_result()
575 chandransh 4730 
    try:
3557 rajveer 4731 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4732 
    except ShoppingCartException, scex:
4733 
      result.scex = scex
559 chandransh 4734 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4735 
    result.write(oprot)
4736 
    oprot.writeMessageEnd()
4737 
    oprot.trans.flush()
4738 
 
11980 amit.gupta 4739 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4740 
    args = validateCartWithDealerCoupon_args()
4741 
    args.read(iprot)
4742 
    iprot.readMessageEnd()
4743 
    result = validateCartWithDealerCoupon_result()
4744 
    try:
4745 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4746 
    except ShoppingCartException, scex:
4747 
      result.scex = scex
4748 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
690 chandransh 4753 
  def process_mergeCart(self, seqid, iprot, oprot):
4754 
    args = mergeCart_args()
575 chandransh 4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
690 chandransh 4757 
    result = mergeCart_result()
4758 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4759 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4763 
 
4764 
  def process_checkOut(self, seqid, iprot, oprot):
4765 
    args = checkOut_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = checkOut_result()
575 chandransh 4769 
    try:
690 chandransh 4770 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4771 
    except ShoppingCartException, scex:
4772 
      result.scex = scex
690 chandransh 4773 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
4777 
 
690 chandransh 4778 
  def process_resetCart(self, seqid, iprot, oprot):
4779 
    args = resetCart_args()
559 chandransh 4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
690 chandransh 4782 
    result = resetCart_result()
4783 
    try:
4784 
      result.success = self._handler.resetCart(args.cartId, args.items)
4785 
    except ShoppingCartException, scex:
4786 
      result.scex = scex
4787 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
2981 rajveer 4792 
  def process_getUserCount(self, seqid, iprot, oprot):
4793 
    args = getUserCount_args()
559 chandransh 4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
2981 rajveer 4796 
    result = getUserCount_result()
4797 
    result.success = self._handler.getUserCount(args.userType)
4798 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
2981 rajveer 4803 
  def process_getAllUsers(self, seqid, iprot, oprot):
4804 
    args = getAllUsers_args()
559 chandransh 4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
2981 rajveer 4807 
    result = getAllUsers_result()
4808 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4809 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4810 
    result.write(oprot)
4811 
    oprot.writeMessageEnd()
4812 
    oprot.trans.flush()
4813 
 
2981 rajveer 4814 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4815 
    args = getMyResearchItems_args()
559 chandransh 4816 
    args.read(iprot)
4817 
    iprot.readMessageEnd()
2981 rajveer 4818 
    result = getMyResearchItems_result()
559 chandransh 4819 
    try:
2981 rajveer 4820 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4821 
    except WidgetException, scx:
4822 
      result.scx = scx
2981 rajveer 4823 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4824 
    result.write(oprot)
4825 
    oprot.writeMessageEnd()
4826 
    oprot.trans.flush()
4827 
 
2981 rajveer 4828 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4829 
    args = updateMyResearch_args()
772 rajveer 4830 
    args.read(iprot)
4831 
    iprot.readMessageEnd()
2981 rajveer 4832 
    result = updateMyResearch_result()
4833 
    try:
4834 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4835 
    except WidgetException, scx:
4836 
      result.scx = scx
4837 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4838 
    result.write(oprot)
4839 
    oprot.writeMessageEnd()
4840 
    oprot.trans.flush()
559 chandransh 4841 
 
2981 rajveer 4842 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4843 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4844 
    args.read(iprot)
4845 
    iprot.readMessageEnd()
2981 rajveer 4846 
    result = deleteItemFromMyResearch_result()
4847 
    try:
4848 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4849 
    except WidgetException, scx:
4850 
      result.scx = scx
4851 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4852 
    result.write(oprot)
4853 
    oprot.writeMessageEnd()
4854 
    oprot.trans.flush()
772 rajveer 4855 
 
2981 rajveer 4856 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4857 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4858 
    args.read(iprot)
4859 
    iprot.readMessageEnd()
2981 rajveer 4860 
    result = getBrowseHistoryItems_result()
4861 
    try:
4862 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4863 
    except WidgetException, scx:
4864 
      result.scx = scx
4865 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4866 
    result.write(oprot)
4867 
    oprot.writeMessageEnd()
4868 
    oprot.trans.flush()
1596 ankur.sing 4869 
 
2981 rajveer 4870 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4871 
    args = updateBrowseHistory_args()
2642 varun.gupt 4872 
    args.read(iprot)
4873 
    iprot.readMessageEnd()
2981 rajveer 4874 
    result = updateBrowseHistory_result()
4875 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4876 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4877 
    result.write(oprot)
4878 
    oprot.writeMessageEnd()
4879 
    oprot.trans.flush()
1673 ankur.sing 4880 
 
3385 varun.gupt 4881 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4882 
    args = getCartsWithCouponCount_args()
4883 
    args.read(iprot)
4884 
    iprot.readMessageEnd()
4885 
    result = getCartsWithCouponCount_result()
4886 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4887 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4888 
    result.write(oprot)
4889 
    oprot.writeMessageEnd()
4890 
    oprot.trans.flush()
2642 varun.gupt 4891 
 
3499 mandeep.dh 4892 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4893 
    args = increaseTrustLevel_args()
4894 
    args.read(iprot)
4895 
    iprot.readMessageEnd()
4896 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4897 
    return
3385 varun.gupt 4898 
 
5407 amar.kumar 4899 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4900 
    args = getTrustLevel_args()
4901 
    args.read(iprot)
4902 
    iprot.readMessageEnd()
4903 
    result = getTrustLevel_result()
4904 
    result.success = self._handler.getTrustLevel(args.userId)
4905 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
4668 varun.gupt 4910 
  def process_showCODOption(self, seqid, iprot, oprot):
4911 
    args = showCODOption_args()
4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
4914 
    result = showCODOption_result()
4915 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4916 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
3499 mandeep.dh 4920 
 
5623 anupam.sin 4921 
  def process_getUserEmails(self, seqid, iprot, oprot):
4922 
    args = getUserEmails_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = getUserEmails_result()
4926 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4927 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
4668 varun.gupt 4931 
 
6903 anupam.sin 4932 
  def process_insureItem(self, seqid, iprot, oprot):
4933 
    args = insureItem_args()
4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
4936 
    result = insureItem_result()
9299 kshitij.so 4937 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4938 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
4942 
 
4943 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4944 
    args = cancelInsurance_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = cancelInsurance_result()
4948 
    result.success = self._handler.cancelInsurance(args.cartId)
4949 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
4953 
 
4954 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4955 
    args = storeInsuranceSpecificDetails_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = storeInsuranceSpecificDetails_result()
4959 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4960 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
4964 
 
4965 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4966 
    args = isInsuranceDetailPresent_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = isInsuranceDetailPresent_result()
4970 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4971 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4975 
 
9791 rajveer 4976 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4977 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
9791 rajveer 4980 
    result = getProductsAddedToCart_result()
4981 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4982 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
5623 anupam.sin 4986 
 
11592 amit.gupta 4987 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4988 
    args = validateCartPlus_args()
4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
4991 
    result = validateCartPlus_result()
4992 
    try:
11980 amit.gupta 4993 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4994 
    except ShoppingCartException, scex:
4995 
      result.scex = scex
4996 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4997 
    result.write(oprot)
4998 
    oprot.writeMessageEnd()
4999 
    oprot.trans.flush()
6821 amar.kumar 5000 
 
11679 vikram.rag 5001 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
5002 
    args = isPrivateDealUser_args()
5003 
    args.read(iprot)
5004 
    iprot.readMessageEnd()
5005 
    result = isPrivateDealUser_result()
5006 
    result.success = self._handler.isPrivateDealUser(args.userId)
5007 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
5008 
    result.write(oprot)
5009 
    oprot.writeMessageEnd()
5010 
    oprot.trans.flush()
11592 amit.gupta 5011 
 
11890 kshitij.so 5012 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
5013 
    args = addPrivateDealUser_args()
5014 
    args.read(iprot)
5015 
    iprot.readMessageEnd()
5016 
    result = addPrivateDealUser_result()
5017 
    result.success = self._handler.addPrivateDealUser(args.userId)
5018 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
5019 
    result.write(oprot)
5020 
    oprot.writeMessageEnd()
5021 
    oprot.trans.flush()
11679 vikram.rag 5022 
 
11890 kshitij.so 5023 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
5024 
    args = changePrivateDealUserStatus_args()
5025 
    args.read(iprot)
5026 
    iprot.readMessageEnd()
5027 
    result = changePrivateDealUserStatus_result()
5028 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
5029 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
5030 
    result.write(oprot)
5031 
    oprot.writeMessageEnd()
5032 
    oprot.trans.flush()
5033 
 
5034 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
5035 
    args = getPrivateDealUser_args()
5036 
    args.read(iprot)
5037 
    iprot.readMessageEnd()
5038 
    result = getPrivateDealUser_result()
5039 
    result.success = self._handler.getPrivateDealUser(args.userId)
5040 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5041 
    result.write(oprot)
5042 
    oprot.writeMessageEnd()
5043 
    oprot.trans.flush()
5044 
 
12696 amit.gupta 5045 
  def process_registerCounter(self, seqid, iprot, oprot):
5046 
    args = registerCounter_args()
5047 
    args.read(iprot)
5048 
    iprot.readMessageEnd()
5049 
    result = registerCounter_result()
5050 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5051 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5052 
    result.write(oprot)
5053 
    oprot.writeMessageEnd()
5054 
    oprot.trans.flush()
11890 kshitij.so 5055 
 
12722 amit.gupta 5056 
  def process_searchCounter(self, seqid, iprot, oprot):
5057 
    args = searchCounter_args()
5058 
    args.read(iprot)
5059 
    iprot.readMessageEnd()
5060 
    result = searchCounter_result()
5061 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5062 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5063 
    result.write(oprot)
5064 
    oprot.writeMessageEnd()
5065 
    oprot.trans.flush()
12696 amit.gupta 5066 
 
18977 amit.gupta 5067 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5068 
    args = getCounterByUserId_args()
5069 
    args.read(iprot)
5070 
    iprot.readMessageEnd()
5071 
    result = getCounterByUserId_result()
5072 
    result.success = self._handler.getCounterByUserId(args.userId)
5073 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5074 
    result.write(oprot)
5075 
    oprot.writeMessageEnd()
5076 
    oprot.trans.flush()
5077 
 
12722 amit.gupta 5078 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5079 
    args = getAllUsersByCounter_args()
5080 
    args.read(iprot)
5081 
    iprot.readMessageEnd()
5082 
    result = getAllUsersByCounter_result()
5083 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5084 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
5088 
 
15251 manish.sha 5089 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5090 
    args = getActiveAccessTokenForUser_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = getActiveAccessTokenForUser_result()
5094 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5095 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5096 
    result.write(oprot)
5097 
    oprot.writeMessageEnd()
5098 
    oprot.trans.flush()
12722 amit.gupta 5099 
 
15251 manish.sha 5100 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5101 
    args = validateAccessToken_args()
5102 
    args.read(iprot)
5103 
    iprot.readMessageEnd()
5104 
    result = validateAccessToken_result()
5105 
    result.success = self._handler.validateAccessToken(args.accessToken)
5106 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5107 
    result.write(oprot)
5108 
    oprot.writeMessageEnd()
5109 
    oprot.trans.flush()
5110 
 
17782 amit.gupta 5111 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5112 
    args = addItemsToCart_args()
5113 
    args.read(iprot)
5114 
    iprot.readMessageEnd()
5115 
    result = addItemsToCart_result()
5116 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5117 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
15251 manish.sha 5121 
 
17782 amit.gupta 5122 
  def process_validateCartNew(self, seqid, iprot, oprot):
5123 
    args = validateCartNew_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = validateCartNew_result()
5127 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5128 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5129 
    result.write(oprot)
5130 
    oprot.writeMessageEnd()
5131 
    oprot.trans.flush()
5132 
 
18644 manish.sha 5133 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5134 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5135 
    args.read(iprot)
5136 
    iprot.readMessageEnd()
18644 manish.sha 5137 
    result = isAddressEditableForCounter_result()
5138 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5139 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
17782 amit.gupta 5143 
 
18530 manish.sha 5144 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5145 
    args = getBillingAddressForUser_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = getBillingAddressForUser_result()
5149 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5150 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5151 
    result.write(oprot)
5152 
    oprot.writeMessageEnd()
5153 
    oprot.trans.flush()
5154 
 
18590 manish.sha 5155 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5156 
    args = isCreditorAssigned_args()
5157 
    args.read(iprot)
5158 
    iprot.readMessageEnd()
5159 
    result = isCreditorAssigned_result()
5160 
    result.success = self._handler.isCreditorAssigned(args.userId)
5161 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
18530 manish.sha 5165 
 
18735 manish.sha 5166 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5167 
    args = isTaxInvoiceEnabledUser_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = isTaxInvoiceEnabledUser_result()
5171 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5172 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5173 
    result.write(oprot)
5174 
    oprot.writeMessageEnd()
5175 
    oprot.trans.flush()
18590 manish.sha 5176 
 
19182 amit.gupta 5177 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5178 
    args = taxInvoiceAvailable_args()
5179 
    args.read(iprot)
5180 
    iprot.readMessageEnd()
5181 
    result = taxInvoiceAvailable_result()
5182 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5183 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5184 
    result.write(oprot)
5185 
    oprot.writeMessageEnd()
5186 
    oprot.trans.flush()
5187 
 
18764 kshitij.so 5188 
  def process_getCartByValue(self, seqid, iprot, oprot):
5189 
    args = getCartByValue_args()
5190 
    args.read(iprot)
5191 
    iprot.readMessageEnd()
5192 
    result = getCartByValue_result()
5193 
    result.success = self._handler.getCartByValue(args.cartIds)
5194 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5195 
    result.write(oprot)
5196 
    oprot.writeMessageEnd()
5197 
    oprot.trans.flush()
18735 manish.sha 5198 
 
19889 manas 5199 
  def process_getCounterName(self, seqid, iprot, oprot):
5200 
    args = getCounterName_args()
5201 
    args.read(iprot)
5202 
    iprot.readMessageEnd()
5203 
    result = getCounterName_result()
5204 
    result.success = self._handler.getCounterName(args.userIds)
5205 
    oprot.writeMessageBegin("getCounterName", TMessageType.REPLY, seqid)
5206 
    result.write(oprot)
5207 
    oprot.writeMessageEnd()
5208 
    oprot.trans.flush()
18764 kshitij.so 5209 
 
19889 manas 5210 
 
94 ashish 5211 
# HELPER FUNCTIONS AND STRUCTURES
5212 
 
559 chandransh 5213 
class createAnonymousUser_args:
94 ashish 5214 
  """
5215 
  Attributes:
559 chandransh 5216 
   - jsessionId
94 ashish 5217 
  """
5218 
 
5219 
  thrift_spec = (
5220 
    None, # 0
559 chandransh 5221 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5222 
  )
5223 
 
559 chandransh 5224 
  def __init__(self, jsessionId=None,):
5225 
    self.jsessionId = jsessionId
94 ashish 5226 
 
5227 
  def read(self, iprot):
5228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5230 
      return
5231 
    iprot.readStructBegin()
5232 
    while True:
5233 
      (fname, ftype, fid) = iprot.readFieldBegin()
5234 
      if ftype == TType.STOP:
5235 
        break
5236 
      if fid == 1:
559 chandransh 5237 
        if ftype == TType.STRING:
5238 
          self.jsessionId = iprot.readString();
94 ashish 5239 
        else:
5240 
          iprot.skip(ftype)
5241 
      else:
5242 
        iprot.skip(ftype)
5243 
      iprot.readFieldEnd()
5244 
    iprot.readStructEnd()
5245 
 
5246 
  def write(self, oprot):
5247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5249 
      return
559 chandransh 5250 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5251 
    if self.jsessionId is not None:
559 chandransh 5252 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5253 
      oprot.writeString(self.jsessionId)
94 ashish 5254 
      oprot.writeFieldEnd()
5255 
    oprot.writeFieldStop()
5256 
    oprot.writeStructEnd()
5257 
 
3431 rajveer 5258 
  def validate(self):
5259 
    return
5260 
 
5261 
 
94 ashish 5262 
  def __repr__(self):
5263 
    L = ['%s=%r' % (key, value)
5264 
      for key, value in self.__dict__.iteritems()]
5265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5266 
 
5267 
  def __eq__(self, other):
5268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5269 
 
5270 
  def __ne__(self, other):
5271 
    return not (self == other)
5272 
 
559 chandransh 5273 
class createAnonymousUser_result:
94 ashish 5274 
  """
5275 
  Attributes:
5276 
   - success
559 chandransh 5277 
   - ucex
94 ashish 5278 
  """
5279 
 
5280 
  thrift_spec = (
559 chandransh 5281 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5282 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5283 
  )
5284 
 
559 chandransh 5285 
  def __init__(self, success=None, ucex=None,):
94 ashish 5286 
    self.success = success
559 chandransh 5287 
    self.ucex = ucex
94 ashish 5288 
 
5289 
  def read(self, iprot):
5290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5292 
      return
5293 
    iprot.readStructBegin()
5294 
    while True:
5295 
      (fname, ftype, fid) = iprot.readFieldBegin()
5296 
      if ftype == TType.STOP:
5297 
        break
5298 
      if fid == 0:
5299 
        if ftype == TType.STRUCT:
559 chandransh 5300 
          self.success = User()
94 ashish 5301 
          self.success.read(iprot)
5302 
        else:
5303 
          iprot.skip(ftype)
5304 
      elif fid == 1:
5305 
        if ftype == TType.STRUCT:
559 chandransh 5306 
          self.ucex = UserContextException()
5307 
          self.ucex.read(iprot)
94 ashish 5308 
        else:
5309 
          iprot.skip(ftype)
5310 
      else:
5311 
        iprot.skip(ftype)
5312 
      iprot.readFieldEnd()
5313 
    iprot.readStructEnd()
5314 
 
5315 
  def write(self, oprot):
5316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5318 
      return
559 chandransh 5319 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5320 
    if self.success is not None:
94 ashish 5321 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5322 
      self.success.write(oprot)
5323 
      oprot.writeFieldEnd()
3431 rajveer 5324 
    if self.ucex is not None:
559 chandransh 5325 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5326 
      self.ucex.write(oprot)
94 ashish 5327 
      oprot.writeFieldEnd()
5328 
    oprot.writeFieldStop()
5329 
    oprot.writeStructEnd()
5330 
 
3431 rajveer 5331 
  def validate(self):
5332 
    return
5333 
 
5334 
 
94 ashish 5335 
  def __repr__(self):
5336 
    L = ['%s=%r' % (key, value)
5337 
      for key, value in self.__dict__.iteritems()]
5338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5339 
 
5340 
  def __eq__(self, other):
5341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5342 
 
5343 
  def __ne__(self, other):
5344 
    return not (self == other)
5345 
 
559 chandransh 5346 
class getUserById_args:
94 ashish 5347 
  """
5348 
  Attributes:
5349 
   - userId
5350 
  """
5351 
 
5352 
  thrift_spec = (
5353 
    None, # 0
5354 
    (1, TType.I64, 'userId', None, None, ), # 1
5355 
  )
5356 
 
559 chandransh 5357 
  def __init__(self, userId=None,):
94 ashish 5358 
    self.userId = userId
5359 
 
5360 
  def read(self, iprot):
5361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5363 
      return
5364 
    iprot.readStructBegin()
5365 
    while True:
5366 
      (fname, ftype, fid) = iprot.readFieldBegin()
5367 
      if ftype == TType.STOP:
5368 
        break
5369 
      if fid == 1:
5370 
        if ftype == TType.I64:
5371 
          self.userId = iprot.readI64();
5372 
        else:
5373 
          iprot.skip(ftype)
5374 
      else:
5375 
        iprot.skip(ftype)
5376 
      iprot.readFieldEnd()
5377 
    iprot.readStructEnd()
5378 
 
5379 
  def write(self, oprot):
5380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5382 
      return
559 chandransh 5383 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5384 
    if self.userId is not None:
94 ashish 5385 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5386 
      oprot.writeI64(self.userId)
5387 
      oprot.writeFieldEnd()
5388 
    oprot.writeFieldStop()
5389 
    oprot.writeStructEnd()
5390 
 
3431 rajveer 5391 
  def validate(self):
5392 
    return
5393 
 
5394 
 
94 ashish 5395 
  def __repr__(self):
5396 
    L = ['%s=%r' % (key, value)
5397 
      for key, value in self.__dict__.iteritems()]
5398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5399 
 
5400 
  def __eq__(self, other):
5401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5402 
 
5403 
  def __ne__(self, other):
5404 
    return not (self == other)
5405 
 
559 chandransh 5406 
class getUserById_result:
94 ashish 5407 
  """
5408 
  Attributes:
5409 
   - success
559 chandransh 5410 
   - ucex
94 ashish 5411 
  """
5412 
 
5413 
  thrift_spec = (
559 chandransh 5414 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5415 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5416 
  )
5417 
 
559 chandransh 5418 
  def __init__(self, success=None, ucex=None,):
94 ashish 5419 
    self.success = success
559 chandransh 5420 
    self.ucex = ucex
94 ashish 5421 
 
5422 
  def read(self, iprot):
5423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5425 
      return
5426 
    iprot.readStructBegin()
5427 
    while True:
5428 
      (fname, ftype, fid) = iprot.readFieldBegin()
5429 
      if ftype == TType.STOP:
5430 
        break
5431 
      if fid == 0:
5432 
        if ftype == TType.STRUCT:
559 chandransh 5433 
          self.success = User()
94 ashish 5434 
          self.success.read(iprot)
5435 
        else:
5436 
          iprot.skip(ftype)
5437 
      elif fid == 1:
5438 
        if ftype == TType.STRUCT:
559 chandransh 5439 
          self.ucex = UserContextException()
5440 
          self.ucex.read(iprot)
94 ashish 5441 
        else:
5442 
          iprot.skip(ftype)
5443 
      else:
5444 
        iprot.skip(ftype)
5445 
      iprot.readFieldEnd()
5446 
    iprot.readStructEnd()
5447 
 
5448 
  def write(self, oprot):
5449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5451 
      return
559 chandransh 5452 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5453 
    if self.success is not None:
94 ashish 5454 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5455 
      self.success.write(oprot)
5456 
      oprot.writeFieldEnd()
3431 rajveer 5457 
    if self.ucex is not None:
559 chandransh 5458 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5459 
      self.ucex.write(oprot)
94 ashish 5460 
      oprot.writeFieldEnd()
5461 
    oprot.writeFieldStop()
5462 
    oprot.writeStructEnd()
5463 
 
3431 rajveer 5464 
  def validate(self):
5465 
    return
5466 
 
5467 
 
94 ashish 5468 
  def __repr__(self):
5469 
    L = ['%s=%r' % (key, value)
5470 
      for key, value in self.__dict__.iteritems()]
5471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5472 
 
5473 
  def __eq__(self, other):
5474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5475 
 
5476 
  def __ne__(self, other):
5477 
    return not (self == other)
5478 
 
5326 rajveer 5479 
class getUserByCartId_args:
1491 vikas 5480 
  """
5481 
  Attributes:
5326 rajveer 5482 
   - cartId
1491 vikas 5483 
  """
5484 
 
5485 
  thrift_spec = (
5486 
    None, # 0
5326 rajveer 5487 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5488 
  )
5489 
 
5326 rajveer 5490 
  def __init__(self, cartId=None,):
5491 
    self.cartId = cartId
1491 vikas 5492 
 
5493 
  def read(self, iprot):
5494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5496 
      return
5497 
    iprot.readStructBegin()
5498 
    while True:
5499 
      (fname, ftype, fid) = iprot.readFieldBegin()
5500 
      if ftype == TType.STOP:
5501 
        break
5502 
      if fid == 1:
5326 rajveer 5503 
        if ftype == TType.I64:
5504 
          self.cartId = iprot.readI64();
1491 vikas 5505 
        else:
5506 
          iprot.skip(ftype)
5507 
      else:
5508 
        iprot.skip(ftype)
5509 
      iprot.readFieldEnd()
5510 
    iprot.readStructEnd()
5511 
 
5512 
  def write(self, oprot):
5513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5515 
      return
5326 rajveer 5516 
    oprot.writeStructBegin('getUserByCartId_args')
5517 
    if self.cartId is not None:
5518 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5519 
      oprot.writeI64(self.cartId)
1491 vikas 5520 
      oprot.writeFieldEnd()
5521 
    oprot.writeFieldStop()
5522 
    oprot.writeStructEnd()
5523 
 
3431 rajveer 5524 
  def validate(self):
5525 
    return
5526 
 
5527 
 
1491 vikas 5528 
  def __repr__(self):
5529 
    L = ['%s=%r' % (key, value)
5530 
      for key, value in self.__dict__.iteritems()]
5531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5532 
 
5533 
  def __eq__(self, other):
5534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5535 
 
5536 
  def __ne__(self, other):
5537 
    return not (self == other)
5538 
 
5326 rajveer 5539 
class getUserByCartId_result:
1491 vikas 5540 
  """
5541 
  Attributes:
5542 
   - success
5543 
   - ucex
5544 
  """
5545 
 
5546 
  thrift_spec = (
5547 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5548 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5549 
  )
5550 
 
5551 
  def __init__(self, success=None, ucex=None,):
5552 
    self.success = success
5553 
    self.ucex = ucex
5554 
 
5555 
  def read(self, iprot):
5556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5558 
      return
5559 
    iprot.readStructBegin()
5560 
    while True:
5561 
      (fname, ftype, fid) = iprot.readFieldBegin()
5562 
      if ftype == TType.STOP:
5563 
        break
5564 
      if fid == 0:
5565 
        if ftype == TType.STRUCT:
5566 
          self.success = User()
5567 
          self.success.read(iprot)
5568 
        else:
5569 
          iprot.skip(ftype)
5570 
      elif fid == 1:
5571 
        if ftype == TType.STRUCT:
5572 
          self.ucex = UserContextException()
5573 
          self.ucex.read(iprot)
5574 
        else:
5575 
          iprot.skip(ftype)
5576 
      else:
5577 
        iprot.skip(ftype)
5578 
      iprot.readFieldEnd()
5579 
    iprot.readStructEnd()
5580 
 
5581 
  def write(self, oprot):
5582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5584 
      return
5326 rajveer 5585 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5586 
    if self.success is not None:
1491 vikas 5587 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5588 
      self.success.write(oprot)
5589 
      oprot.writeFieldEnd()
3431 rajveer 5590 
    if self.ucex is not None:
1491 vikas 5591 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5592 
      self.ucex.write(oprot)
5593 
      oprot.writeFieldEnd()
5594 
    oprot.writeFieldStop()
5595 
    oprot.writeStructEnd()
5596 
 
3431 rajveer 5597 
  def validate(self):
5598 
    return
5599 
 
5600 
 
1491 vikas 5601 
  def __repr__(self):
5602 
    L = ['%s=%r' % (key, value)
5603 
      for key, value in self.__dict__.iteritems()]
5604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5605 
 
5606 
  def __eq__(self, other):
5607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5608 
 
5609 
  def __ne__(self, other):
5610 
    return not (self == other)
5611 
 
5326 rajveer 5612 
class getUserByEmail_args:
3032 mandeep.dh 5613 
  """
5614 
  Attributes:
5326 rajveer 5615 
   - email
3032 mandeep.dh 5616 
  """
5617 
 
5618 
  thrift_spec = (
5619 
    None, # 0
5326 rajveer 5620 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5621 
  )
5622 
 
5326 rajveer 5623 
  def __init__(self, email=None,):
5624 
    self.email = email
3032 mandeep.dh 5625 
 
5626 
  def read(self, iprot):
5627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5629 
      return
5630 
    iprot.readStructBegin()
5631 
    while True:
5632 
      (fname, ftype, fid) = iprot.readFieldBegin()
5633 
      if ftype == TType.STOP:
5634 
        break
5635 
      if fid == 1:
5326 rajveer 5636 
        if ftype == TType.STRING:
5637 
          self.email = iprot.readString();
3032 mandeep.dh 5638 
        else:
5639 
          iprot.skip(ftype)
5640 
      else:
5641 
        iprot.skip(ftype)
5642 
      iprot.readFieldEnd()
5643 
    iprot.readStructEnd()
5644 
 
5645 
  def write(self, oprot):
5646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5648 
      return
5326 rajveer 5649 
    oprot.writeStructBegin('getUserByEmail_args')
5650 
    if self.email is not None:
5651 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5652 
      oprot.writeString(self.email)
3032 mandeep.dh 5653 
      oprot.writeFieldEnd()
5654 
    oprot.writeFieldStop()
5655 
    oprot.writeStructEnd()
5656 
 
3431 rajveer 5657 
  def validate(self):
5658 
    return
5659 
 
5660 
 
3032 mandeep.dh 5661 
  def __repr__(self):
5662 
    L = ['%s=%r' % (key, value)
5663 
      for key, value in self.__dict__.iteritems()]
5664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5665 
 
5666 
  def __eq__(self, other):
5667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5668 
 
5669 
  def __ne__(self, other):
5670 
    return not (self == other)
5671 
 
5326 rajveer 5672 
class getUserByEmail_result:
3032 mandeep.dh 5673 
  """
5674 
  Attributes:
5675 
   - success
5676 
   - ucex
5677 
  """
5678 
 
5679 
  thrift_spec = (
5680 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5681 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5682 
  )
5683 
 
5684 
  def __init__(self, success=None, ucex=None,):
5685 
    self.success = success
5686 
    self.ucex = ucex
5687 
 
5688 
  def read(self, iprot):
5689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5691 
      return
5692 
    iprot.readStructBegin()
5693 
    while True:
5694 
      (fname, ftype, fid) = iprot.readFieldBegin()
5695 
      if ftype == TType.STOP:
5696 
        break
5697 
      if fid == 0:
5698 
        if ftype == TType.STRUCT:
5699 
          self.success = User()
5700 
          self.success.read(iprot)
5701 
        else:
5702 
          iprot.skip(ftype)
5703 
      elif fid == 1:
5704 
        if ftype == TType.STRUCT:
5705 
          self.ucex = UserContextException()
5706 
          self.ucex.read(iprot)
5707 
        else:
5708 
          iprot.skip(ftype)
5709 
      else:
5710 
        iprot.skip(ftype)
5711 
      iprot.readFieldEnd()
5712 
    iprot.readStructEnd()
5713 
 
5714 
  def write(self, oprot):
5715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5717 
      return
5326 rajveer 5718 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5719 
    if self.success is not None:
3032 mandeep.dh 5720 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5721 
      self.success.write(oprot)
5722 
      oprot.writeFieldEnd()
3431 rajveer 5723 
    if self.ucex is not None:
3032 mandeep.dh 5724 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5725 
      self.ucex.write(oprot)
5726 
      oprot.writeFieldEnd()
5727 
    oprot.writeFieldStop()
5728 
    oprot.writeStructEnd()
5729 
 
3431 rajveer 5730 
  def validate(self):
5731 
    return
5732 
 
5733 
 
3032 mandeep.dh 5734 
  def __repr__(self):
5735 
    L = ['%s=%r' % (key, value)
5736 
      for key, value in self.__dict__.iteritems()]
5737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5738 
 
5739 
  def __eq__(self, other):
5740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5741 
 
5742 
  def __ne__(self, other):
5743 
    return not (self == other)
5744 
 
5326 rajveer 5745 
class getUserByMobileNumber_args:
94 ashish 5746 
  """
5747 
  Attributes:
5326 rajveer 5748 
   - mobileNumber
94 ashish 5749 
  """
5750 
 
5751 
  thrift_spec = (
5752 
    None, # 0
5326 rajveer 5753 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5754 
  )
5755 
 
5326 rajveer 5756 
  def __init__(self, mobileNumber=None,):
5757 
    self.mobileNumber = mobileNumber
94 ashish 5758 
 
5759 
  def read(self, iprot):
5760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5762 
      return
5763 
    iprot.readStructBegin()
5764 
    while True:
5765 
      (fname, ftype, fid) = iprot.readFieldBegin()
5766 
      if ftype == TType.STOP:
5767 
        break
5768 
      if fid == 1:
5326 rajveer 5769 
        if ftype == TType.I64:
5770 
          self.mobileNumber = iprot.readI64();
94 ashish 5771 
        else:
5772 
          iprot.skip(ftype)
5773 
      else:
5774 
        iprot.skip(ftype)
5775 
      iprot.readFieldEnd()
5776 
    iprot.readStructEnd()
5777 
 
5778 
  def write(self, oprot):
5779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5781 
      return
5326 rajveer 5782 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5783 
    if self.mobileNumber is not None:
5784 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5785 
      oprot.writeI64(self.mobileNumber)
94 ashish 5786 
      oprot.writeFieldEnd()
5787 
    oprot.writeFieldStop()
5788 
    oprot.writeStructEnd()
5789 
 
3431 rajveer 5790 
  def validate(self):
5791 
    return
5792 
 
5793 
 
94 ashish 5794 
  def __repr__(self):
5795 
    L = ['%s=%r' % (key, value)
5796 
      for key, value in self.__dict__.iteritems()]
5797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5798 
 
5799 
  def __eq__(self, other):
5800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5801 
 
5802 
  def __ne__(self, other):
5803 
    return not (self == other)
5804 
 
5326 rajveer 5805 
class getUserByMobileNumber_result:
94 ashish 5806 
  """
5807 
  Attributes:
5808 
   - success
559 chandransh 5809 
   - ucex
94 ashish 5810 
  """
5811 
 
5812 
  thrift_spec = (
559 chandransh 5813 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5814 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5815 
  )
5816 
 
559 chandransh 5817 
  def __init__(self, success=None, ucex=None,):
94 ashish 5818 
    self.success = success
559 chandransh 5819 
    self.ucex = ucex
94 ashish 5820 
 
5821 
  def read(self, iprot):
5822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5824 
      return
5825 
    iprot.readStructBegin()
5826 
    while True:
5827 
      (fname, ftype, fid) = iprot.readFieldBegin()
5828 
      if ftype == TType.STOP:
5829 
        break
5830 
      if fid == 0:
5831 
        if ftype == TType.STRUCT:
559 chandransh 5832 
          self.success = User()
94 ashish 5833 
          self.success.read(iprot)
5834 
        else:
5835 
          iprot.skip(ftype)
5836 
      elif fid == 1:
5837 
        if ftype == TType.STRUCT:
559 chandransh 5838 
          self.ucex = UserContextException()
5839 
          self.ucex.read(iprot)
94 ashish 5840 
        else:
5841 
          iprot.skip(ftype)
5842 
      else:
5843 
        iprot.skip(ftype)
5844 
      iprot.readFieldEnd()
5845 
    iprot.readStructEnd()
5846 
 
5847 
  def write(self, oprot):
5848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5850 
      return
5326 rajveer 5851 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5852 
    if self.success is not None:
94 ashish 5853 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5854 
      self.success.write(oprot)
5855 
      oprot.writeFieldEnd()
3431 rajveer 5856 
    if self.ucex is not None:
559 chandransh 5857 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5858 
      self.ucex.write(oprot)
94 ashish 5859 
      oprot.writeFieldEnd()
5860 
    oprot.writeFieldStop()
5861 
    oprot.writeStructEnd()
5862 
 
3431 rajveer 5863 
  def validate(self):
5864 
    return
5865 
 
5866 
 
94 ashish 5867 
  def __repr__(self):
5868 
    L = ['%s=%r' % (key, value)
5869 
      for key, value in self.__dict__.iteritems()]
5870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5871 
 
5872 
  def __eq__(self, other):
5873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5874 
 
5875 
  def __ne__(self, other):
5876 
    return not (self == other)
5877 
 
5326 rajveer 5878 
class createUser_args:
94 ashish 5879 
  """
5880 
  Attributes:
559 chandransh 5881 
   - user
94 ashish 5882 
  """
5883 
 
5884 
  thrift_spec = (
5885 
    None, # 0
559 chandransh 5886 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5887 
  )
5888 
 
559 chandransh 5889 
  def __init__(self, user=None,):
5890 
    self.user = user
94 ashish 5891 
 
5892 
  def read(self, iprot):
5893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5895 
      return
5896 
    iprot.readStructBegin()
5897 
    while True:
5898 
      (fname, ftype, fid) = iprot.readFieldBegin()
5899 
      if ftype == TType.STOP:
5900 
        break
5901 
      if fid == 1:
559 chandransh 5902 
        if ftype == TType.STRUCT:
5903 
          self.user = User()
5904 
          self.user.read(iprot)
94 ashish 5905 
        else:
5906 
          iprot.skip(ftype)
5907 
      else:
5908 
        iprot.skip(ftype)
5909 
      iprot.readFieldEnd()
5910 
    iprot.readStructEnd()
5911 
 
5912 
  def write(self, oprot):
5913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5915 
      return
5326 rajveer 5916 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5917 
    if self.user is not None:
559 chandransh 5918 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5919 
      self.user.write(oprot)
94 ashish 5920 
      oprot.writeFieldEnd()
5921 
    oprot.writeFieldStop()
5922 
    oprot.writeStructEnd()
5923 
 
3431 rajveer 5924 
  def validate(self):
5925 
    return
5926 
 
5927 
 
94 ashish 5928 
  def __repr__(self):
5929 
    L = ['%s=%r' % (key, value)
5930 
      for key, value in self.__dict__.iteritems()]
5931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5932 
 
5933 
  def __eq__(self, other):
5934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5935 
 
5936 
  def __ne__(self, other):
5937 
    return not (self == other)
5938 
 
5326 rajveer 5939 
class createUser_result:
94 ashish 5940 
  """
5941 
  Attributes:
5942 
   - success
559 chandransh 5943 
   - ucex
94 ashish 5944 
  """
5945 
 
5946 
  thrift_spec = (
559 chandransh 5947 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5948 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5949 
  )
5950 
 
559 chandransh 5951 
  def __init__(self, success=None, ucex=None,):
94 ashish 5952 
    self.success = success
559 chandransh 5953 
    self.ucex = ucex
94 ashish 5954 
 
5955 
  def read(self, iprot):
5956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5958 
      return
5959 
    iprot.readStructBegin()
5960 
    while True:
5961 
      (fname, ftype, fid) = iprot.readFieldBegin()
5962 
      if ftype == TType.STOP:
5963 
        break
5964 
      if fid == 0:
5965 
        if ftype == TType.STRUCT:
559 chandransh 5966 
          self.success = User()
94 ashish 5967 
          self.success.read(iprot)
5968 
        else:
5969 
          iprot.skip(ftype)
5970 
      elif fid == 1:
5971 
        if ftype == TType.STRUCT:
559 chandransh 5972 
          self.ucex = UserContextException()
5973 
          self.ucex.read(iprot)
94 ashish 5974 
        else:
5975 
          iprot.skip(ftype)
5976 
      else:
5977 
        iprot.skip(ftype)
5978 
      iprot.readFieldEnd()
5979 
    iprot.readStructEnd()
5980 
 
5981 
  def write(self, oprot):
5982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5984 
      return
5326 rajveer 5985 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5986 
    if self.success is not None:
94 ashish 5987 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5988 
      self.success.write(oprot)
5989 
      oprot.writeFieldEnd()
3431 rajveer 5990 
    if self.ucex is not None:
559 chandransh 5991 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5992 
      self.ucex.write(oprot)
94 ashish 5993 
      oprot.writeFieldEnd()
5994 
    oprot.writeFieldStop()
5995 
    oprot.writeStructEnd()
5996 
 
3431 rajveer 5997 
  def validate(self):
5998 
    return
5999 
 
6000 
 
94 ashish 6001 
  def __repr__(self):
6002 
    L = ['%s=%r' % (key, value)
6003 
      for key, value in self.__dict__.iteritems()]
6004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6005 
 
6006 
  def __eq__(self, other):
6007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6008 
 
6009 
  def __ne__(self, other):
6010 
    return not (self == other)
6011 
 
5326 rajveer 6012 
class updateUser_args:
94 ashish 6013 
  """
6014 
  Attributes:
5326 rajveer 6015 
   - user
94 ashish 6016 
  """
6017 
 
6018 
  thrift_spec = (
6019 
    None, # 0
5326 rajveer 6020 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6021 
  )
6022 
 
5326 rajveer 6023 
  def __init__(self, user=None,):
6024 
    self.user = user
94 ashish 6025 
 
6026 
  def read(self, iprot):
6027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6029 
      return
6030 
    iprot.readStructBegin()
6031 
    while True:
6032 
      (fname, ftype, fid) = iprot.readFieldBegin()
6033 
      if ftype == TType.STOP:
6034 
        break
6035 
      if fid == 1:
5326 rajveer 6036 
        if ftype == TType.STRUCT:
6037 
          self.user = User()
6038 
          self.user.read(iprot)
94 ashish 6039 
        else:
6040 
          iprot.skip(ftype)
6041 
      else:
6042 
        iprot.skip(ftype)
6043 
      iprot.readFieldEnd()
6044 
    iprot.readStructEnd()
6045 
 
6046 
  def write(self, oprot):
6047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6049 
      return
5326 rajveer 6050 
    oprot.writeStructBegin('updateUser_args')
6051 
    if self.user is not None:
6052 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6053 
      self.user.write(oprot)
94 ashish 6054 
      oprot.writeFieldEnd()
6055 
    oprot.writeFieldStop()
6056 
    oprot.writeStructEnd()
6057 
 
3431 rajveer 6058 
  def validate(self):
6059 
    return
6060 
 
6061 
 
94 ashish 6062 
  def __repr__(self):
6063 
    L = ['%s=%r' % (key, value)
6064 
      for key, value in self.__dict__.iteritems()]
6065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6066 
 
6067 
  def __eq__(self, other):
6068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6069 
 
6070 
  def __ne__(self, other):
6071 
    return not (self == other)
6072 
 
5326 rajveer 6073 
class updateUser_result:
94 ashish 6074 
  """
6075 
  Attributes:
6076 
   - success
559 chandransh 6077 
   - ucex
94 ashish 6078 
  """
6079 
 
6080 
  thrift_spec = (
5326 rajveer 6081 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6082 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6083 
  )
6084 
 
559 chandransh 6085 
  def __init__(self, success=None, ucex=None,):
94 ashish 6086 
    self.success = success
559 chandransh 6087 
    self.ucex = ucex
94 ashish 6088 
 
6089 
  def read(self, iprot):
6090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6092 
      return
6093 
    iprot.readStructBegin()
6094 
    while True:
6095 
      (fname, ftype, fid) = iprot.readFieldBegin()
6096 
      if ftype == TType.STOP:
6097 
        break
6098 
      if fid == 0:
5326 rajveer 6099 
        if ftype == TType.STRUCT:
6100 
          self.success = User()
6101 
          self.success.read(iprot)
94 ashish 6102 
        else:
6103 
          iprot.skip(ftype)
6104 
      elif fid == 1:
6105 
        if ftype == TType.STRUCT:
559 chandransh 6106 
          self.ucex = UserContextException()
6107 
          self.ucex.read(iprot)
94 ashish 6108 
        else:
6109 
          iprot.skip(ftype)
6110 
      else:
6111 
        iprot.skip(ftype)
6112 
      iprot.readFieldEnd()
6113 
    iprot.readStructEnd()
6114 
 
6115 
  def write(self, oprot):
6116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6118 
      return
5326 rajveer 6119 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6120 
    if self.success is not None:
5326 rajveer 6121 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6122 
      self.success.write(oprot)
94 ashish 6123 
      oprot.writeFieldEnd()
3431 rajveer 6124 
    if self.ucex is not None:
559 chandransh 6125 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6126 
      self.ucex.write(oprot)
94 ashish 6127 
      oprot.writeFieldEnd()
6128 
    oprot.writeFieldStop()
6129 
    oprot.writeStructEnd()
6130 
 
3431 rajveer 6131 
  def validate(self):
6132 
    return
6133 
 
6134 
 
94 ashish 6135 
  def __repr__(self):
6136 
    L = ['%s=%r' % (key, value)
6137 
      for key, value in self.__dict__.iteritems()]
6138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6139 
 
6140 
  def __eq__(self, other):
6141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6142 
 
6143 
  def __ne__(self, other):
6144 
    return not (self == other)
6145 
 
559 chandransh 6146 
class authenticateUser_args:
94 ashish 6147 
  """
6148 
  Attributes:
6149 
   - email
6150 
   - password
6151 
  """
6152 
 
6153 
  thrift_spec = (
6154 
    None, # 0
6155 
    (1, TType.STRING, 'email', None, None, ), # 1
6156 
    (2, TType.STRING, 'password', None, None, ), # 2
6157 
  )
6158 
 
6159 
  def __init__(self, email=None, password=None,):
6160 
    self.email = email
6161 
    self.password = password
6162 
 
6163 
  def read(self, iprot):
6164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6166 
      return
6167 
    iprot.readStructBegin()
6168 
    while True:
6169 
      (fname, ftype, fid) = iprot.readFieldBegin()
6170 
      if ftype == TType.STOP:
6171 
        break
6172 
      if fid == 1:
6173 
        if ftype == TType.STRING:
6174 
          self.email = iprot.readString();
6175 
        else:
6176 
          iprot.skip(ftype)
6177 
      elif fid == 2:
6178 
        if ftype == TType.STRING:
6179 
          self.password = iprot.readString();
6180 
        else:
6181 
          iprot.skip(ftype)
6182 
      else:
6183 
        iprot.skip(ftype)
6184 
      iprot.readFieldEnd()
6185 
    iprot.readStructEnd()
6186 
 
6187 
  def write(self, oprot):
6188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6190 
      return
559 chandransh 6191 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6192 
    if self.email is not None:
94 ashish 6193 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6194 
      oprot.writeString(self.email)
6195 
      oprot.writeFieldEnd()
3431 rajveer 6196 
    if self.password is not None:
94 ashish 6197 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6198 
      oprot.writeString(self.password)
6199 
      oprot.writeFieldEnd()
6200 
    oprot.writeFieldStop()
6201 
    oprot.writeStructEnd()
6202 
 
3431 rajveer 6203 
  def validate(self):
6204 
    return
6205 
 
6206 
 
94 ashish 6207 
  def __repr__(self):
6208 
    L = ['%s=%r' % (key, value)
6209 
      for key, value in self.__dict__.iteritems()]
6210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6211 
 
6212 
  def __eq__(self, other):
6213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6214 
 
6215 
  def __ne__(self, other):
6216 
    return not (self == other)
6217 
 
559 chandransh 6218 
class authenticateUser_result:
94 ashish 6219 
  """
6220 
  Attributes:
6221 
   - success
559 chandransh 6222 
   - auex
94 ashish 6223 
  """
6224 
 
6225 
  thrift_spec = (
559 chandransh 6226 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6227 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6228 
  )
6229 
 
559 chandransh 6230 
  def __init__(self, success=None, auex=None,):
94 ashish 6231 
    self.success = success
559 chandransh 6232 
    self.auex = auex
94 ashish 6233 
 
6234 
  def read(self, iprot):
6235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6237 
      return
6238 
    iprot.readStructBegin()
6239 
    while True:
6240 
      (fname, ftype, fid) = iprot.readFieldBegin()
6241 
      if ftype == TType.STOP:
6242 
        break
6243 
      if fid == 0:
6244 
        if ftype == TType.STRUCT:
559 chandransh 6245 
          self.success = User()
94 ashish 6246 
          self.success.read(iprot)
6247 
        else:
6248 
          iprot.skip(ftype)
6249 
      elif fid == 1:
6250 
        if ftype == TType.STRUCT:
559 chandransh 6251 
          self.auex = AuthenticationException()
6252 
          self.auex.read(iprot)
94 ashish 6253 
        else:
6254 
          iprot.skip(ftype)
6255 
      else:
6256 
        iprot.skip(ftype)
6257 
      iprot.readFieldEnd()
6258 
    iprot.readStructEnd()
6259 
 
6260 
  def write(self, oprot):
6261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6263 
      return
559 chandransh 6264 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6265 
    if self.success is not None:
94 ashish 6266 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6267 
      self.success.write(oprot)
6268 
      oprot.writeFieldEnd()
3431 rajveer 6269 
    if self.auex is not None:
559 chandransh 6270 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6271 
      self.auex.write(oprot)
94 ashish 6272 
      oprot.writeFieldEnd()
6273 
    oprot.writeFieldStop()
6274 
    oprot.writeStructEnd()
6275 
 
3431 rajveer 6276 
  def validate(self):
6277 
    return
6278 
 
6279 
 
94 ashish 6280 
  def __repr__(self):
6281 
    L = ['%s=%r' % (key, value)
6282 
      for key, value in self.__dict__.iteritems()]
6283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6284 
 
6285 
  def __eq__(self, other):
6286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6287 
 
6288 
  def __ne__(self, other):
6289 
    return not (self == other)
6290 
 
559 chandransh 6291 
class userExists_args:
122 ashish 6292 
  """
6293 
  Attributes:
559 chandransh 6294 
   - email
122 ashish 6295 
  """
6296 
 
6297 
  thrift_spec = (
6298 
    None, # 0
559 chandransh 6299 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6300 
  )
6301 
 
559 chandransh 6302 
  def __init__(self, email=None,):
6303 
    self.email = email
122 ashish 6304 
 
6305 
  def read(self, iprot):
6306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6308 
      return
6309 
    iprot.readStructBegin()
6310 
    while True:
6311 
      (fname, ftype, fid) = iprot.readFieldBegin()
6312 
      if ftype == TType.STOP:
6313 
        break
6314 
      if fid == 1:
6315 
        if ftype == TType.STRING:
559 chandransh 6316 
          self.email = iprot.readString();
122 ashish 6317 
        else:
6318 
          iprot.skip(ftype)
559 chandransh 6319 
      else:
6320 
        iprot.skip(ftype)
6321 
      iprot.readFieldEnd()
6322 
    iprot.readStructEnd()
6323 
 
6324 
  def write(self, oprot):
6325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6327 
      return
6328 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6329 
    if self.email is not None:
559 chandransh 6330 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6331 
      oprot.writeString(self.email)
6332 
      oprot.writeFieldEnd()
6333 
    oprot.writeFieldStop()
6334 
    oprot.writeStructEnd()
6335 
 
3431 rajveer 6336 
  def validate(self):
6337 
    return
6338 
 
6339 
 
559 chandransh 6340 
  def __repr__(self):
6341 
    L = ['%s=%r' % (key, value)
6342 
      for key, value in self.__dict__.iteritems()]
6343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6344 
 
6345 
  def __eq__(self, other):
6346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6347 
 
6348 
  def __ne__(self, other):
6349 
    return not (self == other)
6350 
 
6351 
class userExists_result:
6352 
  """
6353 
  Attributes:
6354 
   - success
6355 
   - ucx
6356 
  """
6357 
 
6358 
  thrift_spec = (
6359 
    (0, TType.BOOL, 'success', None, None, ), # 0
6360 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6361 
  )
6362 
 
6363 
  def __init__(self, success=None, ucx=None,):
6364 
    self.success = success
6365 
    self.ucx = ucx
6366 
 
6367 
  def read(self, iprot):
6368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6370 
      return
6371 
    iprot.readStructBegin()
6372 
    while True:
6373 
      (fname, ftype, fid) = iprot.readFieldBegin()
6374 
      if ftype == TType.STOP:
6375 
        break
6376 
      if fid == 0:
6377 
        if ftype == TType.BOOL:
6378 
          self.success = iprot.readBool();
6379 
        else:
6380 
          iprot.skip(ftype)
6381 
      elif fid == 1:
6382 
        if ftype == TType.STRUCT:
6383 
          self.ucx = UserContextException()
6384 
          self.ucx.read(iprot)
6385 
        else:
6386 
          iprot.skip(ftype)
6387 
      else:
6388 
        iprot.skip(ftype)
6389 
      iprot.readFieldEnd()
6390 
    iprot.readStructEnd()
6391 
 
6392 
  def write(self, oprot):
6393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6395 
      return
6396 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6397 
    if self.success is not None:
559 chandransh 6398 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6399 
      oprot.writeBool(self.success)
6400 
      oprot.writeFieldEnd()
3431 rajveer 6401 
    if self.ucx is not None:
559 chandransh 6402 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6403 
      self.ucx.write(oprot)
6404 
      oprot.writeFieldEnd()
6405 
    oprot.writeFieldStop()
6406 
    oprot.writeStructEnd()
6407 
 
3431 rajveer 6408 
  def validate(self):
6409 
    return
6410 
 
6411 
 
559 chandransh 6412 
  def __repr__(self):
6413 
    L = ['%s=%r' % (key, value)
6414 
      for key, value in self.__dict__.iteritems()]
6415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6416 
 
6417 
  def __eq__(self, other):
6418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6419 
 
6420 
  def __ne__(self, other):
6421 
    return not (self == other)
6422 
 
6423 
class addAddressForUser_args:
6424 
  """
6425 
  Attributes:
6426 
   - userId
6427 
   - address
6428 
   - setDefault
6429 
  """
6430 
 
6431 
  thrift_spec = (
6432 
    None, # 0
6433 
    (1, TType.I64, 'userId', None, None, ), # 1
6434 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6435 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6436 
  )
6437 
 
567 rajveer 6438 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6439 
    self.userId = userId
6440 
    self.address = address
6441 
    self.setDefault = setDefault
6442 
 
6443 
  def read(self, iprot):
6444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6446 
      return
6447 
    iprot.readStructBegin()
6448 
    while True:
6449 
      (fname, ftype, fid) = iprot.readFieldBegin()
6450 
      if ftype == TType.STOP:
6451 
        break
6452 
      if fid == 1:
6453 
        if ftype == TType.I64:
6454 
          self.userId = iprot.readI64();
6455 
        else:
6456 
          iprot.skip(ftype)
122 ashish 6457 
      elif fid == 2:
559 chandransh 6458 
        if ftype == TType.STRUCT:
6459 
          self.address = Address()
6460 
          self.address.read(iprot)
122 ashish 6461 
        else:
6462 
          iprot.skip(ftype)
6463 
      elif fid == 3:
6464 
        if ftype == TType.BOOL:
559 chandransh 6465 
          self.setDefault = iprot.readBool();
122 ashish 6466 
        else:
6467 
          iprot.skip(ftype)
6468 
      else:
6469 
        iprot.skip(ftype)
6470 
      iprot.readFieldEnd()
6471 
    iprot.readStructEnd()
6472 
 
6473 
  def write(self, oprot):
6474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6476 
      return
559 chandransh 6477 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6478 
    if self.userId is not None:
559 chandransh 6479 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6480 
      oprot.writeI64(self.userId)
122 ashish 6481 
      oprot.writeFieldEnd()
3431 rajveer 6482 
    if self.address is not None:
559 chandransh 6483 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6484 
      self.address.write(oprot)
122 ashish 6485 
      oprot.writeFieldEnd()
3431 rajveer 6486 
    if self.setDefault is not None:
567 rajveer 6487 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6488 
      oprot.writeBool(self.setDefault)
6489 
      oprot.writeFieldEnd()
122 ashish 6490 
    oprot.writeFieldStop()
6491 
    oprot.writeStructEnd()
6492 
 
3431 rajveer 6493 
  def validate(self):
6494 
    return
6495 
 
6496 
 
122 ashish 6497 
  def __repr__(self):
6498 
    L = ['%s=%r' % (key, value)
6499 
      for key, value in self.__dict__.iteritems()]
6500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6501 
 
6502 
  def __eq__(self, other):
6503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6504 
 
6505 
  def __ne__(self, other):
6506 
    return not (self == other)
6507 
 
559 chandransh 6508 
class addAddressForUser_result:
122 ashish 6509 
  """
6510 
  Attributes:
6511 
   - success
559 chandransh 6512 
   - ucx
122 ashish 6513 
  """
6514 
 
6515 
  thrift_spec = (
567 rajveer 6516 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6517 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6518 
  )
6519 
 
559 chandransh 6520 
  def __init__(self, success=None, ucx=None,):
122 ashish 6521 
    self.success = success
559 chandransh 6522 
    self.ucx = ucx
122 ashish 6523 
 
6524 
  def read(self, iprot):
6525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6527 
      return
6528 
    iprot.readStructBegin()
6529 
    while True:
6530 
      (fname, ftype, fid) = iprot.readFieldBegin()
6531 
      if ftype == TType.STOP:
6532 
        break
6533 
      if fid == 0:
567 rajveer 6534 
        if ftype == TType.I64:
6535 
          self.success = iprot.readI64();
122 ashish 6536 
        else:
6537 
          iprot.skip(ftype)
6538 
      elif fid == 1:
6539 
        if ftype == TType.STRUCT:
559 chandransh 6540 
          self.ucx = UserContextException()
6541 
          self.ucx.read(iprot)
122 ashish 6542 
        else:
6543 
          iprot.skip(ftype)
6544 
      else:
6545 
        iprot.skip(ftype)
6546 
      iprot.readFieldEnd()
6547 
    iprot.readStructEnd()
6548 
 
6549 
  def write(self, oprot):
6550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6552 
      return
559 chandransh 6553 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6554 
    if self.success is not None:
567 rajveer 6555 
      oprot.writeFieldBegin('success', TType.I64, 0)
6556 
      oprot.writeI64(self.success)
122 ashish 6557 
      oprot.writeFieldEnd()
3431 rajveer 6558 
    if self.ucx is not None:
559 chandransh 6559 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6560 
      self.ucx.write(oprot)
122 ashish 6561 
      oprot.writeFieldEnd()
6562 
    oprot.writeFieldStop()
6563 
    oprot.writeStructEnd()
6564 
 
3431 rajveer 6565 
  def validate(self):
6566 
    return
6567 
 
6568 
 
122 ashish 6569 
  def __repr__(self):
6570 
    L = ['%s=%r' % (key, value)
6571 
      for key, value in self.__dict__.iteritems()]
6572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6573 
 
6574 
  def __eq__(self, other):
6575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6576 
 
6577 
  def __ne__(self, other):
6578 
    return not (self == other)
6579 
 
559 chandransh 6580 
class removeAddressForUser_args:
94 ashish 6581 
  """
6582 
  Attributes:
559 chandransh 6583 
   - userid
6584 
   - addressId
94 ashish 6585 
  """
6586 
 
6587 
  thrift_spec = (
6588 
    None, # 0
559 chandransh 6589 
    (1, TType.I64, 'userid', None, None, ), # 1
6590 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6591 
  )
6592 
 
559 chandransh 6593 
  def __init__(self, userid=None, addressId=None,):
6594 
    self.userid = userid
6595 
    self.addressId = addressId
94 ashish 6596 
 
6597 
  def read(self, iprot):
6598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6600 
      return
6601 
    iprot.readStructBegin()
6602 
    while True:
6603 
      (fname, ftype, fid) = iprot.readFieldBegin()
6604 
      if ftype == TType.STOP:
6605 
        break
6606 
      if fid == 1:
559 chandransh 6607 
        if ftype == TType.I64:
6608 
          self.userid = iprot.readI64();
94 ashish 6609 
        else:
6610 
          iprot.skip(ftype)
559 chandransh 6611 
      elif fid == 2:
6612 
        if ftype == TType.I64:
6613 
          self.addressId = iprot.readI64();
6614 
        else:
6615 
          iprot.skip(ftype)
94 ashish 6616 
      else:
6617 
        iprot.skip(ftype)
6618 
      iprot.readFieldEnd()
6619 
    iprot.readStructEnd()
6620 
 
6621 
  def write(self, oprot):
6622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6624 
      return
559 chandransh 6625 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6626 
    if self.userid is not None:
559 chandransh 6627 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6628 
      oprot.writeI64(self.userid)
94 ashish 6629 
      oprot.writeFieldEnd()
3431 rajveer 6630 
    if self.addressId is not None:
559 chandransh 6631 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6632 
      oprot.writeI64(self.addressId)
6633 
      oprot.writeFieldEnd()
94 ashish 6634 
    oprot.writeFieldStop()
6635 
    oprot.writeStructEnd()
6636 
 
3431 rajveer 6637 
  def validate(self):
6638 
    return
6639 
 
6640 
 
94 ashish 6641 
  def __repr__(self):
6642 
    L = ['%s=%r' % (key, value)
6643 
      for key, value in self.__dict__.iteritems()]
6644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6645 
 
6646 
  def __eq__(self, other):
6647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6648 
 
6649 
  def __ne__(self, other):
6650 
    return not (self == other)
6651 
 
559 chandransh 6652 
class removeAddressForUser_result:
94 ashish 6653 
  """
6654 
  Attributes:
6655 
   - success
6656 
   - ucx
6657 
  """
6658 
 
6659 
  thrift_spec = (
6660 
    (0, TType.BOOL, 'success', None, None, ), # 0
6661 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6662 
  )
6663 
 
6664 
  def __init__(self, success=None, ucx=None,):
6665 
    self.success = success
6666 
    self.ucx = ucx
6667 
 
6668 
  def read(self, iprot):
6669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6671 
      return
6672 
    iprot.readStructBegin()
6673 
    while True:
6674 
      (fname, ftype, fid) = iprot.readFieldBegin()
6675 
      if ftype == TType.STOP:
6676 
        break
6677 
      if fid == 0:
6678 
        if ftype == TType.BOOL:
6679 
          self.success = iprot.readBool();
6680 
        else:
6681 
          iprot.skip(ftype)
6682 
      elif fid == 1:
6683 
        if ftype == TType.STRUCT:
6684 
          self.ucx = UserContextException()
6685 
          self.ucx.read(iprot)
6686 
        else:
6687 
          iprot.skip(ftype)
6688 
      else:
6689 
        iprot.skip(ftype)
6690 
      iprot.readFieldEnd()
6691 
    iprot.readStructEnd()
6692 
 
6693 
  def write(self, oprot):
6694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6696 
      return
559 chandransh 6697 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6698 
    if self.success is not None:
94 ashish 6699 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6700 
      oprot.writeBool(self.success)
6701 
      oprot.writeFieldEnd()
3431 rajveer 6702 
    if self.ucx is not None:
94 ashish 6703 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6704 
      self.ucx.write(oprot)
6705 
      oprot.writeFieldEnd()
6706 
    oprot.writeFieldStop()
6707 
    oprot.writeStructEnd()
6708 
 
3431 rajveer 6709 
  def validate(self):
6710 
    return
6711 
 
6712 
 
94 ashish 6713 
  def __repr__(self):
6714 
    L = ['%s=%r' % (key, value)
6715 
      for key, value in self.__dict__.iteritems()]
6716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6717 
 
6718 
  def __eq__(self, other):
6719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6720 
 
6721 
  def __ne__(self, other):
6722 
    return not (self == other)
6723 
 
559 chandransh 6724 
class setUserAsLoggedIn_args:
94 ashish 6725 
  """
6726 
  Attributes:
559 chandransh 6727 
   - userId
94 ashish 6728 
   - timestamp
6729 
  """
6730 
 
6731 
  thrift_spec = (
6732 
    None, # 0
559 chandransh 6733 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6734 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6735 
  )
6736 
 
559 chandransh 6737 
  def __init__(self, userId=None, timestamp=None,):
6738 
    self.userId = userId
94 ashish 6739 
    self.timestamp = timestamp
6740 
 
6741 
  def read(self, iprot):
6742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6744 
      return
6745 
    iprot.readStructBegin()
6746 
    while True:
6747 
      (fname, ftype, fid) = iprot.readFieldBegin()
6748 
      if ftype == TType.STOP:
6749 
        break
6750 
      if fid == 1:
559 chandransh 6751 
        if ftype == TType.I64:
6752 
          self.userId = iprot.readI64();
94 ashish 6753 
        else:
6754 
          iprot.skip(ftype)
6755 
      elif fid == 2:
6756 
        if ftype == TType.I64:
6757 
          self.timestamp = iprot.readI64();
6758 
        else:
6759 
          iprot.skip(ftype)
6760 
      else:
6761 
        iprot.skip(ftype)
6762 
      iprot.readFieldEnd()
6763 
    iprot.readStructEnd()
6764 
 
6765 
  def write(self, oprot):
6766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6768 
      return
559 chandransh 6769 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6770 
    if self.userId is not None:
559 chandransh 6771 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6772 
      oprot.writeI64(self.userId)
94 ashish 6773 
      oprot.writeFieldEnd()
3431 rajveer 6774 
    if self.timestamp is not None:
94 ashish 6775 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6776 
      oprot.writeI64(self.timestamp)
6777 
      oprot.writeFieldEnd()
6778 
    oprot.writeFieldStop()
6779 
    oprot.writeStructEnd()
6780 
 
3431 rajveer 6781 
  def validate(self):
6782 
    return
6783 
 
6784 
 
94 ashish 6785 
  def __repr__(self):
6786 
    L = ['%s=%r' % (key, value)
6787 
      for key, value in self.__dict__.iteritems()]
6788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6789 
 
6790 
  def __eq__(self, other):
6791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6792 
 
6793 
  def __ne__(self, other):
6794 
    return not (self == other)
6795 
 
559 chandransh 6796 
class setUserAsLoggedIn_result:
94 ashish 6797 
  """
6798 
  Attributes:
6799 
   - success
6800 
   - ucx
6801 
  """
6802 
 
6803 
  thrift_spec = (
6804 
    (0, TType.BOOL, 'success', None, None, ), # 0
6805 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6806 
  )
6807 
 
6808 
  def __init__(self, success=None, ucx=None,):
6809 
    self.success = success
6810 
    self.ucx = ucx
6811 
 
6812 
  def read(self, iprot):
6813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6815 
      return
6816 
    iprot.readStructBegin()
6817 
    while True:
6818 
      (fname, ftype, fid) = iprot.readFieldBegin()
6819 
      if ftype == TType.STOP:
6820 
        break
6821 
      if fid == 0:
6822 
        if ftype == TType.BOOL:
6823 
          self.success = iprot.readBool();
6824 
        else:
6825 
          iprot.skip(ftype)
6826 
      elif fid == 1:
6827 
        if ftype == TType.STRUCT:
6828 
          self.ucx = UserContextException()
6829 
          self.ucx.read(iprot)
6830 
        else:
6831 
          iprot.skip(ftype)
6832 
      else:
6833 
        iprot.skip(ftype)
6834 
      iprot.readFieldEnd()
6835 
    iprot.readStructEnd()
6836 
 
6837 
  def write(self, oprot):
6838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6840 
      return
559 chandransh 6841 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6842 
    if self.success is not None:
94 ashish 6843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6844 
      oprot.writeBool(self.success)
6845 
      oprot.writeFieldEnd()
3431 rajveer 6846 
    if self.ucx is not None:
94 ashish 6847 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6848 
      self.ucx.write(oprot)
6849 
      oprot.writeFieldEnd()
6850 
    oprot.writeFieldStop()
6851 
    oprot.writeStructEnd()
6852 
 
3431 rajveer 6853 
  def validate(self):
6854 
    return
6855 
 
6856 
 
94 ashish 6857 
  def __repr__(self):
6858 
    L = ['%s=%r' % (key, value)
6859 
      for key, value in self.__dict__.iteritems()]
6860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6861 
 
6862 
  def __eq__(self, other):
6863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6864 
 
6865 
  def __ne__(self, other):
6866 
    return not (self == other)
6867 
 
559 chandransh 6868 
class setUserAsLoggedOut_args:
94 ashish 6869 
  """
6870 
  Attributes:
6871 
   - userid
6872 
   - timestamp
6873 
  """
6874 
 
6875 
  thrift_spec = (
6876 
    None, # 0
559 chandransh 6877 
    (1, TType.I64, 'userid', None, None, ), # 1
6878 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6879 
  )
6880 
 
559 chandransh 6881 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6882 
    self.userid = userid
6883 
    self.timestamp = timestamp
6884 
 
6885 
  def read(self, iprot):
6886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6888 
      return
6889 
    iprot.readStructBegin()
6890 
    while True:
6891 
      (fname, ftype, fid) = iprot.readFieldBegin()
6892 
      if ftype == TType.STOP:
6893 
        break
6894 
      if fid == 1:
6895 
        if ftype == TType.I64:
6896 
          self.userid = iprot.readI64();
6897 
        else:
6898 
          iprot.skip(ftype)
559 chandransh 6899 
      elif fid == 2:
94 ashish 6900 
        if ftype == TType.I64:
6901 
          self.timestamp = iprot.readI64();
6902 
        else:
6903 
          iprot.skip(ftype)
6904 
      else:
6905 
        iprot.skip(ftype)
6906 
      iprot.readFieldEnd()
6907 
    iprot.readStructEnd()
6908 
 
6909 
  def write(self, oprot):
6910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6912 
      return
559 chandransh 6913 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6914 
    if self.userid is not None:
559 chandransh 6915 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6916 
      oprot.writeI64(self.userid)
6917 
      oprot.writeFieldEnd()
3431 rajveer 6918 
    if self.timestamp is not None:
559 chandransh 6919 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6920 
      oprot.writeI64(self.timestamp)
6921 
      oprot.writeFieldEnd()
6922 
    oprot.writeFieldStop()
6923 
    oprot.writeStructEnd()
6924 
 
3431 rajveer 6925 
  def validate(self):
6926 
    return
6927 
 
6928 
 
94 ashish 6929 
  def __repr__(self):
6930 
    L = ['%s=%r' % (key, value)
6931 
      for key, value in self.__dict__.iteritems()]
6932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6933 
 
6934 
  def __eq__(self, other):
6935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6936 
 
6937 
  def __ne__(self, other):
6938 
    return not (self == other)
6939 
 
559 chandransh 6940 
class setUserAsLoggedOut_result:
94 ashish 6941 
  """
6942 
  Attributes:
6943 
   - success
6944 
   - ucx
6945 
  """
6946 
 
6947 
  thrift_spec = (
6948 
    (0, TType.BOOL, 'success', None, None, ), # 0
6949 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6950 
  )
6951 
 
6952 
  def __init__(self, success=None, ucx=None,):
6953 
    self.success = success
6954 
    self.ucx = ucx
6955 
 
6956 
  def read(self, iprot):
6957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6959 
      return
6960 
    iprot.readStructBegin()
6961 
    while True:
6962 
      (fname, ftype, fid) = iprot.readFieldBegin()
6963 
      if ftype == TType.STOP:
6964 
        break
6965 
      if fid == 0:
6966 
        if ftype == TType.BOOL:
6967 
          self.success = iprot.readBool();
6968 
        else:
6969 
          iprot.skip(ftype)
6970 
      elif fid == 1:
6971 
        if ftype == TType.STRUCT:
6972 
          self.ucx = UserContextException()
6973 
          self.ucx.read(iprot)
6974 
        else:
6975 
          iprot.skip(ftype)
6976 
      else:
6977 
        iprot.skip(ftype)
6978 
      iprot.readFieldEnd()
6979 
    iprot.readStructEnd()
6980 
 
6981 
  def write(self, oprot):
6982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6984 
      return
559 chandransh 6985 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6986 
    if self.success is not None:
94 ashish 6987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6988 
      oprot.writeBool(self.success)
6989 
      oprot.writeFieldEnd()
3431 rajveer 6990 
    if self.ucx is not None:
94 ashish 6991 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6992 
      self.ucx.write(oprot)
6993 
      oprot.writeFieldEnd()
6994 
    oprot.writeFieldStop()
6995 
    oprot.writeStructEnd()
6996 
 
3431 rajveer 6997 
  def validate(self):
6998 
    return
6999 
 
7000 
 
94 ashish 7001 
  def __repr__(self):
7002 
    L = ['%s=%r' % (key, value)
7003 
      for key, value in self.__dict__.iteritems()]
7004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7005 
 
7006 
  def __eq__(self, other):
7007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7008 
 
7009 
  def __ne__(self, other):
7010 
    return not (self == other)
7011 
 
559 chandransh 7012 
class setDefaultAddress_args:
94 ashish 7013 
  """
7014 
  Attributes:
7015 
   - userid
7016 
   - addressId
7017 
  """
7018 
 
7019 
  thrift_spec = (
7020 
    None, # 0
7021 
    (1, TType.I64, 'userid', None, None, ), # 1
7022 
    (2, TType.I64, 'addressId', None, None, ), # 2
7023 
  )
7024 
 
7025 
  def __init__(self, userid=None, addressId=None,):
7026 
    self.userid = userid
7027 
    self.addressId = addressId
7028 
 
7029 
  def read(self, iprot):
7030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7032 
      return
7033 
    iprot.readStructBegin()
7034 
    while True:
7035 
      (fname, ftype, fid) = iprot.readFieldBegin()
7036 
      if ftype == TType.STOP:
7037 
        break
7038 
      if fid == 1:
7039 
        if ftype == TType.I64:
7040 
          self.userid = iprot.readI64();
7041 
        else:
7042 
          iprot.skip(ftype)
7043 
      elif fid == 2:
7044 
        if ftype == TType.I64:
7045 
          self.addressId = iprot.readI64();
7046 
        else:
7047 
          iprot.skip(ftype)
7048 
      else:
7049 
        iprot.skip(ftype)
7050 
      iprot.readFieldEnd()
7051 
    iprot.readStructEnd()
7052 
 
7053 
  def write(self, oprot):
7054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7056 
      return
559 chandransh 7057 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7058 
    if self.userid is not None:
94 ashish 7059 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7060 
      oprot.writeI64(self.userid)
7061 
      oprot.writeFieldEnd()
3431 rajveer 7062 
    if self.addressId is not None:
94 ashish 7063 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7064 
      oprot.writeI64(self.addressId)
7065 
      oprot.writeFieldEnd()
7066 
    oprot.writeFieldStop()
7067 
    oprot.writeStructEnd()
7068 
 
3431 rajveer 7069 
  def validate(self):
7070 
    return
7071 
 
7072 
 
94 ashish 7073 
  def __repr__(self):
7074 
    L = ['%s=%r' % (key, value)
7075 
      for key, value in self.__dict__.iteritems()]
7076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7077 
 
7078 
  def __eq__(self, other):
7079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7080 
 
7081 
  def __ne__(self, other):
7082 
    return not (self == other)
7083 
 
559 chandransh 7084 
class setDefaultAddress_result:
94 ashish 7085 
  """
7086 
  Attributes:
7087 
   - success
7088 
   - ucx
7089 
  """
7090 
 
7091 
  thrift_spec = (
7092 
    (0, TType.BOOL, 'success', None, None, ), # 0
7093 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7094 
  )
7095 
 
7096 
  def __init__(self, success=None, ucx=None,):
7097 
    self.success = success
7098 
    self.ucx = ucx
7099 
 
7100 
  def read(self, iprot):
7101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7103 
      return
7104 
    iprot.readStructBegin()
7105 
    while True:
7106 
      (fname, ftype, fid) = iprot.readFieldBegin()
7107 
      if ftype == TType.STOP:
7108 
        break
7109 
      if fid == 0:
7110 
        if ftype == TType.BOOL:
7111 
          self.success = iprot.readBool();
7112 
        else:
7113 
          iprot.skip(ftype)
7114 
      elif fid == 1:
7115 
        if ftype == TType.STRUCT:
7116 
          self.ucx = UserContextException()
7117 
          self.ucx.read(iprot)
7118 
        else:
7119 
          iprot.skip(ftype)
7120 
      else:
7121 
        iprot.skip(ftype)
7122 
      iprot.readFieldEnd()
7123 
    iprot.readStructEnd()
7124 
 
7125 
  def write(self, oprot):
7126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7128 
      return
559 chandransh 7129 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7130 
    if self.success is not None:
94 ashish 7131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7132 
      oprot.writeBool(self.success)
7133 
      oprot.writeFieldEnd()
3431 rajveer 7134 
    if self.ucx is not None:
94 ashish 7135 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7136 
      self.ucx.write(oprot)
7137 
      oprot.writeFieldEnd()
7138 
    oprot.writeFieldStop()
7139 
    oprot.writeStructEnd()
7140 
 
3431 rajveer 7141 
  def validate(self):
7142 
    return
7143 
 
7144 
 
94 ashish 7145 
  def __repr__(self):
7146 
    L = ['%s=%r' % (key, value)
7147 
      for key, value in self.__dict__.iteritems()]
7148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7149 
 
7150 
  def __eq__(self, other):
7151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7152 
 
7153 
  def __ne__(self, other):
7154 
    return not (self == other)
7155 
 
559 chandransh 7156 
class updatePassword_args:
94 ashish 7157 
  """
7158 
  Attributes:
559 chandransh 7159 
   - userid
594 rajveer 7160 
   - oldPassword
7161 
   - newPassword
94 ashish 7162 
  """
7163 
 
7164 
  thrift_spec = (
7165 
    None, # 0
559 chandransh 7166 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7167 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7168 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7169 
  )
7170 
 
594 rajveer 7171 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7172 
    self.userid = userid
594 rajveer 7173 
    self.oldPassword = oldPassword
7174 
    self.newPassword = newPassword
94 ashish 7175 
 
7176 
  def read(self, iprot):
7177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7179 
      return
7180 
    iprot.readStructBegin()
7181 
    while True:
7182 
      (fname, ftype, fid) = iprot.readFieldBegin()
7183 
      if ftype == TType.STOP:
7184 
        break
7185 
      if fid == 1:
7186 
        if ftype == TType.I64:
559 chandransh 7187 
          self.userid = iprot.readI64();
94 ashish 7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      elif fid == 2:
559 chandransh 7191 
        if ftype == TType.STRING:
594 rajveer 7192 
          self.oldPassword = iprot.readString();
94 ashish 7193 
        else:
7194 
          iprot.skip(ftype)
594 rajveer 7195 
      elif fid == 3:
7196 
        if ftype == TType.STRING:
7197 
          self.newPassword = iprot.readString();
7198 
        else:
7199 
          iprot.skip(ftype)
94 ashish 7200 
      else:
7201 
        iprot.skip(ftype)
7202 
      iprot.readFieldEnd()
7203 
    iprot.readStructEnd()
7204 
 
7205 
  def write(self, oprot):
7206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7208 
      return
559 chandransh 7209 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7210 
    if self.userid is not None:
559 chandransh 7211 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7212 
      oprot.writeI64(self.userid)
94 ashish 7213 
      oprot.writeFieldEnd()
3431 rajveer 7214 
    if self.oldPassword is not None:
594 rajveer 7215 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7216 
      oprot.writeString(self.oldPassword)
94 ashish 7217 
      oprot.writeFieldEnd()
3431 rajveer 7218 
    if self.newPassword is not None:
594 rajveer 7219 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7220 
      oprot.writeString(self.newPassword)
7221 
      oprot.writeFieldEnd()
94 ashish 7222 
    oprot.writeFieldStop()
7223 
    oprot.writeStructEnd()
7224 
 
3431 rajveer 7225 
  def validate(self):
7226 
    return
7227 
 
7228 
 
94 ashish 7229 
  def __repr__(self):
7230 
    L = ['%s=%r' % (key, value)
7231 
      for key, value in self.__dict__.iteritems()]
7232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7233 
 
7234 
  def __eq__(self, other):
7235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7236 
 
7237 
  def __ne__(self, other):
7238 
    return not (self == other)
7239 
 
559 chandransh 7240 
class updatePassword_result:
94 ashish 7241 
  """
7242 
  Attributes:
7243 
   - success
7244 
   - ucx
7245 
  """
7246 
 
7247 
  thrift_spec = (
7248 
    (0, TType.BOOL, 'success', None, None, ), # 0
7249 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7250 
  )
7251 
 
7252 
  def __init__(self, success=None, ucx=None,):
7253 
    self.success = success
7254 
    self.ucx = ucx
7255 
 
7256 
  def read(self, iprot):
7257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7259 
      return
7260 
    iprot.readStructBegin()
7261 
    while True:
7262 
      (fname, ftype, fid) = iprot.readFieldBegin()
7263 
      if ftype == TType.STOP:
7264 
        break
7265 
      if fid == 0:
7266 
        if ftype == TType.BOOL:
7267 
          self.success = iprot.readBool();
7268 
        else:
7269 
          iprot.skip(ftype)
7270 
      elif fid == 1:
7271 
        if ftype == TType.STRUCT:
7272 
          self.ucx = UserContextException()
7273 
          self.ucx.read(iprot)
7274 
        else:
7275 
          iprot.skip(ftype)
7276 
      else:
7277 
        iprot.skip(ftype)
7278 
      iprot.readFieldEnd()
7279 
    iprot.readStructEnd()
7280 
 
7281 
  def write(self, oprot):
7282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7284 
      return
559 chandransh 7285 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7286 
    if self.success is not None:
94 ashish 7287 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7288 
      oprot.writeBool(self.success)
7289 
      oprot.writeFieldEnd()
3431 rajveer 7290 
    if self.ucx is not None:
94 ashish 7291 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7292 
      self.ucx.write(oprot)
7293 
      oprot.writeFieldEnd()
7294 
    oprot.writeFieldStop()
7295 
    oprot.writeStructEnd()
7296 
 
3431 rajveer 7297 
  def validate(self):
7298 
    return
7299 
 
7300 
 
94 ashish 7301 
  def __repr__(self):
7302 
    L = ['%s=%r' % (key, value)
7303 
      for key, value in self.__dict__.iteritems()]
7304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7305 
 
7306 
  def __eq__(self, other):
7307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7308 
 
7309 
  def __ne__(self, other):
7310 
    return not (self == other)
7311 
 
581 rajveer 7312 
class forgotPassword_args:
7313 
  """
7314 
  Attributes:
7315 
   - email
884 rajveer 7316 
   - newPassword
581 rajveer 7317 
  """
7318 
 
7319 
  thrift_spec = (
7320 
    None, # 0
7321 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7322 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7323 
  )
7324 
 
884 rajveer 7325 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7326 
    self.email = email
884 rajveer 7327 
    self.newPassword = newPassword
581 rajveer 7328 
 
7329 
  def read(self, iprot):
7330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7332 
      return
7333 
    iprot.readStructBegin()
7334 
    while True:
7335 
      (fname, ftype, fid) = iprot.readFieldBegin()
7336 
      if ftype == TType.STOP:
7337 
        break
7338 
      if fid == 1:
7339 
        if ftype == TType.STRING:
7340 
          self.email = iprot.readString();
7341 
        else:
7342 
          iprot.skip(ftype)
884 rajveer 7343 
      elif fid == 2:
7344 
        if ftype == TType.STRING:
7345 
          self.newPassword = iprot.readString();
7346 
        else:
7347 
          iprot.skip(ftype)
581 rajveer 7348 
      else:
7349 
        iprot.skip(ftype)
7350 
      iprot.readFieldEnd()
7351 
    iprot.readStructEnd()
7352 
 
7353 
  def write(self, oprot):
7354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7356 
      return
7357 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7358 
    if self.email is not None:
581 rajveer 7359 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7360 
      oprot.writeString(self.email)
7361 
      oprot.writeFieldEnd()
3431 rajveer 7362 
    if self.newPassword is not None:
884 rajveer 7363 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7364 
      oprot.writeString(self.newPassword)
7365 
      oprot.writeFieldEnd()
581 rajveer 7366 
    oprot.writeFieldStop()
7367 
    oprot.writeStructEnd()
7368 
 
3431 rajveer 7369 
  def validate(self):
7370 
    return
7371 
 
7372 
 
581 rajveer 7373 
  def __repr__(self):
7374 
    L = ['%s=%r' % (key, value)
7375 
      for key, value in self.__dict__.iteritems()]
7376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7377 
 
7378 
  def __eq__(self, other):
7379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7380 
 
7381 
  def __ne__(self, other):
7382 
    return not (self == other)
7383 
 
7384 
class forgotPassword_result:
7385 
  """
7386 
  Attributes:
7387 
   - success
7388 
   - ucx
7389 
  """
7390 
 
7391 
  thrift_spec = (
7392 
    (0, TType.BOOL, 'success', None, None, ), # 0
7393 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7394 
  )
7395 
 
7396 
  def __init__(self, success=None, ucx=None,):
7397 
    self.success = success
7398 
    self.ucx = ucx
7399 
 
7400 
  def read(self, iprot):
7401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7403 
      return
7404 
    iprot.readStructBegin()
7405 
    while True:
7406 
      (fname, ftype, fid) = iprot.readFieldBegin()
7407 
      if ftype == TType.STOP:
7408 
        break
7409 
      if fid == 0:
7410 
        if ftype == TType.BOOL:
7411 
          self.success = iprot.readBool();
7412 
        else:
7413 
          iprot.skip(ftype)
7414 
      elif fid == 1:
7415 
        if ftype == TType.STRUCT:
7416 
          self.ucx = UserContextException()
7417 
          self.ucx.read(iprot)
7418 
        else:
7419 
          iprot.skip(ftype)
7420 
      else:
7421 
        iprot.skip(ftype)
7422 
      iprot.readFieldEnd()
7423 
    iprot.readStructEnd()
7424 
 
7425 
  def write(self, oprot):
7426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7428 
      return
7429 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7430 
    if self.success is not None:
581 rajveer 7431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7432 
      oprot.writeBool(self.success)
7433 
      oprot.writeFieldEnd()
3431 rajveer 7434 
    if self.ucx is not None:
581 rajveer 7435 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7436 
      self.ucx.write(oprot)
7437 
      oprot.writeFieldEnd()
7438 
    oprot.writeFieldStop()
7439 
    oprot.writeStructEnd()
7440 
 
3431 rajveer 7441 
  def validate(self):
7442 
    return
7443 
 
7444 
 
581 rajveer 7445 
  def __repr__(self):
7446 
    L = ['%s=%r' % (key, value)
7447 
      for key, value in self.__dict__.iteritems()]
7448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7449 
 
7450 
  def __eq__(self, other):
7451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7452 
 
7453 
  def __ne__(self, other):
7454 
    return not (self == other)
7455 
 
594 rajveer 7456 
class getAllAddressesForUser_args:
7457 
  """
7458 
  Attributes:
7459 
   - userId
7460 
  """
7461 
 
7462 
  thrift_spec = (
7463 
    None, # 0
7464 
    (1, TType.I64, 'userId', None, None, ), # 1
7465 
  )
7466 
 
7467 
  def __init__(self, userId=None,):
7468 
    self.userId = userId
7469 
 
7470 
  def read(self, iprot):
7471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7473 
      return
7474 
    iprot.readStructBegin()
7475 
    while True:
7476 
      (fname, ftype, fid) = iprot.readFieldBegin()
7477 
      if ftype == TType.STOP:
7478 
        break
7479 
      if fid == 1:
7480 
        if ftype == TType.I64:
7481 
          self.userId = iprot.readI64();
7482 
        else:
7483 
          iprot.skip(ftype)
7484 
      else:
7485 
        iprot.skip(ftype)
7486 
      iprot.readFieldEnd()
7487 
    iprot.readStructEnd()
7488 
 
7489 
  def write(self, oprot):
7490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7492 
      return
7493 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7494 
    if self.userId is not None:
594 rajveer 7495 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7496 
      oprot.writeI64(self.userId)
7497 
      oprot.writeFieldEnd()
7498 
    oprot.writeFieldStop()
7499 
    oprot.writeStructEnd()
7500 
 
3431 rajveer 7501 
  def validate(self):
7502 
    return
7503 
 
7504 
 
594 rajveer 7505 
  def __repr__(self):
7506 
    L = ['%s=%r' % (key, value)
7507 
      for key, value in self.__dict__.iteritems()]
7508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7509 
 
7510 
  def __eq__(self, other):
7511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7512 
 
7513 
  def __ne__(self, other):
7514 
    return not (self == other)
7515 
 
7516 
class getAllAddressesForUser_result:
7517 
  """
7518 
  Attributes:
7519 
   - success
7520 
   - ucx
7521 
  """
7522 
 
7523 
  thrift_spec = (
7524 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7525 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7526 
  )
7527 
 
7528 
  def __init__(self, success=None, ucx=None,):
7529 
    self.success = success
7530 
    self.ucx = ucx
7531 
 
7532 
  def read(self, iprot):
7533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7535 
      return
7536 
    iprot.readStructBegin()
7537 
    while True:
7538 
      (fname, ftype, fid) = iprot.readFieldBegin()
7539 
      if ftype == TType.STOP:
7540 
        break
7541 
      if fid == 0:
7542 
        if ftype == TType.LIST:
7543 
          self.success = []
11592 amit.gupta 7544 
          (_etype100, _size97) = iprot.readListBegin()
7545 
          for _i101 in xrange(_size97):
7546 
            _elem102 = Address()
7547 
            _elem102.read(iprot)
7548 
            self.success.append(_elem102)
594 rajveer 7549 
          iprot.readListEnd()
7550 
        else:
7551 
          iprot.skip(ftype)
7552 
      elif fid == 1:
7553 
        if ftype == TType.STRUCT:
7554 
          self.ucx = UserContextException()
7555 
          self.ucx.read(iprot)
7556 
        else:
7557 
          iprot.skip(ftype)
7558 
      else:
7559 
        iprot.skip(ftype)
7560 
      iprot.readFieldEnd()
7561 
    iprot.readStructEnd()
7562 
 
7563 
  def write(self, oprot):
7564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7566 
      return
7567 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7568 
    if self.success is not None:
594 rajveer 7569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7571 
      for iter103 in self.success:
7572 
        iter103.write(oprot)
594 rajveer 7573 
      oprot.writeListEnd()
7574 
      oprot.writeFieldEnd()
3431 rajveer 7575 
    if self.ucx is not None:
594 rajveer 7576 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7577 
      self.ucx.write(oprot)
7578 
      oprot.writeFieldEnd()
7579 
    oprot.writeFieldStop()
7580 
    oprot.writeStructEnd()
7581 
 
3431 rajveer 7582 
  def validate(self):
7583 
    return
7584 
 
7585 
 
594 rajveer 7586 
  def __repr__(self):
7587 
    L = ['%s=%r' % (key, value)
7588 
      for key, value in self.__dict__.iteritems()]
7589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7590 
 
7591 
  def __eq__(self, other):
7592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7593 
 
7594 
  def __ne__(self, other):
7595 
    return not (self == other)
7596 
 
1894 vikas 7597 
class getAddressById_args:
7598 
  """
7599 
  Attributes:
7600 
   - addressId
7601 
  """
7602 
 
7603 
  thrift_spec = (
7604 
    None, # 0
7605 
    (1, TType.I64, 'addressId', None, None, ), # 1
7606 
  )
7607 
 
7608 
  def __init__(self, addressId=None,):
7609 
    self.addressId = addressId
7610 
 
7611 
  def read(self, iprot):
7612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7614 
      return
7615 
    iprot.readStructBegin()
7616 
    while True:
7617 
      (fname, ftype, fid) = iprot.readFieldBegin()
7618 
      if ftype == TType.STOP:
7619 
        break
7620 
      if fid == 1:
7621 
        if ftype == TType.I64:
7622 
          self.addressId = iprot.readI64();
7623 
        else:
7624 
          iprot.skip(ftype)
7625 
      else:
7626 
        iprot.skip(ftype)
7627 
      iprot.readFieldEnd()
7628 
    iprot.readStructEnd()
7629 
 
7630 
  def write(self, oprot):
7631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7633 
      return
7634 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7635 
    if self.addressId is not None:
1894 vikas 7636 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7637 
      oprot.writeI64(self.addressId)
7638 
      oprot.writeFieldEnd()
7639 
    oprot.writeFieldStop()
7640 
    oprot.writeStructEnd()
7641 
 
3431 rajveer 7642 
  def validate(self):
7643 
    return
7644 
 
7645 
 
1894 vikas 7646 
  def __repr__(self):
7647 
    L = ['%s=%r' % (key, value)
7648 
      for key, value in self.__dict__.iteritems()]
7649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7650 
 
7651 
  def __eq__(self, other):
7652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7653 
 
7654 
  def __ne__(self, other):
7655 
    return not (self == other)
7656 
 
7657 
class getAddressById_result:
7658 
  """
7659 
  Attributes:
7660 
   - success
7661 
   - ucx
7662 
  """
7663 
 
7664 
  thrift_spec = (
7665 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7666 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7667 
  )
7668 
 
7669 
  def __init__(self, success=None, ucx=None,):
7670 
    self.success = success
7671 
    self.ucx = ucx
7672 
 
7673 
  def read(self, iprot):
7674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7676 
      return
7677 
    iprot.readStructBegin()
7678 
    while True:
7679 
      (fname, ftype, fid) = iprot.readFieldBegin()
7680 
      if ftype == TType.STOP:
7681 
        break
7682 
      if fid == 0:
7683 
        if ftype == TType.STRUCT:
7684 
          self.success = Address()
7685 
          self.success.read(iprot)
7686 
        else:
7687 
          iprot.skip(ftype)
7688 
      elif fid == 1:
7689 
        if ftype == TType.STRUCT:
7690 
          self.ucx = UserContextException()
7691 
          self.ucx.read(iprot)
7692 
        else:
7693 
          iprot.skip(ftype)
7694 
      else:
7695 
        iprot.skip(ftype)
7696 
      iprot.readFieldEnd()
7697 
    iprot.readStructEnd()
7698 
 
7699 
  def write(self, oprot):
7700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7702 
      return
7703 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7704 
    if self.success is not None:
1894 vikas 7705 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7706 
      self.success.write(oprot)
7707 
      oprot.writeFieldEnd()
3431 rajveer 7708 
    if self.ucx is not None:
1894 vikas 7709 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7710 
      self.ucx.write(oprot)
7711 
      oprot.writeFieldEnd()
7712 
    oprot.writeFieldStop()
7713 
    oprot.writeStructEnd()
7714 
 
3431 rajveer 7715 
  def validate(self):
7716 
    return
7717 
 
7718 
 
1894 vikas 7719 
  def __repr__(self):
7720 
    L = ['%s=%r' % (key, value)
7721 
      for key, value in self.__dict__.iteritems()]
7722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7723 
 
7724 
  def __eq__(self, other):
7725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7726 
 
7727 
  def __ne__(self, other):
7728 
    return not (self == other)
7729 
 
594 rajveer 7730 
class getDefaultAddressId_args:
7731 
  """
7732 
  Attributes:
7733 
   - userId
7734 
  """
7735 
 
7736 
  thrift_spec = (
7737 
    None, # 0
7738 
    (1, TType.I64, 'userId', None, None, ), # 1
7739 
  )
7740 
 
7741 
  def __init__(self, userId=None,):
7742 
    self.userId = userId
7743 
 
7744 
  def read(self, iprot):
7745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7747 
      return
7748 
    iprot.readStructBegin()
7749 
    while True:
7750 
      (fname, ftype, fid) = iprot.readFieldBegin()
7751 
      if ftype == TType.STOP:
7752 
        break
7753 
      if fid == 1:
7754 
        if ftype == TType.I64:
7755 
          self.userId = iprot.readI64();
7756 
        else:
7757 
          iprot.skip(ftype)
7758 
      else:
7759 
        iprot.skip(ftype)
7760 
      iprot.readFieldEnd()
7761 
    iprot.readStructEnd()
7762 
 
7763 
  def write(self, oprot):
7764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7766 
      return
7767 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7768 
    if self.userId is not None:
594 rajveer 7769 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7770 
      oprot.writeI64(self.userId)
7771 
      oprot.writeFieldEnd()
7772 
    oprot.writeFieldStop()
7773 
    oprot.writeStructEnd()
7774 
 
3431 rajveer 7775 
  def validate(self):
7776 
    return
7777 
 
7778 
 
594 rajveer 7779 
  def __repr__(self):
7780 
    L = ['%s=%r' % (key, value)
7781 
      for key, value in self.__dict__.iteritems()]
7782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7783 
 
7784 
  def __eq__(self, other):
7785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7786 
 
7787 
  def __ne__(self, other):
7788 
    return not (self == other)
7789 
 
7790 
class getDefaultAddressId_result:
7791 
  """
7792 
  Attributes:
7793 
   - success
7794 
   - ucx
7795 
  """
7796 
 
7797 
  thrift_spec = (
7798 
    (0, TType.I64, 'success', None, None, ), # 0
7799 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7800 
  )
7801 
 
7802 
  def __init__(self, success=None, ucx=None,):
7803 
    self.success = success
7804 
    self.ucx = ucx
7805 
 
7806 
  def read(self, iprot):
7807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7809 
      return
7810 
    iprot.readStructBegin()
7811 
    while True:
7812 
      (fname, ftype, fid) = iprot.readFieldBegin()
7813 
      if ftype == TType.STOP:
7814 
        break
7815 
      if fid == 0:
7816 
        if ftype == TType.I64:
7817 
          self.success = iprot.readI64();
7818 
        else:
7819 
          iprot.skip(ftype)
7820 
      elif fid == 1:
7821 
        if ftype == TType.STRUCT:
7822 
          self.ucx = UserContextException()
7823 
          self.ucx.read(iprot)
7824 
        else:
7825 
          iprot.skip(ftype)
7826 
      else:
7827 
        iprot.skip(ftype)
7828 
      iprot.readFieldEnd()
7829 
    iprot.readStructEnd()
7830 
 
7831 
  def write(self, oprot):
7832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7834 
      return
7835 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7836 
    if self.success is not None:
594 rajveer 7837 
      oprot.writeFieldBegin('success', TType.I64, 0)
7838 
      oprot.writeI64(self.success)
7839 
      oprot.writeFieldEnd()
3431 rajveer 7840 
    if self.ucx is not None:
594 rajveer 7841 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7842 
      self.ucx.write(oprot)
7843 
      oprot.writeFieldEnd()
7844 
    oprot.writeFieldStop()
7845 
    oprot.writeStructEnd()
7846 
 
3431 rajveer 7847 
  def validate(self):
7848 
    return
7849 
 
7850 
 
594 rajveer 7851 
  def __repr__(self):
7852 
    L = ['%s=%r' % (key, value)
7853 
      for key, value in self.__dict__.iteritems()]
7854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7855 
 
7856 
  def __eq__(self, other):
7857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7858 
 
7859 
  def __ne__(self, other):
7860 
    return not (self == other)
7861 
 
785 rajveer 7862 
class getDefaultPincode_args:
7863 
  """
7864 
  Attributes:
7865 
   - userId
7866 
  """
7867 
 
7868 
  thrift_spec = (
7869 
    None, # 0
7870 
    (1, TType.I64, 'userId', None, None, ), # 1
7871 
  )
7872 
 
7873 
  def __init__(self, userId=None,):
7874 
    self.userId = userId
7875 
 
7876 
  def read(self, iprot):
7877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7879 
      return
7880 
    iprot.readStructBegin()
7881 
    while True:
7882 
      (fname, ftype, fid) = iprot.readFieldBegin()
7883 
      if ftype == TType.STOP:
7884 
        break
7885 
      if fid == 1:
7886 
        if ftype == TType.I64:
7887 
          self.userId = iprot.readI64();
7888 
        else:
7889 
          iprot.skip(ftype)
7890 
      else:
7891 
        iprot.skip(ftype)
7892 
      iprot.readFieldEnd()
7893 
    iprot.readStructEnd()
7894 
 
7895 
  def write(self, oprot):
7896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7898 
      return
7899 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7900 
    if self.userId is not None:
785 rajveer 7901 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7902 
      oprot.writeI64(self.userId)
7903 
      oprot.writeFieldEnd()
7904 
    oprot.writeFieldStop()
7905 
    oprot.writeStructEnd()
7906 
 
3431 rajveer 7907 
  def validate(self):
7908 
    return
7909 
 
7910 
 
785 rajveer 7911 
  def __repr__(self):
7912 
    L = ['%s=%r' % (key, value)
7913 
      for key, value in self.__dict__.iteritems()]
7914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7915 
 
7916 
  def __eq__(self, other):
7917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7918 
 
7919 
  def __ne__(self, other):
7920 
    return not (self == other)
7921 
 
7922 
class getDefaultPincode_result:
7923 
  """
7924 
  Attributes:
7925 
   - success
7926 
   - ucx
7927 
  """
7928 
 
7929 
  thrift_spec = (
7930 
    (0, TType.STRING, 'success', None, None, ), # 0
7931 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7932 
  )
7933 
 
7934 
  def __init__(self, success=None, ucx=None,):
7935 
    self.success = success
7936 
    self.ucx = ucx
7937 
 
7938 
  def read(self, iprot):
7939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7941 
      return
7942 
    iprot.readStructBegin()
7943 
    while True:
7944 
      (fname, ftype, fid) = iprot.readFieldBegin()
7945 
      if ftype == TType.STOP:
7946 
        break
7947 
      if fid == 0:
7948 
        if ftype == TType.STRING:
7949 
          self.success = iprot.readString();
7950 
        else:
7951 
          iprot.skip(ftype)
7952 
      elif fid == 1:
7953 
        if ftype == TType.STRUCT:
7954 
          self.ucx = UserContextException()
7955 
          self.ucx.read(iprot)
7956 
        else:
7957 
          iprot.skip(ftype)
7958 
      else:
7959 
        iprot.skip(ftype)
7960 
      iprot.readFieldEnd()
7961 
    iprot.readStructEnd()
7962 
 
7963 
  def write(self, oprot):
7964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7966 
      return
7967 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7968 
    if self.success is not None:
785 rajveer 7969 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7970 
      oprot.writeString(self.success)
7971 
      oprot.writeFieldEnd()
3431 rajveer 7972 
    if self.ucx is not None:
785 rajveer 7973 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7974 
      self.ucx.write(oprot)
7975 
      oprot.writeFieldEnd()
7976 
    oprot.writeFieldStop()
7977 
    oprot.writeStructEnd()
7978 
 
3431 rajveer 7979 
  def validate(self):
7980 
    return
7981 
 
7982 
 
785 rajveer 7983 
  def __repr__(self):
7984 
    L = ['%s=%r' % (key, value)
7985 
      for key, value in self.__dict__.iteritems()]
7986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7987 
 
7988 
  def __eq__(self, other):
7989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7990 
 
7991 
  def __ne__(self, other):
7992 
    return not (self == other)
7993 
 
1274 varun.gupt 7994 
class saveUserCommunication_args:
7995 
  """
7996 
  Attributes:
7997 
   - userId
7998 
   - replyTo
7999 
   - communicationType
8000 
   - orderId
8001 
   - airwaybillNo
8002 
   - productName
8003 
   - subject
8004 
   - message
8005 
  """
8006 
 
8007 
  thrift_spec = (
8008 
    None, # 0
8009 
    (1, TType.I64, 'userId', None, None, ), # 1
8010 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
8011 
    (3, TType.I64, 'communicationType', None, None, ), # 3
8012 
    (4, TType.I64, 'orderId', None, None, ), # 4
8013 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
8014 
    (6, TType.STRING, 'productName', None, None, ), # 6
8015 
    (7, TType.STRING, 'subject', None, None, ), # 7
8016 
    (8, TType.STRING, 'message', None, None, ), # 8
8017 
  )
8018 
 
8019 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
8020 
    self.userId = userId
8021 
    self.replyTo = replyTo
8022 
    self.communicationType = communicationType
8023 
    self.orderId = orderId
8024 
    self.airwaybillNo = airwaybillNo
8025 
    self.productName = productName
8026 
    self.subject = subject
8027 
    self.message = message
8028 
 
8029 
  def read(self, iprot):
8030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8032 
      return
8033 
    iprot.readStructBegin()
8034 
    while True:
8035 
      (fname, ftype, fid) = iprot.readFieldBegin()
8036 
      if ftype == TType.STOP:
8037 
        break
8038 
      if fid == 1:
8039 
        if ftype == TType.I64:
8040 
          self.userId = iprot.readI64();
8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      elif fid == 2:
8044 
        if ftype == TType.STRING:
8045 
          self.replyTo = iprot.readString();
8046 
        else:
8047 
          iprot.skip(ftype)
8048 
      elif fid == 3:
8049 
        if ftype == TType.I64:
8050 
          self.communicationType = iprot.readI64();
8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      elif fid == 4:
8054 
        if ftype == TType.I64:
8055 
          self.orderId = iprot.readI64();
8056 
        else:
8057 
          iprot.skip(ftype)
8058 
      elif fid == 5:
8059 
        if ftype == TType.STRING:
8060 
          self.airwaybillNo = iprot.readString();
8061 
        else:
8062 
          iprot.skip(ftype)
8063 
      elif fid == 6:
8064 
        if ftype == TType.STRING:
8065 
          self.productName = iprot.readString();
8066 
        else:
8067 
          iprot.skip(ftype)
8068 
      elif fid == 7:
8069 
        if ftype == TType.STRING:
8070 
          self.subject = iprot.readString();
8071 
        else:
8072 
          iprot.skip(ftype)
8073 
      elif fid == 8:
8074 
        if ftype == TType.STRING:
8075 
          self.message = iprot.readString();
8076 
        else:
8077 
          iprot.skip(ftype)
8078 
      else:
8079 
        iprot.skip(ftype)
8080 
      iprot.readFieldEnd()
8081 
    iprot.readStructEnd()
8082 
 
8083 
  def write(self, oprot):
8084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8086 
      return
8087 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 8088 
    if self.userId is not None:
1274 varun.gupt 8089 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8090 
      oprot.writeI64(self.userId)
8091 
      oprot.writeFieldEnd()
3431 rajveer 8092 
    if self.replyTo is not None:
1274 varun.gupt 8093 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8094 
      oprot.writeString(self.replyTo)
8095 
      oprot.writeFieldEnd()
3431 rajveer 8096 
    if self.communicationType is not None:
1274 varun.gupt 8097 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8098 
      oprot.writeI64(self.communicationType)
8099 
      oprot.writeFieldEnd()
3431 rajveer 8100 
    if self.orderId is not None:
1274 varun.gupt 8101 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8102 
      oprot.writeI64(self.orderId)
8103 
      oprot.writeFieldEnd()
3431 rajveer 8104 
    if self.airwaybillNo is not None:
1274 varun.gupt 8105 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8106 
      oprot.writeString(self.airwaybillNo)
8107 
      oprot.writeFieldEnd()
3431 rajveer 8108 
    if self.productName is not None:
1274 varun.gupt 8109 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8110 
      oprot.writeString(self.productName)
8111 
      oprot.writeFieldEnd()
3431 rajveer 8112 
    if self.subject is not None:
1274 varun.gupt 8113 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8114 
      oprot.writeString(self.subject)
8115 
      oprot.writeFieldEnd()
3431 rajveer 8116 
    if self.message is not None:
1274 varun.gupt 8117 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8118 
      oprot.writeString(self.message)
8119 
      oprot.writeFieldEnd()
8120 
    oprot.writeFieldStop()
8121 
    oprot.writeStructEnd()
8122 
 
3431 rajveer 8123 
  def validate(self):
8124 
    return
8125 
 
8126 
 
1274 varun.gupt 8127 
  def __repr__(self):
8128 
    L = ['%s=%r' % (key, value)
8129 
      for key, value in self.__dict__.iteritems()]
8130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8131 
 
8132 
  def __eq__(self, other):
8133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8134 
 
8135 
  def __ne__(self, other):
8136 
    return not (self == other)
8137 
 
8138 
class saveUserCommunication_result:
8139 
  """
8140 
  Attributes:
8141 
   - success
8142 
   - ucx
8143 
  """
8144 
 
8145 
  thrift_spec = (
8146 
    (0, TType.BOOL, 'success', None, None, ), # 0
8147 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8148 
  )
8149 
 
8150 
  def __init__(self, success=None, ucx=None,):
8151 
    self.success = success
8152 
    self.ucx = ucx
8153 
 
8154 
  def read(self, iprot):
8155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8157 
      return
8158 
    iprot.readStructBegin()
8159 
    while True:
8160 
      (fname, ftype, fid) = iprot.readFieldBegin()
8161 
      if ftype == TType.STOP:
8162 
        break
8163 
      if fid == 0:
8164 
        if ftype == TType.BOOL:
8165 
          self.success = iprot.readBool();
8166 
        else:
8167 
          iprot.skip(ftype)
8168 
      elif fid == 1:
8169 
        if ftype == TType.STRUCT:
8170 
          self.ucx = UserCommunicationException()
8171 
          self.ucx.read(iprot)
8172 
        else:
8173 
          iprot.skip(ftype)
8174 
      else:
8175 
        iprot.skip(ftype)
8176 
      iprot.readFieldEnd()
8177 
    iprot.readStructEnd()
8178 
 
8179 
  def write(self, oprot):
8180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8182 
      return
8183 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8184 
    if self.success is not None:
1274 varun.gupt 8185 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8186 
      oprot.writeBool(self.success)
8187 
      oprot.writeFieldEnd()
3431 rajveer 8188 
    if self.ucx is not None:
1274 varun.gupt 8189 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8190 
      self.ucx.write(oprot)
8191 
      oprot.writeFieldEnd()
8192 
    oprot.writeFieldStop()
8193 
    oprot.writeStructEnd()
8194 
 
3431 rajveer 8195 
  def validate(self):
8196 
    return
8197 
 
8198 
 
1274 varun.gupt 8199 
  def __repr__(self):
8200 
    L = ['%s=%r' % (key, value)
8201 
      for key, value in self.__dict__.iteritems()]
8202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8203 
 
8204 
  def __eq__(self, other):
8205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8206 
 
8207 
  def __ne__(self, other):
8208 
    return not (self == other)
8209 
 
1590 varun.gupt 8210 
class getUserCommunicationById_args:
8211 
  """
8212 
  Attributes:
8213 
   - id
8214 
  """
8215 
 
8216 
  thrift_spec = (
8217 
    None, # 0
8218 
    (1, TType.I64, 'id', None, None, ), # 1
8219 
  )
8220 
 
8221 
  def __init__(self, id=None,):
8222 
    self.id = id
8223 
 
8224 
  def read(self, iprot):
8225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8227 
      return
8228 
    iprot.readStructBegin()
8229 
    while True:
8230 
      (fname, ftype, fid) = iprot.readFieldBegin()
8231 
      if ftype == TType.STOP:
8232 
        break
8233 
      if fid == 1:
8234 
        if ftype == TType.I64:
8235 
          self.id = iprot.readI64();
8236 
        else:
8237 
          iprot.skip(ftype)
8238 
      else:
8239 
        iprot.skip(ftype)
8240 
      iprot.readFieldEnd()
8241 
    iprot.readStructEnd()
8242 
 
8243 
  def write(self, oprot):
8244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8246 
      return
8247 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8248 
    if self.id is not None:
1590 varun.gupt 8249 
      oprot.writeFieldBegin('id', TType.I64, 1)
8250 
      oprot.writeI64(self.id)
8251 
      oprot.writeFieldEnd()
8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
3431 rajveer 8255 
  def validate(self):
8256 
    return
8257 
 
8258 
 
1590 varun.gupt 8259 
  def __repr__(self):
8260 
    L = ['%s=%r' % (key, value)
8261 
      for key, value in self.__dict__.iteritems()]
8262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8263 
 
8264 
  def __eq__(self, other):
8265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8266 
 
8267 
  def __ne__(self, other):
8268 
    return not (self == other)
8269 
 
8270 
class getUserCommunicationById_result:
8271 
  """
8272 
  Attributes:
8273 
   - success
8274 
   - ucx
8275 
  """
8276 
 
8277 
  thrift_spec = (
8278 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8279 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8280 
  )
8281 
 
8282 
  def __init__(self, success=None, ucx=None,):
8283 
    self.success = success
8284 
    self.ucx = ucx
8285 
 
8286 
  def read(self, iprot):
8287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8289 
      return
8290 
    iprot.readStructBegin()
8291 
    while True:
8292 
      (fname, ftype, fid) = iprot.readFieldBegin()
8293 
      if ftype == TType.STOP:
8294 
        break
8295 
      if fid == 0:
8296 
        if ftype == TType.STRUCT:
8297 
          self.success = UserCommunication()
8298 
          self.success.read(iprot)
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      elif fid == 1:
8302 
        if ftype == TType.STRUCT:
8303 
          self.ucx = UserCommunicationException()
8304 
          self.ucx.read(iprot)
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      else:
8308 
        iprot.skip(ftype)
8309 
      iprot.readFieldEnd()
8310 
    iprot.readStructEnd()
8311 
 
8312 
  def write(self, oprot):
8313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8315 
      return
8316 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8317 
    if self.success is not None:
1590 varun.gupt 8318 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8319 
      self.success.write(oprot)
8320 
      oprot.writeFieldEnd()
3431 rajveer 8321 
    if self.ucx is not None:
1590 varun.gupt 8322 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8323 
      self.ucx.write(oprot)
8324 
      oprot.writeFieldEnd()
8325 
    oprot.writeFieldStop()
8326 
    oprot.writeStructEnd()
8327 
 
3431 rajveer 8328 
  def validate(self):
8329 
    return
8330 
 
8331 
 
1590 varun.gupt 8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
8343 
class getUserCommunicationByUser_args:
8344 
  """
8345 
  Attributes:
8346 
   - userId
8347 
  """
8348 
 
8349 
  thrift_spec = (
8350 
    None, # 0
8351 
    (1, TType.I64, 'userId', None, None, ), # 1
8352 
  )
8353 
 
8354 
  def __init__(self, userId=None,):
8355 
    self.userId = userId
8356 
 
8357 
  def read(self, iprot):
8358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8360 
      return
8361 
    iprot.readStructBegin()
8362 
    while True:
8363 
      (fname, ftype, fid) = iprot.readFieldBegin()
8364 
      if ftype == TType.STOP:
8365 
        break
8366 
      if fid == 1:
8367 
        if ftype == TType.I64:
8368 
          self.userId = iprot.readI64();
8369 
        else:
8370 
          iprot.skip(ftype)
8371 
      else:
8372 
        iprot.skip(ftype)
8373 
      iprot.readFieldEnd()
8374 
    iprot.readStructEnd()
8375 
 
8376 
  def write(self, oprot):
8377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8379 
      return
8380 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8381 
    if self.userId is not None:
1590 varun.gupt 8382 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8383 
      oprot.writeI64(self.userId)
8384 
      oprot.writeFieldEnd()
8385 
    oprot.writeFieldStop()
8386 
    oprot.writeStructEnd()
8387 
 
3431 rajveer 8388 
  def validate(self):
8389 
    return
8390 
 
8391 
 
1590 varun.gupt 8392 
  def __repr__(self):
8393 
    L = ['%s=%r' % (key, value)
8394 
      for key, value in self.__dict__.iteritems()]
8395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8396 
 
8397 
  def __eq__(self, other):
8398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8399 
 
8400 
  def __ne__(self, other):
8401 
    return not (self == other)
8402 
 
8403 
class getUserCommunicationByUser_result:
8404 
  """
8405 
  Attributes:
8406 
   - success
8407 
   - ucx
8408 
  """
8409 
 
8410 
  thrift_spec = (
8411 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8412 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8413 
  )
8414 
 
8415 
  def __init__(self, success=None, ucx=None,):
8416 
    self.success = success
8417 
    self.ucx = ucx
8418 
 
8419 
  def read(self, iprot):
8420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8422 
      return
8423 
    iprot.readStructBegin()
8424 
    while True:
8425 
      (fname, ftype, fid) = iprot.readFieldBegin()
8426 
      if ftype == TType.STOP:
8427 
        break
8428 
      if fid == 0:
8429 
        if ftype == TType.LIST:
8430 
          self.success = []
11592 amit.gupta 8431 
          (_etype107, _size104) = iprot.readListBegin()
8432 
          for _i108 in xrange(_size104):
8433 
            _elem109 = UserCommunication()
8434 
            _elem109.read(iprot)
8435 
            self.success.append(_elem109)
1590 varun.gupt 8436 
          iprot.readListEnd()
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      elif fid == 1:
8440 
        if ftype == TType.STRUCT:
8441 
          self.ucx = UserCommunicationException()
8442 
          self.ucx.read(iprot)
8443 
        else:
8444 
          iprot.skip(ftype)
8445 
      else:
8446 
        iprot.skip(ftype)
8447 
      iprot.readFieldEnd()
8448 
    iprot.readStructEnd()
8449 
 
8450 
  def write(self, oprot):
8451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8453 
      return
8454 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8455 
    if self.success is not None:
1590 varun.gupt 8456 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8457 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8458 
      for iter110 in self.success:
8459 
        iter110.write(oprot)
1590 varun.gupt 8460 
      oprot.writeListEnd()
8461 
      oprot.writeFieldEnd()
3431 rajveer 8462 
    if self.ucx is not None:
1590 varun.gupt 8463 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8464 
      self.ucx.write(oprot)
8465 
      oprot.writeFieldEnd()
8466 
    oprot.writeFieldStop()
8467 
    oprot.writeStructEnd()
8468 
 
3431 rajveer 8469 
  def validate(self):
8470 
    return
8471 
 
8472 
 
1590 varun.gupt 8473 
  def __repr__(self):
8474 
    L = ['%s=%r' % (key, value)
8475 
      for key, value in self.__dict__.iteritems()]
8476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8477 
 
8478 
  def __eq__(self, other):
8479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8480 
 
8481 
  def __ne__(self, other):
8482 
    return not (self == other)
8483 
 
8484 
class getAllUserCommunications_args:
8485 
 
8486 
  thrift_spec = (
8487 
  )
8488 
 
8489 
  def read(self, iprot):
8490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8492 
      return
8493 
    iprot.readStructBegin()
8494 
    while True:
8495 
      (fname, ftype, fid) = iprot.readFieldBegin()
8496 
      if ftype == TType.STOP:
8497 
        break
8498 
      else:
8499 
        iprot.skip(ftype)
8500 
      iprot.readFieldEnd()
8501 
    iprot.readStructEnd()
8502 
 
8503 
  def write(self, oprot):
8504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8506 
      return
8507 
    oprot.writeStructBegin('getAllUserCommunications_args')
8508 
    oprot.writeFieldStop()
8509 
    oprot.writeStructEnd()
8510 
 
3431 rajveer 8511 
  def validate(self):
8512 
    return
8513 
 
8514 
 
1590 varun.gupt 8515 
  def __repr__(self):
8516 
    L = ['%s=%r' % (key, value)
8517 
      for key, value in self.__dict__.iteritems()]
8518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8519 
 
8520 
  def __eq__(self, other):
8521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8522 
 
8523 
  def __ne__(self, other):
8524 
    return not (self == other)
8525 
 
8526 
class getAllUserCommunications_result:
8527 
  """
8528 
  Attributes:
8529 
   - success
8530 
   - ucx
8531 
  """
8532 
 
8533 
  thrift_spec = (
8534 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8535 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8536 
  )
8537 
 
8538 
  def __init__(self, success=None, ucx=None,):
8539 
    self.success = success
8540 
    self.ucx = ucx
8541 
 
8542 
  def read(self, iprot):
8543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8545 
      return
8546 
    iprot.readStructBegin()
8547 
    while True:
8548 
      (fname, ftype, fid) = iprot.readFieldBegin()
8549 
      if ftype == TType.STOP:
8550 
        break
8551 
      if fid == 0:
8552 
        if ftype == TType.LIST:
8553 
          self.success = []
11592 amit.gupta 8554 
          (_etype114, _size111) = iprot.readListBegin()
8555 
          for _i115 in xrange(_size111):
8556 
            _elem116 = UserCommunication()
8557 
            _elem116.read(iprot)
8558 
            self.success.append(_elem116)
1590 varun.gupt 8559 
          iprot.readListEnd()
8560 
        else:
8561 
          iprot.skip(ftype)
8562 
      elif fid == 1:
8563 
        if ftype == TType.STRUCT:
8564 
          self.ucx = UserCommunicationException()
8565 
          self.ucx.read(iprot)
8566 
        else:
8567 
          iprot.skip(ftype)
8568 
      else:
8569 
        iprot.skip(ftype)
8570 
      iprot.readFieldEnd()
8571 
    iprot.readStructEnd()
8572 
 
8573 
  def write(self, oprot):
8574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8576 
      return
8577 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8578 
    if self.success is not None:
1590 varun.gupt 8579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8581 
      for iter117 in self.success:
8582 
        iter117.write(oprot)
1590 varun.gupt 8583 
      oprot.writeListEnd()
8584 
      oprot.writeFieldEnd()
3431 rajveer 8585 
    if self.ucx is not None:
1590 varun.gupt 8586 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8587 
      self.ucx.write(oprot)
8588 
      oprot.writeFieldEnd()
8589 
    oprot.writeFieldStop()
8590 
    oprot.writeStructEnd()
8591 
 
3431 rajveer 8592 
  def validate(self):
8593 
    return
8594 
 
8595 
 
1590 varun.gupt 8596 
  def __repr__(self):
8597 
    L = ['%s=%r' % (key, value)
8598 
      for key, value in self.__dict__.iteritems()]
8599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8600 
 
8601 
  def __eq__(self, other):
8602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8603 
 
8604 
  def __ne__(self, other):
8605 
    return not (self == other)
8606 
 
5407 amar.kumar 8607 
class removeUserCommunication_args:
8608 
  """
8609 
  Attributes:
8610 
   - id
8611 
  """
8612 
 
8613 
  thrift_spec = (
8614 
    None, # 0
8615 
    (1, TType.I64, 'id', None, None, ), # 1
8616 
  )
8617 
 
8618 
  def __init__(self, id=None,):
8619 
    self.id = id
8620 
 
8621 
  def read(self, iprot):
8622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8624 
      return
8625 
    iprot.readStructBegin()
8626 
    while True:
8627 
      (fname, ftype, fid) = iprot.readFieldBegin()
8628 
      if ftype == TType.STOP:
8629 
        break
8630 
      if fid == 1:
8631 
        if ftype == TType.I64:
8632 
          self.id = iprot.readI64();
8633 
        else:
8634 
          iprot.skip(ftype)
8635 
      else:
8636 
        iprot.skip(ftype)
8637 
      iprot.readFieldEnd()
8638 
    iprot.readStructEnd()
8639 
 
8640 
  def write(self, oprot):
8641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8643 
      return
8644 
    oprot.writeStructBegin('removeUserCommunication_args')
8645 
    if self.id is not None:
8646 
      oprot.writeFieldBegin('id', TType.I64, 1)
8647 
      oprot.writeI64(self.id)
8648 
      oprot.writeFieldEnd()
8649 
    oprot.writeFieldStop()
8650 
    oprot.writeStructEnd()
8651 
 
8652 
  def validate(self):
8653 
    return
8654 
 
8655 
 
8656 
  def __repr__(self):
8657 
    L = ['%s=%r' % (key, value)
8658 
      for key, value in self.__dict__.iteritems()]
8659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8660 
 
8661 
  def __eq__(self, other):
8662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8663 
 
8664 
  def __ne__(self, other):
8665 
    return not (self == other)
8666 
 
8667 
class removeUserCommunication_result:
8668 
  """
8669 
  Attributes:
8670 
   - ucx
8671 
  """
8672 
 
8673 
  thrift_spec = (
8674 
    None, # 0
8675 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8676 
  )
8677 
 
8678 
  def __init__(self, ucx=None,):
8679 
    self.ucx = ucx
8680 
 
8681 
  def read(self, iprot):
8682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8684 
      return
8685 
    iprot.readStructBegin()
8686 
    while True:
8687 
      (fname, ftype, fid) = iprot.readFieldBegin()
8688 
      if ftype == TType.STOP:
8689 
        break
8690 
      if fid == 1:
8691 
        if ftype == TType.STRUCT:
8692 
          self.ucx = UserCommunicationException()
8693 
          self.ucx.read(iprot)
8694 
        else:
8695 
          iprot.skip(ftype)
8696 
      else:
8697 
        iprot.skip(ftype)
8698 
      iprot.readFieldEnd()
8699 
    iprot.readStructEnd()
8700 
 
8701 
  def write(self, oprot):
8702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8704 
      return
8705 
    oprot.writeStructBegin('removeUserCommunication_result')
8706 
    if self.ucx is not None:
8707 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8708 
      self.ucx.write(oprot)
8709 
      oprot.writeFieldEnd()
8710 
    oprot.writeFieldStop()
8711 
    oprot.writeStructEnd()
8712 
 
8713 
  def validate(self):
8714 
    return
8715 
 
8716 
 
8717 
  def __repr__(self):
8718 
    L = ['%s=%r' % (key, value)
8719 
      for key, value in self.__dict__.iteritems()]
8720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8721 
 
8722 
  def __eq__(self, other):
8723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8724 
 
8725 
  def __ne__(self, other):
8726 
    return not (self == other)
8727 
 
1845 vikas 8728 
class createMasterAffiliate_args:
8729 
  """
8730 
  Attributes:
8731 
   - name
1859 vikas 8732 
   - addedOn
1845 vikas 8733 
  """
8734 
 
8735 
  thrift_spec = (
8736 
    None, # 0
8737 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8738 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8739 
  )
8740 
 
1859 vikas 8741 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8742 
    self.name = name
1859 vikas 8743 
    self.addedOn = addedOn
1845 vikas 8744 
 
8745 
  def read(self, iprot):
8746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8748 
      return
8749 
    iprot.readStructBegin()
8750 
    while True:
8751 
      (fname, ftype, fid) = iprot.readFieldBegin()
8752 
      if ftype == TType.STOP:
8753 
        break
8754 
      if fid == 1:
8755 
        if ftype == TType.STRING:
8756 
          self.name = iprot.readString();
8757 
        else:
8758 
          iprot.skip(ftype)
1859 vikas 8759 
      elif fid == 2:
8760 
        if ftype == TType.I64:
8761 
          self.addedOn = iprot.readI64();
8762 
        else:
8763 
          iprot.skip(ftype)
1845 vikas 8764 
      else:
8765 
        iprot.skip(ftype)
8766 
      iprot.readFieldEnd()
8767 
    iprot.readStructEnd()
8768 
 
8769 
  def write(self, oprot):
8770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8772 
      return
8773 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8774 
    if self.name is not None:
1845 vikas 8775 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8776 
      oprot.writeString(self.name)
8777 
      oprot.writeFieldEnd()
3431 rajveer 8778 
    if self.addedOn is not None:
1859 vikas 8779 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8780 
      oprot.writeI64(self.addedOn)
8781 
      oprot.writeFieldEnd()
1845 vikas 8782 
    oprot.writeFieldStop()
8783 
    oprot.writeStructEnd()
8784 
 
3431 rajveer 8785 
  def validate(self):
8786 
    return
8787 
 
8788 
 
1845 vikas 8789 
  def __repr__(self):
8790 
    L = ['%s=%r' % (key, value)
8791 
      for key, value in self.__dict__.iteritems()]
8792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8793 
 
8794 
  def __eq__(self, other):
8795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8796 
 
8797 
  def __ne__(self, other):
8798 
    return not (self == other)
8799 
 
8800 
class createMasterAffiliate_result:
8801 
  """
8802 
  Attributes:
8803 
   - success
8804 
   - utx
8805 
  """
8806 
 
8807 
  thrift_spec = (
8808 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8809 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8810 
  )
8811 
 
8812 
  def __init__(self, success=None, utx=None,):
8813 
    self.success = success
8814 
    self.utx = utx
8815 
 
8816 
  def read(self, iprot):
8817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8819 
      return
8820 
    iprot.readStructBegin()
8821 
    while True:
8822 
      (fname, ftype, fid) = iprot.readFieldBegin()
8823 
      if ftype == TType.STOP:
8824 
        break
8825 
      if fid == 0:
8826 
        if ftype == TType.STRUCT:
8827 
          self.success = MasterAffiliate()
8828 
          self.success.read(iprot)
8829 
        else:
8830 
          iprot.skip(ftype)
8831 
      elif fid == 1:
8832 
        if ftype == TType.STRUCT:
1996 vikas 8833 
          self.utx = UserAffiliateException()
1845 vikas 8834 
          self.utx.read(iprot)
8835 
        else:
8836 
          iprot.skip(ftype)
8837 
      else:
8838 
        iprot.skip(ftype)
8839 
      iprot.readFieldEnd()
8840 
    iprot.readStructEnd()
8841 
 
8842 
  def write(self, oprot):
8843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8845 
      return
8846 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8847 
    if self.success is not None:
1845 vikas 8848 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8849 
      self.success.write(oprot)
8850 
      oprot.writeFieldEnd()
3431 rajveer 8851 
    if self.utx is not None:
1845 vikas 8852 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8853 
      self.utx.write(oprot)
8854 
      oprot.writeFieldEnd()
8855 
    oprot.writeFieldStop()
8856 
    oprot.writeStructEnd()
8857 
 
3431 rajveer 8858 
  def validate(self):
8859 
    return
8860 
 
8861 
 
1845 vikas 8862 
  def __repr__(self):
8863 
    L = ['%s=%r' % (key, value)
8864 
      for key, value in self.__dict__.iteritems()]
8865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8866 
 
8867 
  def __eq__(self, other):
8868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8869 
 
8870 
  def __ne__(self, other):
8871 
    return not (self == other)
8872 
 
1899 vikas 8873 
class getAllMasterAffiliates_args:
8874 
 
8875 
  thrift_spec = (
8876 
  )
8877 
 
8878 
  def read(self, iprot):
8879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8881 
      return
8882 
    iprot.readStructBegin()
8883 
    while True:
8884 
      (fname, ftype, fid) = iprot.readFieldBegin()
8885 
      if ftype == TType.STOP:
8886 
        break
8887 
      else:
8888 
        iprot.skip(ftype)
8889 
      iprot.readFieldEnd()
8890 
    iprot.readStructEnd()
8891 
 
8892 
  def write(self, oprot):
8893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8895 
      return
8896 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8897 
    oprot.writeFieldStop()
8898 
    oprot.writeStructEnd()
8899 
 
3431 rajveer 8900 
  def validate(self):
8901 
    return
8902 
 
8903 
 
1899 vikas 8904 
  def __repr__(self):
8905 
    L = ['%s=%r' % (key, value)
8906 
      for key, value in self.__dict__.iteritems()]
8907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8908 
 
8909 
  def __eq__(self, other):
8910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8911 
 
8912 
  def __ne__(self, other):
8913 
    return not (self == other)
8914 
 
8915 
class getAllMasterAffiliates_result:
8916 
  """
8917 
  Attributes:
8918 
   - success
8919 
   - utx
8920 
  """
8921 
 
8922 
  thrift_spec = (
8923 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8924 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8925 
  )
8926 
 
8927 
  def __init__(self, success=None, utx=None,):
8928 
    self.success = success
8929 
    self.utx = utx
8930 
 
8931 
  def read(self, iprot):
8932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8934 
      return
8935 
    iprot.readStructBegin()
8936 
    while True:
8937 
      (fname, ftype, fid) = iprot.readFieldBegin()
8938 
      if ftype == TType.STOP:
8939 
        break
8940 
      if fid == 0:
8941 
        if ftype == TType.LIST:
8942 
          self.success = []
11592 amit.gupta 8943 
          (_etype121, _size118) = iprot.readListBegin()
8944 
          for _i122 in xrange(_size118):
8945 
            _elem123 = MasterAffiliate()
8946 
            _elem123.read(iprot)
8947 
            self.success.append(_elem123)
1899 vikas 8948 
          iprot.readListEnd()
8949 
        else:
8950 
          iprot.skip(ftype)
8951 
      elif fid == 1:
8952 
        if ftype == TType.STRUCT:
1996 vikas 8953 
          self.utx = UserAffiliateException()
1899 vikas 8954 
          self.utx.read(iprot)
8955 
        else:
8956 
          iprot.skip(ftype)
8957 
      else:
8958 
        iprot.skip(ftype)
8959 
      iprot.readFieldEnd()
8960 
    iprot.readStructEnd()
8961 
 
8962 
  def write(self, oprot):
8963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8965 
      return
8966 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8967 
    if self.success is not None:
1899 vikas 8968 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8969 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8970 
      for iter124 in self.success:
8971 
        iter124.write(oprot)
1899 vikas 8972 
      oprot.writeListEnd()
8973 
      oprot.writeFieldEnd()
3431 rajveer 8974 
    if self.utx is not None:
1899 vikas 8975 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8976 
      self.utx.write(oprot)
8977 
      oprot.writeFieldEnd()
8978 
    oprot.writeFieldStop()
8979 
    oprot.writeStructEnd()
8980 
 
3431 rajveer 8981 
  def validate(self):
8982 
    return
8983 
 
8984 
 
1899 vikas 8985 
  def __repr__(self):
8986 
    L = ['%s=%r' % (key, value)
8987 
      for key, value in self.__dict__.iteritems()]
8988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8989 
 
8990 
  def __eq__(self, other):
8991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8992 
 
8993 
  def __ne__(self, other):
8994 
    return not (self == other)
8995 
 
1845 vikas 8996 
class getMasterAffiliateById_args:
8997 
  """
8998 
  Attributes:
8999 
   - id
9000 
  """
9001 
 
9002 
  thrift_spec = (
9003 
    None, # 0
9004 
    (1, TType.I64, 'id', None, None, ), # 1
9005 
  )
9006 
 
9007 
  def __init__(self, id=None,):
9008 
    self.id = id
9009 
 
9010 
  def read(self, iprot):
9011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9013 
      return
9014 
    iprot.readStructBegin()
9015 
    while True:
9016 
      (fname, ftype, fid) = iprot.readFieldBegin()
9017 
      if ftype == TType.STOP:
9018 
        break
9019 
      if fid == 1:
9020 
        if ftype == TType.I64:
9021 
          self.id = iprot.readI64();
9022 
        else:
9023 
          iprot.skip(ftype)
9024 
      else:
9025 
        iprot.skip(ftype)
9026 
      iprot.readFieldEnd()
9027 
    iprot.readStructEnd()
9028 
 
9029 
  def write(self, oprot):
9030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9032 
      return
9033 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 9034 
    if self.id is not None:
1845 vikas 9035 
      oprot.writeFieldBegin('id', TType.I64, 1)
9036 
      oprot.writeI64(self.id)
9037 
      oprot.writeFieldEnd()
9038 
    oprot.writeFieldStop()
9039 
    oprot.writeStructEnd()
9040 
 
3431 rajveer 9041 
  def validate(self):
9042 
    return
9043 
 
9044 
 
1845 vikas 9045 
  def __repr__(self):
9046 
    L = ['%s=%r' % (key, value)
9047 
      for key, value in self.__dict__.iteritems()]
9048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9049 
 
9050 
  def __eq__(self, other):
9051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9052 
 
9053 
  def __ne__(self, other):
9054 
    return not (self == other)
9055 
 
9056 
class getMasterAffiliateById_result:
9057 
  """
9058 
  Attributes:
9059 
   - success
9060 
   - utx
9061 
  """
9062 
 
9063 
  thrift_spec = (
9064 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9065 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9066 
  )
9067 
 
9068 
  def __init__(self, success=None, utx=None,):
9069 
    self.success = success
9070 
    self.utx = utx
9071 
 
9072 
  def read(self, iprot):
9073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9075 
      return
9076 
    iprot.readStructBegin()
9077 
    while True:
9078 
      (fname, ftype, fid) = iprot.readFieldBegin()
9079 
      if ftype == TType.STOP:
9080 
        break
9081 
      if fid == 0:
9082 
        if ftype == TType.STRUCT:
9083 
          self.success = MasterAffiliate()
9084 
          self.success.read(iprot)
9085 
        else:
9086 
          iprot.skip(ftype)
9087 
      elif fid == 1:
9088 
        if ftype == TType.STRUCT:
1996 vikas 9089 
          self.utx = UserAffiliateException()
1845 vikas 9090 
          self.utx.read(iprot)
9091 
        else:
9092 
          iprot.skip(ftype)
9093 
      else:
9094 
        iprot.skip(ftype)
9095 
      iprot.readFieldEnd()
9096 
    iprot.readStructEnd()
9097 
 
9098 
  def write(self, oprot):
9099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9101 
      return
9102 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9103 
    if self.success is not None:
1845 vikas 9104 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9105 
      self.success.write(oprot)
9106 
      oprot.writeFieldEnd()
3431 rajveer 9107 
    if self.utx is not None:
1845 vikas 9108 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9109 
      self.utx.write(oprot)
9110 
      oprot.writeFieldEnd()
9111 
    oprot.writeFieldStop()
9112 
    oprot.writeStructEnd()
9113 
 
3431 rajveer 9114 
  def validate(self):
9115 
    return
9116 
 
9117 
 
1845 vikas 9118 
  def __repr__(self):
9119 
    L = ['%s=%r' % (key, value)
9120 
      for key, value in self.__dict__.iteritems()]
9121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9122 
 
9123 
  def __eq__(self, other):
9124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9125 
 
9126 
  def __ne__(self, other):
9127 
    return not (self == other)
9128 
 
9129 
class getMasterAffiliateByName_args:
9130 
  """
9131 
  Attributes:
9132 
   - name
9133 
  """
9134 
 
9135 
  thrift_spec = (
9136 
    None, # 0
9137 
    (1, TType.STRING, 'name', None, None, ), # 1
9138 
  )
9139 
 
9140 
  def __init__(self, name=None,):
9141 
    self.name = name
9142 
 
9143 
  def read(self, iprot):
9144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9146 
      return
9147 
    iprot.readStructBegin()
9148 
    while True:
9149 
      (fname, ftype, fid) = iprot.readFieldBegin()
9150 
      if ftype == TType.STOP:
9151 
        break
9152 
      if fid == 1:
9153 
        if ftype == TType.STRING:
9154 
          self.name = iprot.readString();
9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      else:
9158 
        iprot.skip(ftype)
9159 
      iprot.readFieldEnd()
9160 
    iprot.readStructEnd()
9161 
 
9162 
  def write(self, oprot):
9163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9165 
      return
9166 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9167 
    if self.name is not None:
1845 vikas 9168 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9169 
      oprot.writeString(self.name)
9170 
      oprot.writeFieldEnd()
9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
3431 rajveer 9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
1845 vikas 9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
9189 
class getMasterAffiliateByName_result:
9190 
  """
9191 
  Attributes:
9192 
   - success
9193 
   - utx
9194 
  """
9195 
 
9196 
  thrift_spec = (
9197 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9198 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9199 
  )
9200 
 
9201 
  def __init__(self, success=None, utx=None,):
9202 
    self.success = success
9203 
    self.utx = utx
9204 
 
9205 
  def read(self, iprot):
9206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9208 
      return
9209 
    iprot.readStructBegin()
9210 
    while True:
9211 
      (fname, ftype, fid) = iprot.readFieldBegin()
9212 
      if ftype == TType.STOP:
9213 
        break
9214 
      if fid == 0:
9215 
        if ftype == TType.STRUCT:
9216 
          self.success = MasterAffiliate()
9217 
          self.success.read(iprot)
9218 
        else:
9219 
          iprot.skip(ftype)
9220 
      elif fid == 1:
9221 
        if ftype == TType.STRUCT:
1996 vikas 9222 
          self.utx = UserAffiliateException()
1845 vikas 9223 
          self.utx.read(iprot)
9224 
        else:
9225 
          iprot.skip(ftype)
9226 
      else:
9227 
        iprot.skip(ftype)
9228 
      iprot.readFieldEnd()
9229 
    iprot.readStructEnd()
9230 
 
9231 
  def write(self, oprot):
9232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9234 
      return
9235 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9236 
    if self.success is not None:
1845 vikas 9237 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9238 
      self.success.write(oprot)
9239 
      oprot.writeFieldEnd()
3431 rajveer 9240 
    if self.utx is not None:
1845 vikas 9241 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9242 
      self.utx.write(oprot)
9243 
      oprot.writeFieldEnd()
9244 
    oprot.writeFieldStop()
9245 
    oprot.writeStructEnd()
9246 
 
3431 rajveer 9247 
  def validate(self):
9248 
    return
9249 
 
9250 
 
1845 vikas 9251 
  def __repr__(self):
9252 
    L = ['%s=%r' % (key, value)
9253 
      for key, value in self.__dict__.iteritems()]
9254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9255 
 
9256 
  def __eq__(self, other):
9257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9258 
 
9259 
  def __ne__(self, other):
9260 
    return not (self == other)
9261 
 
9262 
class createAffiliate_args:
9263 
  """
9264 
  Attributes:
9265 
   - name
9266 
   - url
9267 
   - masterAffiliateId
1859 vikas 9268 
   - addedOn
1845 vikas 9269 
  """
9270 
 
9271 
  thrift_spec = (
9272 
    None, # 0
9273 
    (1, TType.STRING, 'name', None, None, ), # 1
9274 
    (2, TType.STRING, 'url', None, None, ), # 2
9275 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9276 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9277 
  )
9278 
 
1859 vikas 9279 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9280 
    self.name = name
9281 
    self.url = url
9282 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9283 
    self.addedOn = addedOn
1845 vikas 9284 
 
9285 
  def read(self, iprot):
9286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9288 
      return
9289 
    iprot.readStructBegin()
9290 
    while True:
9291 
      (fname, ftype, fid) = iprot.readFieldBegin()
9292 
      if ftype == TType.STOP:
9293 
        break
9294 
      if fid == 1:
9295 
        if ftype == TType.STRING:
9296 
          self.name = iprot.readString();
9297 
        else:
9298 
          iprot.skip(ftype)
9299 
      elif fid == 2:
9300 
        if ftype == TType.STRING:
9301 
          self.url = iprot.readString();
9302 
        else:
9303 
          iprot.skip(ftype)
9304 
      elif fid == 3:
9305 
        if ftype == TType.I64:
9306 
          self.masterAffiliateId = iprot.readI64();
9307 
        else:
9308 
          iprot.skip(ftype)
1859 vikas 9309 
      elif fid == 4:
9310 
        if ftype == TType.I64:
9311 
          self.addedOn = iprot.readI64();
9312 
        else:
9313 
          iprot.skip(ftype)
1845 vikas 9314 
      else:
9315 
        iprot.skip(ftype)
9316 
      iprot.readFieldEnd()
9317 
    iprot.readStructEnd()
9318 
 
9319 
  def write(self, oprot):
9320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9322 
      return
9323 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9324 
    if self.name is not None:
1845 vikas 9325 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9326 
      oprot.writeString(self.name)
9327 
      oprot.writeFieldEnd()
3431 rajveer 9328 
    if self.url is not None:
1845 vikas 9329 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9330 
      oprot.writeString(self.url)
9331 
      oprot.writeFieldEnd()
3431 rajveer 9332 
    if self.masterAffiliateId is not None:
1845 vikas 9333 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9334 
      oprot.writeI64(self.masterAffiliateId)
9335 
      oprot.writeFieldEnd()
3431 rajveer 9336 
    if self.addedOn is not None:
1859 vikas 9337 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9338 
      oprot.writeI64(self.addedOn)
9339 
      oprot.writeFieldEnd()
1845 vikas 9340 
    oprot.writeFieldStop()
9341 
    oprot.writeStructEnd()
9342 
 
3431 rajveer 9343 
  def validate(self):
9344 
    return
9345 
 
9346 
 
1845 vikas 9347 
  def __repr__(self):
9348 
    L = ['%s=%r' % (key, value)
9349 
      for key, value in self.__dict__.iteritems()]
9350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9351 
 
9352 
  def __eq__(self, other):
9353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9354 
 
9355 
  def __ne__(self, other):
9356 
    return not (self == other)
9357 
 
9358 
class createAffiliate_result:
9359 
  """
9360 
  Attributes:
9361 
   - success
9362 
   - utx
9363 
  """
9364 
 
9365 
  thrift_spec = (
9366 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9367 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9368 
  )
9369 
 
9370 
  def __init__(self, success=None, utx=None,):
9371 
    self.success = success
9372 
    self.utx = utx
9373 
 
9374 
  def read(self, iprot):
9375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9377 
      return
9378 
    iprot.readStructBegin()
9379 
    while True:
9380 
      (fname, ftype, fid) = iprot.readFieldBegin()
9381 
      if ftype == TType.STOP:
9382 
        break
9383 
      if fid == 0:
9384 
        if ftype == TType.STRUCT:
9385 
          self.success = Affiliate()
9386 
          self.success.read(iprot)
9387 
        else:
9388 
          iprot.skip(ftype)
9389 
      elif fid == 1:
9390 
        if ftype == TType.STRUCT:
1996 vikas 9391 
          self.utx = UserAffiliateException()
1845 vikas 9392 
          self.utx.read(iprot)
9393 
        else:
9394 
          iprot.skip(ftype)
9395 
      else:
9396 
        iprot.skip(ftype)
9397 
      iprot.readFieldEnd()
9398 
    iprot.readStructEnd()
9399 
 
9400 
  def write(self, oprot):
9401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9403 
      return
9404 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9405 
    if self.success is not None:
1845 vikas 9406 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9407 
      self.success.write(oprot)
9408 
      oprot.writeFieldEnd()
3431 rajveer 9409 
    if self.utx is not None:
1845 vikas 9410 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9411 
      self.utx.write(oprot)
9412 
      oprot.writeFieldEnd()
9413 
    oprot.writeFieldStop()
9414 
    oprot.writeStructEnd()
9415 
 
3431 rajveer 9416 
  def validate(self):
9417 
    return
9418 
 
9419 
 
1845 vikas 9420 
  def __repr__(self):
9421 
    L = ['%s=%r' % (key, value)
9422 
      for key, value in self.__dict__.iteritems()]
9423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9424 
 
9425 
  def __eq__(self, other):
9426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9427 
 
9428 
  def __ne__(self, other):
9429 
    return not (self == other)
9430 
 
9431 
class getAffiliateById_args:
9432 
  """
9433 
  Attributes:
9434 
   - id
9435 
  """
9436 
 
9437 
  thrift_spec = (
9438 
    None, # 0
9439 
    (1, TType.I64, 'id', None, None, ), # 1
9440 
  )
9441 
 
9442 
  def __init__(self, id=None,):
9443 
    self.id = id
9444 
 
9445 
  def read(self, iprot):
9446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9448 
      return
9449 
    iprot.readStructBegin()
9450 
    while True:
9451 
      (fname, ftype, fid) = iprot.readFieldBegin()
9452 
      if ftype == TType.STOP:
9453 
        break
9454 
      if fid == 1:
9455 
        if ftype == TType.I64:
9456 
          self.id = iprot.readI64();
9457 
        else:
9458 
          iprot.skip(ftype)
9459 
      else:
9460 
        iprot.skip(ftype)
9461 
      iprot.readFieldEnd()
9462 
    iprot.readStructEnd()
9463 
 
9464 
  def write(self, oprot):
9465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9467 
      return
9468 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9469 
    if self.id is not None:
1845 vikas 9470 
      oprot.writeFieldBegin('id', TType.I64, 1)
9471 
      oprot.writeI64(self.id)
9472 
      oprot.writeFieldEnd()
9473 
    oprot.writeFieldStop()
9474 
    oprot.writeStructEnd()
9475 
 
3431 rajveer 9476 
  def validate(self):
9477 
    return
9478 
 
9479 
 
1845 vikas 9480 
  def __repr__(self):
9481 
    L = ['%s=%r' % (key, value)
9482 
      for key, value in self.__dict__.iteritems()]
9483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9484 
 
9485 
  def __eq__(self, other):
9486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9487 
 
9488 
  def __ne__(self, other):
9489 
    return not (self == other)
9490 
 
9491 
class getAffiliateById_result:
9492 
  """
9493 
  Attributes:
9494 
   - success
9495 
   - utx
9496 
  """
9497 
 
9498 
  thrift_spec = (
9499 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9500 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9501 
  )
9502 
 
9503 
  def __init__(self, success=None, utx=None,):
9504 
    self.success = success
9505 
    self.utx = utx
9506 
 
9507 
  def read(self, iprot):
9508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9510 
      return
9511 
    iprot.readStructBegin()
9512 
    while True:
9513 
      (fname, ftype, fid) = iprot.readFieldBegin()
9514 
      if ftype == TType.STOP:
9515 
        break
9516 
      if fid == 0:
9517 
        if ftype == TType.STRUCT:
9518 
          self.success = Affiliate()
9519 
          self.success.read(iprot)
9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      elif fid == 1:
9523 
        if ftype == TType.STRUCT:
1996 vikas 9524 
          self.utx = UserAffiliateException()
1845 vikas 9525 
          self.utx.read(iprot)
9526 
        else:
9527 
          iprot.skip(ftype)
9528 
      else:
9529 
        iprot.skip(ftype)
9530 
      iprot.readFieldEnd()
9531 
    iprot.readStructEnd()
9532 
 
9533 
  def write(self, oprot):
9534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9536 
      return
9537 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9538 
    if self.success is not None:
1845 vikas 9539 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9540 
      self.success.write(oprot)
9541 
      oprot.writeFieldEnd()
3431 rajveer 9542 
    if self.utx is not None:
1845 vikas 9543 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9544 
      self.utx.write(oprot)
9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
3431 rajveer 9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
1845 vikas 9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
9564 
class getAffiliateByName_args:
9565 
  """
9566 
  Attributes:
9567 
   - name
9568 
  """
9569 
 
9570 
  thrift_spec = (
9571 
    None, # 0
9572 
    (1, TType.STRING, 'name', None, None, ), # 1
9573 
  )
9574 
 
9575 
  def __init__(self, name=None,):
9576 
    self.name = name
9577 
 
9578 
  def read(self, iprot):
9579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9581 
      return
9582 
    iprot.readStructBegin()
9583 
    while True:
9584 
      (fname, ftype, fid) = iprot.readFieldBegin()
9585 
      if ftype == TType.STOP:
9586 
        break
9587 
      if fid == 1:
9588 
        if ftype == TType.STRING:
9589 
          self.name = iprot.readString();
9590 
        else:
9591 
          iprot.skip(ftype)
9592 
      else:
9593 
        iprot.skip(ftype)
9594 
      iprot.readFieldEnd()
9595 
    iprot.readStructEnd()
9596 
 
9597 
  def write(self, oprot):
9598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9600 
      return
9601 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9602 
    if self.name is not None:
1845 vikas 9603 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9604 
      oprot.writeString(self.name)
9605 
      oprot.writeFieldEnd()
9606 
    oprot.writeFieldStop()
9607 
    oprot.writeStructEnd()
9608 
 
3431 rajveer 9609 
  def validate(self):
9610 
    return
9611 
 
9612 
 
1845 vikas 9613 
  def __repr__(self):
9614 
    L = ['%s=%r' % (key, value)
9615 
      for key, value in self.__dict__.iteritems()]
9616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9617 
 
9618 
  def __eq__(self, other):
9619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9620 
 
9621 
  def __ne__(self, other):
9622 
    return not (self == other)
9623 
 
9624 
class getAffiliateByName_result:
9625 
  """
9626 
  Attributes:
9627 
   - success
9628 
   - utx
9629 
  """
9630 
 
9631 
  thrift_spec = (
9632 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9633 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9634 
  )
9635 
 
9636 
  def __init__(self, success=None, utx=None,):
9637 
    self.success = success
9638 
    self.utx = utx
9639 
 
9640 
  def read(self, iprot):
9641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9643 
      return
9644 
    iprot.readStructBegin()
9645 
    while True:
9646 
      (fname, ftype, fid) = iprot.readFieldBegin()
9647 
      if ftype == TType.STOP:
9648 
        break
9649 
      if fid == 0:
9650 
        if ftype == TType.STRUCT:
9651 
          self.success = Affiliate()
9652 
          self.success.read(iprot)
9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      elif fid == 1:
9656 
        if ftype == TType.STRUCT:
1996 vikas 9657 
          self.utx = UserAffiliateException()
1845 vikas 9658 
          self.utx.read(iprot)
9659 
        else:
9660 
          iprot.skip(ftype)
9661 
      else:
9662 
        iprot.skip(ftype)
9663 
      iprot.readFieldEnd()
9664 
    iprot.readStructEnd()
9665 
 
9666 
  def write(self, oprot):
9667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9669 
      return
9670 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9671 
    if self.success is not None:
1845 vikas 9672 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9673 
      self.success.write(oprot)
9674 
      oprot.writeFieldEnd()
3431 rajveer 9675 
    if self.utx is not None:
1845 vikas 9676 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9677 
      self.utx.write(oprot)
9678 
      oprot.writeFieldEnd()
9679 
    oprot.writeFieldStop()
9680 
    oprot.writeStructEnd()
9681 
 
3431 rajveer 9682 
  def validate(self):
9683 
    return
9684 
 
9685 
 
1845 vikas 9686 
  def __repr__(self):
9687 
    L = ['%s=%r' % (key, value)
9688 
      for key, value in self.__dict__.iteritems()]
9689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9690 
 
9691 
  def __eq__(self, other):
9692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9693 
 
9694 
  def __ne__(self, other):
9695 
    return not (self == other)
9696 
 
1996 vikas 9697 
class getTrackerById_args:
1845 vikas 9698 
  """
9699 
  Attributes:
9700 
   - id
9701 
  """
9702 
 
9703 
  thrift_spec = (
9704 
    None, # 0
9705 
    (1, TType.I64, 'id', None, None, ), # 1
9706 
  )
9707 
 
9708 
  def __init__(self, id=None,):
9709 
    self.id = id
9710 
 
9711 
  def read(self, iprot):
9712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9714 
      return
9715 
    iprot.readStructBegin()
9716 
    while True:
9717 
      (fname, ftype, fid) = iprot.readFieldBegin()
9718 
      if ftype == TType.STOP:
9719 
        break
9720 
      if fid == 1:
9721 
        if ftype == TType.I64:
9722 
          self.id = iprot.readI64();
9723 
        else:
9724 
          iprot.skip(ftype)
9725 
      else:
9726 
        iprot.skip(ftype)
9727 
      iprot.readFieldEnd()
9728 
    iprot.readStructEnd()
9729 
 
9730 
  def write(self, oprot):
9731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9733 
      return
1996 vikas 9734 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9735 
    if self.id is not None:
1845 vikas 9736 
      oprot.writeFieldBegin('id', TType.I64, 1)
9737 
      oprot.writeI64(self.id)
9738 
      oprot.writeFieldEnd()
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
3431 rajveer 9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
1845 vikas 9746 
  def __repr__(self):
9747 
    L = ['%s=%r' % (key, value)
9748 
      for key, value in self.__dict__.iteritems()]
9749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9750 
 
9751 
  def __eq__(self, other):
9752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9753 
 
9754 
  def __ne__(self, other):
9755 
    return not (self == other)
9756 
 
9757 
class getTrackerById_result:
9758 
  """
9759 
  Attributes:
9760 
   - success
9761 
   - utx
9762 
  """
9763 
 
9764 
  thrift_spec = (
9765 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9766 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9767 
  )
9768 
 
9769 
  def __init__(self, success=None, utx=None,):
9770 
    self.success = success
9771 
    self.utx = utx
9772 
 
9773 
  def read(self, iprot):
9774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9776 
      return
9777 
    iprot.readStructBegin()
9778 
    while True:
9779 
      (fname, ftype, fid) = iprot.readFieldBegin()
9780 
      if ftype == TType.STOP:
9781 
        break
9782 
      if fid == 0:
9783 
        if ftype == TType.STRUCT:
9784 
          self.success = Tracker()
9785 
          self.success.read(iprot)
9786 
        else:
9787 
          iprot.skip(ftype)
9788 
      elif fid == 1:
9789 
        if ftype == TType.STRUCT:
1996 vikas 9790 
          self.utx = UserAffiliateException()
1845 vikas 9791 
          self.utx.read(iprot)
9792 
        else:
9793 
          iprot.skip(ftype)
9794 
      else:
9795 
        iprot.skip(ftype)
9796 
      iprot.readFieldEnd()
9797 
    iprot.readStructEnd()
9798 
 
9799 
  def write(self, oprot):
9800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9802 
      return
9803 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9804 
    if self.success is not None:
1845 vikas 9805 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9806 
      self.success.write(oprot)
9807 
      oprot.writeFieldEnd()
3431 rajveer 9808 
    if self.utx is not None:
1845 vikas 9809 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9810 
      self.utx.write(oprot)
9811 
      oprot.writeFieldEnd()
9812 
    oprot.writeFieldStop()
9813 
    oprot.writeStructEnd()
9814 
 
3431 rajveer 9815 
  def validate(self):
9816 
    return
9817 
 
9818 
 
1845 vikas 9819 
  def __repr__(self):
9820 
    L = ['%s=%r' % (key, value)
9821 
      for key, value in self.__dict__.iteritems()]
9822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9823 
 
9824 
  def __eq__(self, other):
9825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9826 
 
9827 
  def __ne__(self, other):
9828 
    return not (self == other)
9829 
 
1996 vikas 9830 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9831 
  """
9832 
  Attributes:
1996 vikas 9833 
   - id
1845 vikas 9834 
  """
9835 
 
9836 
  thrift_spec = (
9837 
    None, # 0
1996 vikas 9838 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9839 
  )
9840 
 
1996 vikas 9841 
  def __init__(self, id=None,):
9842 
    self.id = id
1845 vikas 9843 
 
9844 
  def read(self, iprot):
9845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9847 
      return
9848 
    iprot.readStructBegin()
9849 
    while True:
9850 
      (fname, ftype, fid) = iprot.readFieldBegin()
9851 
      if ftype == TType.STOP:
9852 
        break
9853 
      if fid == 1:
9854 
        if ftype == TType.I64:
1996 vikas 9855 
          self.id = iprot.readI64();
1845 vikas 9856 
        else:
9857 
          iprot.skip(ftype)
9858 
      else:
9859 
        iprot.skip(ftype)
9860 
      iprot.readFieldEnd()
9861 
    iprot.readStructEnd()
9862 
 
9863 
  def write(self, oprot):
9864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9866 
      return
1996 vikas 9867 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9868 
    if self.id is not None:
1996 vikas 9869 
      oprot.writeFieldBegin('id', TType.I64, 1)
9870 
      oprot.writeI64(self.id)
1845 vikas 9871 
      oprot.writeFieldEnd()
9872 
    oprot.writeFieldStop()
9873 
    oprot.writeStructEnd()
9874 
 
3431 rajveer 9875 
  def validate(self):
9876 
    return
9877 
 
9878 
 
1845 vikas 9879 
  def __repr__(self):
9880 
    L = ['%s=%r' % (key, value)
9881 
      for key, value in self.__dict__.iteritems()]
9882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9883 
 
9884 
  def __eq__(self, other):
9885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9886 
 
9887 
  def __ne__(self, other):
9888 
    return not (self == other)
9889 
 
1996 vikas 9890 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9891 
  """
9892 
  Attributes:
9893 
   - success
9894 
   - utx
9895 
  """
9896 
 
9897 
  thrift_spec = (
1996 vikas 9898 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9899 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9900 
  )
9901 
 
9902 
  def __init__(self, success=None, utx=None,):
9903 
    self.success = success
9904 
    self.utx = utx
9905 
 
9906 
  def read(self, iprot):
9907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9909 
      return
9910 
    iprot.readStructBegin()
9911 
    while True:
9912 
      (fname, ftype, fid) = iprot.readFieldBegin()
9913 
      if ftype == TType.STOP:
9914 
        break
9915 
      if fid == 0:
9916 
        if ftype == TType.LIST:
9917 
          self.success = []
11592 amit.gupta 9918 
          (_etype128, _size125) = iprot.readListBegin()
9919 
          for _i129 in xrange(_size125):
9920 
            _elem130 = Affiliate()
9921 
            _elem130.read(iprot)
9922 
            self.success.append(_elem130)
1845 vikas 9923 
          iprot.readListEnd()
9924 
        else:
9925 
          iprot.skip(ftype)
9926 
      elif fid == 1:
9927 
        if ftype == TType.STRUCT:
1996 vikas 9928 
          self.utx = UserAffiliateException()
1845 vikas 9929 
          self.utx.read(iprot)
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      else:
9933 
        iprot.skip(ftype)
9934 
      iprot.readFieldEnd()
9935 
    iprot.readStructEnd()
9936 
 
9937 
  def write(self, oprot):
9938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9940 
      return
1996 vikas 9941 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9942 
    if self.success is not None:
1845 vikas 9943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9945 
      for iter131 in self.success:
9946 
        iter131.write(oprot)
1845 vikas 9947 
      oprot.writeListEnd()
9948 
      oprot.writeFieldEnd()
3431 rajveer 9949 
    if self.utx is not None:
1845 vikas 9950 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9951 
      self.utx.write(oprot)
9952 
      oprot.writeFieldEnd()
9953 
    oprot.writeFieldStop()
9954 
    oprot.writeStructEnd()
9955 
 
3431 rajveer 9956 
  def validate(self):
9957 
    return
9958 
 
9959 
 
1845 vikas 9960 
  def __repr__(self):
9961 
    L = ['%s=%r' % (key, value)
9962 
      for key, value in self.__dict__.iteritems()]
9963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9964 
 
9965 
  def __eq__(self, other):
9966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9967 
 
9968 
  def __ne__(self, other):
9969 
    return not (self == other)
9970 
 
9971 
class addTrackLog_args:
9972 
  """
9973 
  Attributes:
1996 vikas 9974 
   - affiliateId
1845 vikas 9975 
   - userId
9976 
   - event
9977 
   - url
9978 
   - data
1859 vikas 9979 
   - addedOn
1845 vikas 9980 
  """
9981 
 
9982 
  thrift_spec = (
9983 
    None, # 0
1996 vikas 9984 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9985 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9986 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9987 
    (4, TType.STRING, 'url', None, None, ), # 4
9988 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9989 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9990 
  )
9991 
 
1996 vikas 9992 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9993 
    self.affiliateId = affiliateId
1845 vikas 9994 
    self.userId = userId
9995 
    self.event = event
9996 
    self.url = url
9997 
    self.data = data
1859 vikas 9998 
    self.addedOn = addedOn
1845 vikas 9999 
 
10000 
  def read(self, iprot):
10001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10003 
      return
10004 
    iprot.readStructBegin()
10005 
    while True:
10006 
      (fname, ftype, fid) = iprot.readFieldBegin()
10007 
      if ftype == TType.STOP:
10008 
        break
10009 
      if fid == 1:
10010 
        if ftype == TType.I64:
1996 vikas 10011 
          self.affiliateId = iprot.readI64();
1845 vikas 10012 
        else:
10013 
          iprot.skip(ftype)
10014 
      elif fid == 2:
10015 
        if ftype == TType.I64:
10016 
          self.userId = iprot.readI64();
10017 
        else:
10018 
          iprot.skip(ftype)
10019 
      elif fid == 3:
3378 vikas 10020 
        if ftype == TType.I32:
10021 
          self.event = iprot.readI32();
1845 vikas 10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 4:
10025 
        if ftype == TType.STRING:
10026 
          self.url = iprot.readString();
10027 
        else:
10028 
          iprot.skip(ftype)
10029 
      elif fid == 5:
10030 
        if ftype == TType.STRING:
10031 
          self.data = iprot.readString();
10032 
        else:
10033 
          iprot.skip(ftype)
1859 vikas 10034 
      elif fid == 6:
10035 
        if ftype == TType.I64:
10036 
          self.addedOn = iprot.readI64();
10037 
        else:
10038 
          iprot.skip(ftype)
1845 vikas 10039 
      else:
10040 
        iprot.skip(ftype)
10041 
      iprot.readFieldEnd()
10042 
    iprot.readStructEnd()
10043 
 
10044 
  def write(self, oprot):
10045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10047 
      return
10048 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10049 
    if self.affiliateId is not None:
1996 vikas 10050 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10051 
      oprot.writeI64(self.affiliateId)
1845 vikas 10052 
      oprot.writeFieldEnd()
3431 rajveer 10053 
    if self.userId is not None:
1845 vikas 10054 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10055 
      oprot.writeI64(self.userId)
10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.event is not None:
3378 vikas 10058 
      oprot.writeFieldBegin('event', TType.I32, 3)
10059 
      oprot.writeI32(self.event)
1845 vikas 10060 
      oprot.writeFieldEnd()
3431 rajveer 10061 
    if self.url is not None:
1845 vikas 10062 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10063 
      oprot.writeString(self.url)
10064 
      oprot.writeFieldEnd()
3431 rajveer 10065 
    if self.data is not None:
1845 vikas 10066 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10067 
      oprot.writeString(self.data)
10068 
      oprot.writeFieldEnd()
3431 rajveer 10069 
    if self.addedOn is not None:
1859 vikas 10070 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10071 
      oprot.writeI64(self.addedOn)
10072 
      oprot.writeFieldEnd()
1845 vikas 10073 
    oprot.writeFieldStop()
10074 
    oprot.writeStructEnd()
10075 
 
3431 rajveer 10076 
  def validate(self):
10077 
    return
10078 
 
10079 
 
1845 vikas 10080 
  def __repr__(self):
10081 
    L = ['%s=%r' % (key, value)
10082 
      for key, value in self.__dict__.iteritems()]
10083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10084 
 
10085 
  def __eq__(self, other):
10086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10087 
 
10088 
  def __ne__(self, other):
10089 
    return not (self == other)
10090 
 
10091 
class addTrackLog_result:
10092 
  """
10093 
  Attributes:
10094 
   - success
10095 
   - utx
10096 
  """
10097 
 
10098 
  thrift_spec = (
10099 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10100 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10101 
  )
10102 
 
10103 
  def __init__(self, success=None, utx=None,):
10104 
    self.success = success
10105 
    self.utx = utx
10106 
 
10107 
  def read(self, iprot):
10108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10110 
      return
10111 
    iprot.readStructBegin()
10112 
    while True:
10113 
      (fname, ftype, fid) = iprot.readFieldBegin()
10114 
      if ftype == TType.STOP:
10115 
        break
10116 
      if fid == 0:
10117 
        if ftype == TType.I64:
10118 
          self.success = iprot.readI64();
10119 
        else:
10120 
          iprot.skip(ftype)
10121 
      elif fid == 1:
10122 
        if ftype == TType.STRUCT:
1996 vikas 10123 
          self.utx = UserAffiliateException()
1845 vikas 10124 
          self.utx.read(iprot)
10125 
        else:
10126 
          iprot.skip(ftype)
10127 
      else:
10128 
        iprot.skip(ftype)
10129 
      iprot.readFieldEnd()
10130 
    iprot.readStructEnd()
10131 
 
10132 
  def write(self, oprot):
10133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10135 
      return
10136 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10137 
    if self.success is not None:
1845 vikas 10138 
      oprot.writeFieldBegin('success', TType.I64, 0)
10139 
      oprot.writeI64(self.success)
10140 
      oprot.writeFieldEnd()
3431 rajveer 10141 
    if self.utx is not None:
1845 vikas 10142 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10143 
      self.utx.write(oprot)
10144 
      oprot.writeFieldEnd()
10145 
    oprot.writeFieldStop()
10146 
    oprot.writeStructEnd()
10147 
 
3431 rajveer 10148 
  def validate(self):
10149 
    return
10150 
 
10151 
 
1845 vikas 10152 
  def __repr__(self):
10153 
    L = ['%s=%r' % (key, value)
10154 
      for key, value in self.__dict__.iteritems()]
10155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10156 
 
10157 
  def __eq__(self, other):
10158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10159 
 
10160 
  def __ne__(self, other):
10161 
    return not (self == other)
10162 
 
10163 
class getTrackLogById_args:
10164 
  """
10165 
  Attributes:
10166 
   - id
10167 
  """
10168 
 
10169 
  thrift_spec = (
10170 
    None, # 0
10171 
    (1, TType.I64, 'id', None, None, ), # 1
10172 
  )
10173 
 
10174 
  def __init__(self, id=None,):
10175 
    self.id = id
10176 
 
10177 
  def read(self, iprot):
10178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10180 
      return
10181 
    iprot.readStructBegin()
10182 
    while True:
10183 
      (fname, ftype, fid) = iprot.readFieldBegin()
10184 
      if ftype == TType.STOP:
10185 
        break
10186 
      if fid == 1:
10187 
        if ftype == TType.I64:
10188 
          self.id = iprot.readI64();
10189 
        else:
10190 
          iprot.skip(ftype)
10191 
      else:
10192 
        iprot.skip(ftype)
10193 
      iprot.readFieldEnd()
10194 
    iprot.readStructEnd()
10195 
 
10196 
  def write(self, oprot):
10197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10199 
      return
10200 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10201 
    if self.id is not None:
1845 vikas 10202 
      oprot.writeFieldBegin('id', TType.I64, 1)
10203 
      oprot.writeI64(self.id)
10204 
      oprot.writeFieldEnd()
10205 
    oprot.writeFieldStop()
10206 
    oprot.writeStructEnd()
10207 
 
3431 rajveer 10208 
  def validate(self):
10209 
    return
10210 
 
10211 
 
1845 vikas 10212 
  def __repr__(self):
10213 
    L = ['%s=%r' % (key, value)
10214 
      for key, value in self.__dict__.iteritems()]
10215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10216 
 
10217 
  def __eq__(self, other):
10218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10219 
 
10220 
  def __ne__(self, other):
10221 
    return not (self == other)
10222 
 
10223 
class getTrackLogById_result:
10224 
  """
10225 
  Attributes:
10226 
   - success
10227 
   - utx
10228 
  """
10229 
 
10230 
  thrift_spec = (
10231 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10232 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10233 
  )
10234 
 
10235 
  def __init__(self, success=None, utx=None,):
10236 
    self.success = success
10237 
    self.utx = utx
10238 
 
10239 
  def read(self, iprot):
10240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10242 
      return
10243 
    iprot.readStructBegin()
10244 
    while True:
10245 
      (fname, ftype, fid) = iprot.readFieldBegin()
10246 
      if ftype == TType.STOP:
10247 
        break
10248 
      if fid == 0:
10249 
        if ftype == TType.STRUCT:
10250 
          self.success = TrackLog()
10251 
          self.success.read(iprot)
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 1:
10255 
        if ftype == TType.STRUCT:
1996 vikas 10256 
          self.utx = UserAffiliateException()
1845 vikas 10257 
          self.utx.read(iprot)
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      else:
10261 
        iprot.skip(ftype)
10262 
      iprot.readFieldEnd()
10263 
    iprot.readStructEnd()
10264 
 
10265 
  def write(self, oprot):
10266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10268 
      return
10269 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10270 
    if self.success is not None:
1845 vikas 10271 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10272 
      self.success.write(oprot)
10273 
      oprot.writeFieldEnd()
3431 rajveer 10274 
    if self.utx is not None:
1845 vikas 10275 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10276 
      self.utx.write(oprot)
10277 
      oprot.writeFieldEnd()
10278 
    oprot.writeFieldStop()
10279 
    oprot.writeStructEnd()
10280 
 
3431 rajveer 10281 
  def validate(self):
10282 
    return
10283 
 
10284 
 
1845 vikas 10285 
  def __repr__(self):
10286 
    L = ['%s=%r' % (key, value)
10287 
      for key, value in self.__dict__.iteritems()]
10288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10289 
 
10290 
  def __eq__(self, other):
10291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10292 
 
10293 
  def __ne__(self, other):
10294 
    return not (self == other)
10295 
 
1996 vikas 10296 
class getTrackLogsByAffiliate_args:
1845 vikas 10297 
  """
10298 
  Attributes:
1996 vikas 10299 
   - affiliateId
3293 vikas 10300 
   - startDate
10301 
   - endDate
1845 vikas 10302 
  """
10303 
 
10304 
  thrift_spec = (
10305 
    None, # 0
1996 vikas 10306 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10307 
    (2, TType.I64, 'startDate', None, None, ), # 2
10308 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10309 
  )
10310 
 
3293 vikas 10311 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10312 
    self.affiliateId = affiliateId
3293 vikas 10313 
    self.startDate = startDate
10314 
    self.endDate = endDate
1845 vikas 10315 
 
10316 
  def read(self, iprot):
10317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10319 
      return
10320 
    iprot.readStructBegin()
10321 
    while True:
10322 
      (fname, ftype, fid) = iprot.readFieldBegin()
10323 
      if ftype == TType.STOP:
10324 
        break
10325 
      if fid == 1:
10326 
        if ftype == TType.I64:
1996 vikas 10327 
          self.affiliateId = iprot.readI64();
1845 vikas 10328 
        else:
10329 
          iprot.skip(ftype)
3293 vikas 10330 
      elif fid == 2:
10331 
        if ftype == TType.I64:
10332 
          self.startDate = iprot.readI64();
10333 
        else:
10334 
          iprot.skip(ftype)
10335 
      elif fid == 3:
10336 
        if ftype == TType.I64:
10337 
          self.endDate = iprot.readI64();
10338 
        else:
10339 
          iprot.skip(ftype)
1845 vikas 10340 
      else:
10341 
        iprot.skip(ftype)
10342 
      iprot.readFieldEnd()
10343 
    iprot.readStructEnd()
10344 
 
10345 
  def write(self, oprot):
10346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10348 
      return
1996 vikas 10349 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10350 
    if self.affiliateId is not None:
1996 vikas 10351 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10352 
      oprot.writeI64(self.affiliateId)
1845 vikas 10353 
      oprot.writeFieldEnd()
3431 rajveer 10354 
    if self.startDate is not None:
3293 vikas 10355 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10356 
      oprot.writeI64(self.startDate)
10357 
      oprot.writeFieldEnd()
3431 rajveer 10358 
    if self.endDate is not None:
3293 vikas 10359 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10360 
      oprot.writeI64(self.endDate)
10361 
      oprot.writeFieldEnd()
1845 vikas 10362 
    oprot.writeFieldStop()
10363 
    oprot.writeStructEnd()
10364 
 
3431 rajveer 10365 
  def validate(self):
10366 
    return
10367 
 
10368 
 
1845 vikas 10369 
  def __repr__(self):
10370 
    L = ['%s=%r' % (key, value)
10371 
      for key, value in self.__dict__.iteritems()]
10372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10373 
 
10374 
  def __eq__(self, other):
10375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10376 
 
10377 
  def __ne__(self, other):
10378 
    return not (self == other)
10379 
 
1996 vikas 10380 
class getTrackLogsByAffiliate_result:
1845 vikas 10381 
  """
10382 
  Attributes:
10383 
   - success
10384 
   - utx
10385 
  """
10386 
 
10387 
  thrift_spec = (
10388 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10389 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10390 
  )
10391 
 
10392 
  def __init__(self, success=None, utx=None,):
10393 
    self.success = success
10394 
    self.utx = utx
10395 
 
10396 
  def read(self, iprot):
10397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10399 
      return
10400 
    iprot.readStructBegin()
10401 
    while True:
10402 
      (fname, ftype, fid) = iprot.readFieldBegin()
10403 
      if ftype == TType.STOP:
10404 
        break
10405 
      if fid == 0:
10406 
        if ftype == TType.LIST:
10407 
          self.success = []
11592 amit.gupta 10408 
          (_etype135, _size132) = iprot.readListBegin()
10409 
          for _i136 in xrange(_size132):
10410 
            _elem137 = TrackLog()
10411 
            _elem137.read(iprot)
10412 
            self.success.append(_elem137)
1845 vikas 10413 
          iprot.readListEnd()
10414 
        else:
10415 
          iprot.skip(ftype)
10416 
      elif fid == 1:
10417 
        if ftype == TType.STRUCT:
1996 vikas 10418 
          self.utx = UserAffiliateException()
1845 vikas 10419 
          self.utx.read(iprot)
10420 
        else:
10421 
          iprot.skip(ftype)
10422 
      else:
10423 
        iprot.skip(ftype)
10424 
      iprot.readFieldEnd()
10425 
    iprot.readStructEnd()
10426 
 
10427 
  def write(self, oprot):
10428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10430 
      return
1996 vikas 10431 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10432 
    if self.success is not None:
1845 vikas 10433 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10434 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10435 
      for iter138 in self.success:
10436 
        iter138.write(oprot)
1845 vikas 10437 
      oprot.writeListEnd()
10438 
      oprot.writeFieldEnd()
3431 rajveer 10439 
    if self.utx is not None:
1845 vikas 10440 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10441 
      self.utx.write(oprot)
10442 
      oprot.writeFieldEnd()
10443 
    oprot.writeFieldStop()
10444 
    oprot.writeStructEnd()
10445 
 
3431 rajveer 10446 
  def validate(self):
10447 
    return
10448 
 
10449 
 
1845 vikas 10450 
  def __repr__(self):
10451 
    L = ['%s=%r' % (key, value)
10452 
      for key, value in self.__dict__.iteritems()]
10453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10454 
 
10455 
  def __eq__(self, other):
10456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10457 
 
10458 
  def __ne__(self, other):
10459 
    return not (self == other)
10460 
 
10461 
class getTrackLogsByUser_args:
10462 
  """
10463 
  Attributes:
10464 
   - userId
10465 
  """
10466 
 
10467 
  thrift_spec = (
10468 
    None, # 0
10469 
    (1, TType.I64, 'userId', None, None, ), # 1
10470 
  )
10471 
 
10472 
  def __init__(self, userId=None,):
10473 
    self.userId = userId
10474 
 
10475 
  def read(self, iprot):
10476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10478 
      return
10479 
    iprot.readStructBegin()
10480 
    while True:
10481 
      (fname, ftype, fid) = iprot.readFieldBegin()
10482 
      if ftype == TType.STOP:
10483 
        break
10484 
      if fid == 1:
10485 
        if ftype == TType.I64:
10486 
          self.userId = iprot.readI64();
10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      else:
10490 
        iprot.skip(ftype)
10491 
      iprot.readFieldEnd()
10492 
    iprot.readStructEnd()
10493 
 
10494 
  def write(self, oprot):
10495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10497 
      return
10498 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10499 
    if self.userId is not None:
1845 vikas 10500 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10501 
      oprot.writeI64(self.userId)
10502 
      oprot.writeFieldEnd()
10503 
    oprot.writeFieldStop()
10504 
    oprot.writeStructEnd()
10505 
 
3431 rajveer 10506 
  def validate(self):
10507 
    return
10508 
 
10509 
 
1845 vikas 10510 
  def __repr__(self):
10511 
    L = ['%s=%r' % (key, value)
10512 
      for key, value in self.__dict__.iteritems()]
10513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10514 
 
10515 
  def __eq__(self, other):
10516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10517 
 
10518 
  def __ne__(self, other):
10519 
    return not (self == other)
10520 
 
10521 
class getTrackLogsByUser_result:
10522 
  """
10523 
  Attributes:
10524 
   - success
10525 
   - utx
10526 
  """
10527 
 
10528 
  thrift_spec = (
10529 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10530 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10531 
  )
10532 
 
10533 
  def __init__(self, success=None, utx=None,):
10534 
    self.success = success
10535 
    self.utx = utx
10536 
 
10537 
  def read(self, iprot):
10538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10540 
      return
10541 
    iprot.readStructBegin()
10542 
    while True:
10543 
      (fname, ftype, fid) = iprot.readFieldBegin()
10544 
      if ftype == TType.STOP:
10545 
        break
10546 
      if fid == 0:
10547 
        if ftype == TType.LIST:
10548 
          self.success = []
11592 amit.gupta 10549 
          (_etype142, _size139) = iprot.readListBegin()
10550 
          for _i143 in xrange(_size139):
10551 
            _elem144 = TrackLog()
10552 
            _elem144.read(iprot)
10553 
            self.success.append(_elem144)
1845 vikas 10554 
          iprot.readListEnd()
10555 
        else:
10556 
          iprot.skip(ftype)
10557 
      elif fid == 1:
10558 
        if ftype == TType.STRUCT:
1996 vikas 10559 
          self.utx = UserAffiliateException()
1845 vikas 10560 
          self.utx.read(iprot)
10561 
        else:
10562 
          iprot.skip(ftype)
10563 
      else:
10564 
        iprot.skip(ftype)
10565 
      iprot.readFieldEnd()
10566 
    iprot.readStructEnd()
10567 
 
10568 
  def write(self, oprot):
10569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10571 
      return
10572 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10573 
    if self.success is not None:
1845 vikas 10574 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10575 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10576 
      for iter145 in self.success:
10577 
        iter145.write(oprot)
1845 vikas 10578 
      oprot.writeListEnd()
10579 
      oprot.writeFieldEnd()
3431 rajveer 10580 
    if self.utx is not None:
1845 vikas 10581 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10582 
      self.utx.write(oprot)
10583 
      oprot.writeFieldEnd()
10584 
    oprot.writeFieldStop()
10585 
    oprot.writeStructEnd()
10586 
 
3431 rajveer 10587 
  def validate(self):
10588 
    return
10589 
 
10590 
 
1845 vikas 10591 
  def __repr__(self):
10592 
    L = ['%s=%r' % (key, value)
10593 
      for key, value in self.__dict__.iteritems()]
10594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10595 
 
10596 
  def __eq__(self, other):
10597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10598 
 
10599 
  def __ne__(self, other):
10600 
    return not (self == other)
10601 
 
10602 
class getTrackLogs_args:
10603 
  """
10604 
  Attributes:
10605 
   - userId
10606 
   - event
10607 
   - url
10608 
  """
10609 
 
10610 
  thrift_spec = (
10611 
    None, # 0
1996 vikas 10612 
    (1, TType.I64, 'userId', None, None, ), # 1
10613 
    (2, TType.STRING, 'event', None, None, ), # 2
10614 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10615 
  )
10616 
 
1996 vikas 10617 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10618 
    self.userId = userId
10619 
    self.event = event
10620 
    self.url = url
10621 
 
10622 
  def read(self, iprot):
10623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10625 
      return
10626 
    iprot.readStructBegin()
10627 
    while True:
10628 
      (fname, ftype, fid) = iprot.readFieldBegin()
10629 
      if ftype == TType.STOP:
10630 
        break
10631 
      if fid == 1:
10632 
        if ftype == TType.I64:
1996 vikas 10633 
          self.userId = iprot.readI64();
1845 vikas 10634 
        else:
10635 
          iprot.skip(ftype)
10636 
      elif fid == 2:
10637 
        if ftype == TType.STRING:
10638 
          self.event = iprot.readString();
10639 
        else:
10640 
          iprot.skip(ftype)
1996 vikas 10641 
      elif fid == 3:
1845 vikas 10642 
        if ftype == TType.STRING:
10643 
          self.url = iprot.readString();
10644 
        else:
10645 
          iprot.skip(ftype)
10646 
      else:
10647 
        iprot.skip(ftype)
10648 
      iprot.readFieldEnd()
10649 
    iprot.readStructEnd()
10650 
 
10651 
  def write(self, oprot):
10652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10654 
      return
10655 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10656 
    if self.userId is not None:
1996 vikas 10657 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10658 
      oprot.writeI64(self.userId)
10659 
      oprot.writeFieldEnd()
3431 rajveer 10660 
    if self.event is not None:
1996 vikas 10661 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10662 
      oprot.writeString(self.event)
10663 
      oprot.writeFieldEnd()
3431 rajveer 10664 
    if self.url is not None:
1996 vikas 10665 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10666 
      oprot.writeString(self.url)
10667 
      oprot.writeFieldEnd()
10668 
    oprot.writeFieldStop()
10669 
    oprot.writeStructEnd()
10670 
 
3431 rajveer 10671 
  def validate(self):
10672 
    return
10673 
 
10674 
 
1845 vikas 10675 
  def __repr__(self):
10676 
    L = ['%s=%r' % (key, value)
10677 
      for key, value in self.__dict__.iteritems()]
10678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10679 
 
10680 
  def __eq__(self, other):
10681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10682 
 
10683 
  def __ne__(self, other):
10684 
    return not (self == other)
10685 
 
10686 
class getTrackLogs_result:
10687 
  """
10688 
  Attributes:
10689 
   - success
10690 
   - utx
10691 
  """
10692 
 
10693 
  thrift_spec = (
10694 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10695 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10696 
  )
10697 
 
10698 
  def __init__(self, success=None, utx=None,):
10699 
    self.success = success
10700 
    self.utx = utx
10701 
 
10702 
  def read(self, iprot):
10703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10705 
      return
10706 
    iprot.readStructBegin()
10707 
    while True:
10708 
      (fname, ftype, fid) = iprot.readFieldBegin()
10709 
      if ftype == TType.STOP:
10710 
        break
10711 
      if fid == 0:
10712 
        if ftype == TType.LIST:
10713 
          self.success = []
11592 amit.gupta 10714 
          (_etype149, _size146) = iprot.readListBegin()
10715 
          for _i150 in xrange(_size146):
10716 
            _elem151 = TrackLog()
10717 
            _elem151.read(iprot)
10718 
            self.success.append(_elem151)
1845 vikas 10719 
          iprot.readListEnd()
10720 
        else:
10721 
          iprot.skip(ftype)
10722 
      elif fid == 1:
10723 
        if ftype == TType.STRUCT:
1996 vikas 10724 
          self.utx = UserAffiliateException()
1845 vikas 10725 
          self.utx.read(iprot)
10726 
        else:
10727 
          iprot.skip(ftype)
10728 
      else:
10729 
        iprot.skip(ftype)
10730 
      iprot.readFieldEnd()
10731 
    iprot.readStructEnd()
10732 
 
10733 
  def write(self, oprot):
10734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10736 
      return
10737 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10738 
    if self.success is not None:
1845 vikas 10739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10741 
      for iter152 in self.success:
10742 
        iter152.write(oprot)
1845 vikas 10743 
      oprot.writeListEnd()
10744 
      oprot.writeFieldEnd()
3431 rajveer 10745 
    if self.utx is not None:
1845 vikas 10746 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10747 
      self.utx.write(oprot)
10748 
      oprot.writeFieldEnd()
10749 
    oprot.writeFieldStop()
10750 
    oprot.writeStructEnd()
10751 
 
3431 rajveer 10752 
  def validate(self):
10753 
    return
10754 
 
10755 
 
1845 vikas 10756 
  def __repr__(self):
10757 
    L = ['%s=%r' % (key, value)
10758 
      for key, value in self.__dict__.iteritems()]
10759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10760 
 
10761 
  def __eq__(self, other):
10762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10763 
 
10764 
  def __ne__(self, other):
10765 
    return not (self == other)
10766 
 
559 chandransh 10767 
class getCurrentCart_args:
94 ashish 10768 
  """
10769 
  Attributes:
559 chandransh 10770 
   - userId
10771 
  """
10772 
 
10773 
  thrift_spec = (
10774 
    None, # 0
10775 
    (1, TType.I64, 'userId', None, None, ), # 1
10776 
  )
10777 
 
10778 
  def __init__(self, userId=None,):
10779 
    self.userId = userId
10780 
 
10781 
  def read(self, iprot):
10782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10784 
      return
10785 
    iprot.readStructBegin()
10786 
    while True:
10787 
      (fname, ftype, fid) = iprot.readFieldBegin()
10788 
      if ftype == TType.STOP:
10789 
        break
10790 
      if fid == 1:
10791 
        if ftype == TType.I64:
10792 
          self.userId = iprot.readI64();
10793 
        else:
10794 
          iprot.skip(ftype)
10795 
      else:
10796 
        iprot.skip(ftype)
10797 
      iprot.readFieldEnd()
10798 
    iprot.readStructEnd()
10799 
 
10800 
  def write(self, oprot):
10801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10803 
      return
10804 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10805 
    if self.userId is not None:
559 chandransh 10806 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10807 
      oprot.writeI64(self.userId)
10808 
      oprot.writeFieldEnd()
10809 
    oprot.writeFieldStop()
10810 
    oprot.writeStructEnd()
10811 
 
3431 rajveer 10812 
  def validate(self):
10813 
    return
10814 
 
10815 
 
559 chandransh 10816 
  def __repr__(self):
10817 
    L = ['%s=%r' % (key, value)
10818 
      for key, value in self.__dict__.iteritems()]
10819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10820 
 
10821 
  def __eq__(self, other):
10822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10823 
 
10824 
  def __ne__(self, other):
10825 
    return not (self == other)
10826 
 
10827 
class getCurrentCart_result:
10828 
  """
10829 
  Attributes:
94 ashish 10830 
   - success
559 chandransh 10831 
   - scx
94 ashish 10832 
  """
10833 
 
10834 
  thrift_spec = (
559 chandransh 10835 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10836 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10837 
  )
10838 
 
559 chandransh 10839 
  def __init__(self, success=None, scx=None,):
94 ashish 10840 
    self.success = success
559 chandransh 10841 
    self.scx = scx
94 ashish 10842 
 
10843 
  def read(self, iprot):
10844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10846 
      return
10847 
    iprot.readStructBegin()
10848 
    while True:
10849 
      (fname, ftype, fid) = iprot.readFieldBegin()
10850 
      if ftype == TType.STOP:
10851 
        break
10852 
      if fid == 0:
559 chandransh 10853 
        if ftype == TType.STRUCT:
10854 
          self.success = Cart()
10855 
          self.success.read(iprot)
94 ashish 10856 
        else:
10857 
          iprot.skip(ftype)
10858 
      elif fid == 1:
10859 
        if ftype == TType.STRUCT:
559 chandransh 10860 
          self.scx = ShoppingCartException()
10861 
          self.scx.read(iprot)
94 ashish 10862 
        else:
10863 
          iprot.skip(ftype)
10864 
      else:
10865 
        iprot.skip(ftype)
10866 
      iprot.readFieldEnd()
10867 
    iprot.readStructEnd()
10868 
 
10869 
  def write(self, oprot):
10870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10872 
      return
559 chandransh 10873 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10874 
    if self.success is not None:
559 chandransh 10875 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10876 
      self.success.write(oprot)
94 ashish 10877 
      oprot.writeFieldEnd()
3431 rajveer 10878 
    if self.scx is not None:
559 chandransh 10879 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10880 
      self.scx.write(oprot)
94 ashish 10881 
      oprot.writeFieldEnd()
10882 
    oprot.writeFieldStop()
10883 
    oprot.writeStructEnd()
10884 
 
3431 rajveer 10885 
  def validate(self):
10886 
    return
10887 
 
10888 
 
94 ashish 10889 
  def __repr__(self):
10890 
    L = ['%s=%r' % (key, value)
10891 
      for key, value in self.__dict__.iteritems()]
10892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10893 
 
10894 
  def __eq__(self, other):
10895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10896 
 
10897 
  def __ne__(self, other):
10898 
    return not (self == other)
10899 
 
559 chandransh 10900 
class getCart_args:
504 rajveer 10901 
  """
10902 
  Attributes:
559 chandransh 10903 
   - cartId
504 rajveer 10904 
  """
10905 
 
10906 
  thrift_spec = (
10907 
    None, # 0
559 chandransh 10908 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10909 
  )
10910 
 
559 chandransh 10911 
  def __init__(self, cartId=None,):
10912 
    self.cartId = cartId
504 rajveer 10913 
 
10914 
  def read(self, iprot):
10915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10917 
      return
10918 
    iprot.readStructBegin()
10919 
    while True:
10920 
      (fname, ftype, fid) = iprot.readFieldBegin()
10921 
      if ftype == TType.STOP:
10922 
        break
10923 
      if fid == 1:
10924 
        if ftype == TType.I64:
559 chandransh 10925 
          self.cartId = iprot.readI64();
504 rajveer 10926 
        else:
10927 
          iprot.skip(ftype)
10928 
      else:
10929 
        iprot.skip(ftype)
10930 
      iprot.readFieldEnd()
10931 
    iprot.readStructEnd()
10932 
 
10933 
  def write(self, oprot):
10934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10936 
      return
559 chandransh 10937 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10938 
    if self.cartId is not None:
559 chandransh 10939 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10940 
      oprot.writeI64(self.cartId)
504 rajveer 10941 
      oprot.writeFieldEnd()
10942 
    oprot.writeFieldStop()
10943 
    oprot.writeStructEnd()
10944 
 
3431 rajveer 10945 
  def validate(self):
10946 
    return
10947 
 
10948 
 
504 rajveer 10949 
  def __repr__(self):
10950 
    L = ['%s=%r' % (key, value)
10951 
      for key, value in self.__dict__.iteritems()]
10952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10953 
 
10954 
  def __eq__(self, other):
10955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10956 
 
10957 
  def __ne__(self, other):
10958 
    return not (self == other)
10959 
 
559 chandransh 10960 
class getCart_result:
504 rajveer 10961 
  """
10962 
  Attributes:
10963 
   - success
559 chandransh 10964 
   - scx
504 rajveer 10965 
  """
10966 
 
10967 
  thrift_spec = (
559 chandransh 10968 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10969 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10970 
  )
10971 
 
559 chandransh 10972 
  def __init__(self, success=None, scx=None,):
504 rajveer 10973 
    self.success = success
559 chandransh 10974 
    self.scx = scx
504 rajveer 10975 
 
10976 
  def read(self, iprot):
10977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10979 
      return
10980 
    iprot.readStructBegin()
10981 
    while True:
10982 
      (fname, ftype, fid) = iprot.readFieldBegin()
10983 
      if ftype == TType.STOP:
10984 
        break
10985 
      if fid == 0:
559 chandransh 10986 
        if ftype == TType.STRUCT:
10987 
          self.success = Cart()
10988 
          self.success.read(iprot)
504 rajveer 10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      elif fid == 1:
10992 
        if ftype == TType.STRUCT:
559 chandransh 10993 
          self.scx = ShoppingCartException()
10994 
          self.scx.read(iprot)
504 rajveer 10995 
        else:
10996 
          iprot.skip(ftype)
10997 
      else:
10998 
        iprot.skip(ftype)
10999 
      iprot.readFieldEnd()
11000 
    iprot.readStructEnd()
11001 
 
11002 
  def write(self, oprot):
11003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11005 
      return
559 chandransh 11006 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 11007 
    if self.success is not None:
559 chandransh 11008 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11009 
      self.success.write(oprot)
504 rajveer 11010 
      oprot.writeFieldEnd()
3431 rajveer 11011 
    if self.scx is not None:
559 chandransh 11012 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11013 
      self.scx.write(oprot)
504 rajveer 11014 
      oprot.writeFieldEnd()
11015 
    oprot.writeFieldStop()
11016 
    oprot.writeStructEnd()
11017 
 
3431 rajveer 11018 
  def validate(self):
11019 
    return
11020 
 
11021 
 
504 rajveer 11022 
  def __repr__(self):
11023 
    L = ['%s=%r' % (key, value)
11024 
      for key, value in self.__dict__.iteritems()]
11025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11026 
 
11027 
  def __eq__(self, other):
11028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11029 
 
11030 
  def __ne__(self, other):
11031 
    return not (self == other)
11032 
 
559 chandransh 11033 
class getCartsByTime_args:
11034 
  """
11035 
  Attributes:
11036 
   - from_time
11037 
   - to_time
11038 
   - status
11039 
  """
11040 
 
11041 
  thrift_spec = (
11042 
    None, # 0
11043 
    (1, TType.I64, 'from_time', None, None, ), # 1
11044 
    (2, TType.I64, 'to_time', None, None, ), # 2
11045 
    (3, TType.I32, 'status', None, None, ), # 3
11046 
  )
11047 
 
11048 
  def __init__(self, from_time=None, to_time=None, status=None,):
11049 
    self.from_time = from_time
11050 
    self.to_time = to_time
11051 
    self.status = status
11052 
 
11053 
  def read(self, iprot):
11054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11056 
      return
11057 
    iprot.readStructBegin()
11058 
    while True:
11059 
      (fname, ftype, fid) = iprot.readFieldBegin()
11060 
      if ftype == TType.STOP:
11061 
        break
11062 
      if fid == 1:
94 ashish 11063 
        if ftype == TType.I64:
559 chandransh 11064 
          self.from_time = iprot.readI64();
94 ashish 11065 
        else:
11066 
          iprot.skip(ftype)
122 ashish 11067 
      elif fid == 2:
559 chandransh 11068 
        if ftype == TType.I64:
11069 
          self.to_time = iprot.readI64();
122 ashish 11070 
        else:
11071 
          iprot.skip(ftype)
559 chandransh 11072 
      elif fid == 3:
11073 
        if ftype == TType.I32:
11074 
          self.status = iprot.readI32();
11075 
        else:
11076 
          iprot.skip(ftype)
94 ashish 11077 
      else:
11078 
        iprot.skip(ftype)
11079 
      iprot.readFieldEnd()
11080 
    iprot.readStructEnd()
11081 
 
11082 
  def write(self, oprot):
11083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11085 
      return
559 chandransh 11086 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11087 
    if self.from_time is not None:
559 chandransh 11088 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11089 
      oprot.writeI64(self.from_time)
94 ashish 11090 
      oprot.writeFieldEnd()
3431 rajveer 11091 
    if self.to_time is not None:
559 chandransh 11092 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11093 
      oprot.writeI64(self.to_time)
122 ashish 11094 
      oprot.writeFieldEnd()
3431 rajveer 11095 
    if self.status is not None:
559 chandransh 11096 
      oprot.writeFieldBegin('status', TType.I32, 3)
11097 
      oprot.writeI32(self.status)
11098 
      oprot.writeFieldEnd()
94 ashish 11099 
    oprot.writeFieldStop()
11100 
    oprot.writeStructEnd()
11101 
 
3431 rajveer 11102 
  def validate(self):
11103 
    return
11104 
 
11105 
 
94 ashish 11106 
  def __repr__(self):
11107 
    L = ['%s=%r' % (key, value)
11108 
      for key, value in self.__dict__.iteritems()]
11109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11110 
 
11111 
  def __eq__(self, other):
11112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11113 
 
11114 
  def __ne__(self, other):
11115 
    return not (self == other)
11116 
 
559 chandransh 11117 
class getCartsByTime_result:
94 ashish 11118 
  """
11119 
  Attributes:
11120 
   - success
559 chandransh 11121 
   - scx
94 ashish 11122 
  """
11123 
 
11124 
  thrift_spec = (
559 chandransh 11125 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11126 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11127 
  )
11128 
 
559 chandransh 11129 
  def __init__(self, success=None, scx=None,):
94 ashish 11130 
    self.success = success
559 chandransh 11131 
    self.scx = scx
94 ashish 11132 
 
11133 
  def read(self, iprot):
11134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11136 
      return
11137 
    iprot.readStructBegin()
11138 
    while True:
11139 
      (fname, ftype, fid) = iprot.readFieldBegin()
11140 
      if ftype == TType.STOP:
11141 
        break
11142 
      if fid == 0:
559 chandransh 11143 
        if ftype == TType.LIST:
11144 
          self.success = []
11592 amit.gupta 11145 
          (_etype156, _size153) = iprot.readListBegin()
11146 
          for _i157 in xrange(_size153):
11147 
            _elem158 = Cart()
11148 
            _elem158.read(iprot)
11149 
            self.success.append(_elem158)
559 chandransh 11150 
          iprot.readListEnd()
94 ashish 11151 
        else:
11152 
          iprot.skip(ftype)
11153 
      elif fid == 1:
11154 
        if ftype == TType.STRUCT:
559 chandransh 11155 
          self.scx = ShoppingCartException()
11156 
          self.scx.read(iprot)
94 ashish 11157 
        else:
11158 
          iprot.skip(ftype)
11159 
      else:
11160 
        iprot.skip(ftype)
11161 
      iprot.readFieldEnd()
11162 
    iprot.readStructEnd()
11163 
 
11164 
  def write(self, oprot):
11165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11167 
      return
559 chandransh 11168 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11169 
    if self.success is not None:
559 chandransh 11170 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11171 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11172 
      for iter159 in self.success:
11173 
        iter159.write(oprot)
559 chandransh 11174 
      oprot.writeListEnd()
94 ashish 11175 
      oprot.writeFieldEnd()
3431 rajveer 11176 
    if self.scx is not None:
559 chandransh 11177 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11178 
      self.scx.write(oprot)
94 ashish 11179 
      oprot.writeFieldEnd()
11180 
    oprot.writeFieldStop()
11181 
    oprot.writeStructEnd()
11182 
 
3431 rajveer 11183 
  def validate(self):
11184 
    return
11185 
 
11186 
 
94 ashish 11187 
  def __repr__(self):
11188 
    L = ['%s=%r' % (key, value)
11189 
      for key, value in self.__dict__.iteritems()]
11190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11191 
 
11192 
  def __eq__(self, other):
11193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11194 
 
11195 
  def __ne__(self, other):
11196 
    return not (self == other)
11197 
 
559 chandransh 11198 
class addItemToCart_args:
11199 
  """
11200 
  Attributes:
11201 
   - cartId
11202 
   - itemId
11203 
   - quantity
3557 rajveer 11204 
   - sourceId
559 chandransh 11205 
  """
11206 
 
11207 
  thrift_spec = (
11208 
    None, # 0
11209 
    (1, TType.I64, 'cartId', None, None, ), # 1
11210 
    (2, TType.I64, 'itemId', None, None, ), # 2
11211 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11212 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11213 
  )
11214 
 
3557 rajveer 11215 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11216 
    self.cartId = cartId
11217 
    self.itemId = itemId
11218 
    self.quantity = quantity
3557 rajveer 11219 
    self.sourceId = sourceId
559 chandransh 11220 
 
11221 
  def read(self, iprot):
11222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11224 
      return
11225 
    iprot.readStructBegin()
11226 
    while True:
11227 
      (fname, ftype, fid) = iprot.readFieldBegin()
11228 
      if ftype == TType.STOP:
11229 
        break
11230 
      if fid == 1:
11231 
        if ftype == TType.I64:
11232 
          self.cartId = iprot.readI64();
11233 
        else:
11234 
          iprot.skip(ftype)
11235 
      elif fid == 2:
11236 
        if ftype == TType.I64:
11237 
          self.itemId = iprot.readI64();
11238 
        else:
11239 
          iprot.skip(ftype)
11240 
      elif fid == 3:
11241 
        if ftype == TType.I64:
11242 
          self.quantity = iprot.readI64();
11243 
        else:
11244 
          iprot.skip(ftype)
3557 rajveer 11245 
      elif fid == 4:
11246 
        if ftype == TType.I64:
11247 
          self.sourceId = iprot.readI64();
11248 
        else:
11249 
          iprot.skip(ftype)
559 chandransh 11250 
      else:
11251 
        iprot.skip(ftype)
11252 
      iprot.readFieldEnd()
11253 
    iprot.readStructEnd()
11254 
 
11255 
  def write(self, oprot):
11256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11258 
      return
11259 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11260 
    if self.cartId is not None:
559 chandransh 11261 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11262 
      oprot.writeI64(self.cartId)
11263 
      oprot.writeFieldEnd()
3431 rajveer 11264 
    if self.itemId is not None:
559 chandransh 11265 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11266 
      oprot.writeI64(self.itemId)
11267 
      oprot.writeFieldEnd()
3431 rajveer 11268 
    if self.quantity is not None:
559 chandransh 11269 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11270 
      oprot.writeI64(self.quantity)
11271 
      oprot.writeFieldEnd()
3557 rajveer 11272 
    if self.sourceId is not None:
11273 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11274 
      oprot.writeI64(self.sourceId)
11275 
      oprot.writeFieldEnd()
559 chandransh 11276 
    oprot.writeFieldStop()
11277 
    oprot.writeStructEnd()
11278 
 
3431 rajveer 11279 
  def validate(self):
11280 
    return
11281 
 
11282 
 
559 chandransh 11283 
  def __repr__(self):
11284 
    L = ['%s=%r' % (key, value)
11285 
      for key, value in self.__dict__.iteritems()]
11286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11287 
 
11288 
  def __eq__(self, other):
11289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11290 
 
11291 
  def __ne__(self, other):
11292 
    return not (self == other)
11293 
 
11294 
class addItemToCart_result:
11295 
  """
11296 
  Attributes:
2035 rajveer 11297 
   - success
559 chandransh 11298 
   - scx
11299 
  """
11300 
 
11301 
  thrift_spec = (
2035 rajveer 11302 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11303 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11304 
  )
11305 
 
2035 rajveer 11306 
  def __init__(self, success=None, scx=None,):
11307 
    self.success = success
559 chandransh 11308 
    self.scx = scx
11309 
 
11310 
  def read(self, iprot):
11311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11313 
      return
11314 
    iprot.readStructBegin()
11315 
    while True:
11316 
      (fname, ftype, fid) = iprot.readFieldBegin()
11317 
      if ftype == TType.STOP:
11318 
        break
2035 rajveer 11319 
      if fid == 0:
11320 
        if ftype == TType.STRING:
11321 
          self.success = iprot.readString();
11322 
        else:
11323 
          iprot.skip(ftype)
11324 
      elif fid == 1:
559 chandransh 11325 
        if ftype == TType.STRUCT:
11326 
          self.scx = ShoppingCartException()
11327 
          self.scx.read(iprot)
11328 
        else:
11329 
          iprot.skip(ftype)
11330 
      else:
11331 
        iprot.skip(ftype)
11332 
      iprot.readFieldEnd()
11333 
    iprot.readStructEnd()
11334 
 
11335 
  def write(self, oprot):
11336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11338 
      return
11339 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11340 
    if self.success is not None:
2035 rajveer 11341 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11342 
      oprot.writeString(self.success)
11343 
      oprot.writeFieldEnd()
3431 rajveer 11344 
    if self.scx is not None:
559 chandransh 11345 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11346 
      self.scx.write(oprot)
11347 
      oprot.writeFieldEnd()
11348 
    oprot.writeFieldStop()
11349 
    oprot.writeStructEnd()
11350 
 
3431 rajveer 11351 
  def validate(self):
11352 
    return
11353 
 
11354 
 
559 chandransh 11355 
  def __repr__(self):
11356 
    L = ['%s=%r' % (key, value)
11357 
      for key, value in self.__dict__.iteritems()]
11358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11359 
 
11360 
  def __eq__(self, other):
11361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11362 
 
11363 
  def __ne__(self, other):
11364 
    return not (self == other)
11365 
 
11366 
class deleteItemFromCart_args:
11367 
  """
11368 
  Attributes:
11369 
   - cartId
11370 
   - itemId
11371 
  """
11372 
 
11373 
  thrift_spec = (
11374 
    None, # 0
11375 
    (1, TType.I64, 'cartId', None, None, ), # 1
11376 
    (2, TType.I64, 'itemId', None, None, ), # 2
11377 
  )
11378 
 
11379 
  def __init__(self, cartId=None, itemId=None,):
11380 
    self.cartId = cartId
11381 
    self.itemId = itemId
11382 
 
11383 
  def read(self, iprot):
11384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11386 
      return
11387 
    iprot.readStructBegin()
11388 
    while True:
11389 
      (fname, ftype, fid) = iprot.readFieldBegin()
11390 
      if ftype == TType.STOP:
11391 
        break
11392 
      if fid == 1:
11393 
        if ftype == TType.I64:
11394 
          self.cartId = iprot.readI64();
11395 
        else:
11396 
          iprot.skip(ftype)
11397 
      elif fid == 2:
11398 
        if ftype == TType.I64:
11399 
          self.itemId = iprot.readI64();
11400 
        else:
11401 
          iprot.skip(ftype)
11402 
      else:
11403 
        iprot.skip(ftype)
11404 
      iprot.readFieldEnd()
11405 
    iprot.readStructEnd()
11406 
 
11407 
  def write(self, oprot):
11408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11410 
      return
11411 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11412 
    if self.cartId is not None:
559 chandransh 11413 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11414 
      oprot.writeI64(self.cartId)
11415 
      oprot.writeFieldEnd()
3431 rajveer 11416 
    if self.itemId is not None:
559 chandransh 11417 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11418 
      oprot.writeI64(self.itemId)
11419 
      oprot.writeFieldEnd()
11420 
    oprot.writeFieldStop()
11421 
    oprot.writeStructEnd()
11422 
 
3431 rajveer 11423 
  def validate(self):
11424 
    return
11425 
 
11426 
 
559 chandransh 11427 
  def __repr__(self):
11428 
    L = ['%s=%r' % (key, value)
11429 
      for key, value in self.__dict__.iteritems()]
11430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11431 
 
11432 
  def __eq__(self, other):
11433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11434 
 
11435 
  def __ne__(self, other):
11436 
    return not (self == other)
11437 
 
11438 
class deleteItemFromCart_result:
11439 
  """
11440 
  Attributes:
11441 
   - scx
11442 
  """
11443 
 
11444 
  thrift_spec = (
11445 
    None, # 0
11446 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11447 
  )
11448 
 
11449 
  def __init__(self, scx=None,):
11450 
    self.scx = scx
11451 
 
11452 
  def read(self, iprot):
11453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11455 
      return
11456 
    iprot.readStructBegin()
11457 
    while True:
11458 
      (fname, ftype, fid) = iprot.readFieldBegin()
11459 
      if ftype == TType.STOP:
11460 
        break
11461 
      if fid == 1:
11462 
        if ftype == TType.STRUCT:
11463 
          self.scx = ShoppingCartException()
11464 
          self.scx.read(iprot)
11465 
        else:
11466 
          iprot.skip(ftype)
11467 
      else:
11468 
        iprot.skip(ftype)
11469 
      iprot.readFieldEnd()
11470 
    iprot.readStructEnd()
11471 
 
11472 
  def write(self, oprot):
11473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11475 
      return
11476 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11477 
    if self.scx is not None:
559 chandransh 11478 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11479 
      self.scx.write(oprot)
11480 
      oprot.writeFieldEnd()
11481 
    oprot.writeFieldStop()
11482 
    oprot.writeStructEnd()
11483 
 
3431 rajveer 11484 
  def validate(self):
11485 
    return
11486 
 
11487 
 
559 chandransh 11488 
  def __repr__(self):
11489 
    L = ['%s=%r' % (key, value)
11490 
      for key, value in self.__dict__.iteritems()]
11491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11492 
 
11493 
  def __eq__(self, other):
11494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11495 
 
11496 
  def __ne__(self, other):
11497 
    return not (self == other)
11498 
 
11499 
class addAddressToCart_args:
11500 
  """
11501 
  Attributes:
11502 
   - cartId
11503 
   - addressId
11504 
  """
11505 
 
11506 
  thrift_spec = (
11507 
    None, # 0
11508 
    (1, TType.I64, 'cartId', None, None, ), # 1
11509 
    (2, TType.I64, 'addressId', None, None, ), # 2
11510 
  )
11511 
 
11512 
  def __init__(self, cartId=None, addressId=None,):
11513 
    self.cartId = cartId
11514 
    self.addressId = addressId
11515 
 
11516 
  def read(self, iprot):
11517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11519 
      return
11520 
    iprot.readStructBegin()
11521 
    while True:
11522 
      (fname, ftype, fid) = iprot.readFieldBegin()
11523 
      if ftype == TType.STOP:
11524 
        break
11525 
      if fid == 1:
11526 
        if ftype == TType.I64:
11527 
          self.cartId = iprot.readI64();
11528 
        else:
11529 
          iprot.skip(ftype)
11530 
      elif fid == 2:
11531 
        if ftype == TType.I64:
11532 
          self.addressId = iprot.readI64();
11533 
        else:
11534 
          iprot.skip(ftype)
11535 
      else:
11536 
        iprot.skip(ftype)
11537 
      iprot.readFieldEnd()
11538 
    iprot.readStructEnd()
11539 
 
11540 
  def write(self, oprot):
11541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11543 
      return
11544 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11545 
    if self.cartId is not None:
559 chandransh 11546 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11547 
      oprot.writeI64(self.cartId)
11548 
      oprot.writeFieldEnd()
3431 rajveer 11549 
    if self.addressId is not None:
559 chandransh 11550 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11551 
      oprot.writeI64(self.addressId)
11552 
      oprot.writeFieldEnd()
11553 
    oprot.writeFieldStop()
11554 
    oprot.writeStructEnd()
11555 
 
3431 rajveer 11556 
  def validate(self):
11557 
    return
11558 
 
11559 
 
559 chandransh 11560 
  def __repr__(self):
11561 
    L = ['%s=%r' % (key, value)
11562 
      for key, value in self.__dict__.iteritems()]
11563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11564 
 
11565 
  def __eq__(self, other):
11566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11567 
 
11568 
  def __ne__(self, other):
11569 
    return not (self == other)
11570 
 
11571 
class addAddressToCart_result:
575 chandransh 11572 
  """
11573 
  Attributes:
11574 
   - scx
11575 
  """
559 chandransh 11576 
 
11577 
  thrift_spec = (
575 chandransh 11578 
    None, # 0
11579 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11580 
  )
11581 
 
575 chandransh 11582 
  def __init__(self, scx=None,):
11583 
    self.scx = scx
11584 
 
559 chandransh 11585 
  def read(self, iprot):
11586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11588 
      return
11589 
    iprot.readStructBegin()
11590 
    while True:
11591 
      (fname, ftype, fid) = iprot.readFieldBegin()
11592 
      if ftype == TType.STOP:
11593 
        break
575 chandransh 11594 
      if fid == 1:
11595 
        if ftype == TType.STRUCT:
11596 
          self.scx = ShoppingCartException()
11597 
          self.scx.read(iprot)
11598 
        else:
11599 
          iprot.skip(ftype)
559 chandransh 11600 
      else:
11601 
        iprot.skip(ftype)
11602 
      iprot.readFieldEnd()
11603 
    iprot.readStructEnd()
11604 
 
11605 
  def write(self, oprot):
11606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11608 
      return
11609 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11610 
    if self.scx is not None:
575 chandransh 11611 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11612 
      self.scx.write(oprot)
11613 
      oprot.writeFieldEnd()
559 chandransh 11614 
    oprot.writeFieldStop()
11615 
    oprot.writeStructEnd()
11616 
 
3431 rajveer 11617 
  def validate(self):
11618 
    return
11619 
 
11620 
 
559 chandransh 11621 
  def __repr__(self):
11622 
    L = ['%s=%r' % (key, value)
11623 
      for key, value in self.__dict__.iteritems()]
11624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11625 
 
11626 
  def __eq__(self, other):
11627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11628 
 
11629 
  def __ne__(self, other):
11630 
    return not (self == other)
11631 
 
5553 rajveer 11632 
class addStoreToCart_args:
11633 
  """
11634 
  Attributes:
11635 
   - cartId
11636 
   - storeId
11637 
  """
11638 
 
11639 
  thrift_spec = (
11640 
    None, # 0
11641 
    (1, TType.I64, 'cartId', None, None, ), # 1
11642 
    (2, TType.I64, 'storeId', None, None, ), # 2
11643 
  )
11644 
 
11645 
  def __init__(self, cartId=None, storeId=None,):
11646 
    self.cartId = cartId
11647 
    self.storeId = storeId
11648 
 
11649 
  def read(self, iprot):
11650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11652 
      return
11653 
    iprot.readStructBegin()
11654 
    while True:
11655 
      (fname, ftype, fid) = iprot.readFieldBegin()
11656 
      if ftype == TType.STOP:
11657 
        break
11658 
      if fid == 1:
11659 
        if ftype == TType.I64:
11660 
          self.cartId = iprot.readI64();
11661 
        else:
11662 
          iprot.skip(ftype)
11663 
      elif fid == 2:
11664 
        if ftype == TType.I64:
11665 
          self.storeId = iprot.readI64();
11666 
        else:
11667 
          iprot.skip(ftype)
11668 
      else:
11669 
        iprot.skip(ftype)
11670 
      iprot.readFieldEnd()
11671 
    iprot.readStructEnd()
11672 
 
11673 
  def write(self, oprot):
11674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11676 
      return
11677 
    oprot.writeStructBegin('addStoreToCart_args')
11678 
    if self.cartId is not None:
11679 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11680 
      oprot.writeI64(self.cartId)
11681 
      oprot.writeFieldEnd()
11682 
    if self.storeId is not None:
11683 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11684 
      oprot.writeI64(self.storeId)
11685 
      oprot.writeFieldEnd()
11686 
    oprot.writeFieldStop()
11687 
    oprot.writeStructEnd()
11688 
 
11689 
  def validate(self):
11690 
    return
11691 
 
11692 
 
11693 
  def __repr__(self):
11694 
    L = ['%s=%r' % (key, value)
11695 
      for key, value in self.__dict__.iteritems()]
11696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11697 
 
11698 
  def __eq__(self, other):
11699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11700 
 
11701 
  def __ne__(self, other):
11702 
    return not (self == other)
11703 
 
11704 
class addStoreToCart_result:
11705 
  """
11706 
  Attributes:
11707 
   - scx
11708 
  """
11709 
 
11710 
  thrift_spec = (
11711 
    None, # 0
11712 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11713 
  )
11714 
 
11715 
  def __init__(self, scx=None,):
11716 
    self.scx = scx
11717 
 
11718 
  def read(self, iprot):
11719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11721 
      return
11722 
    iprot.readStructBegin()
11723 
    while True:
11724 
      (fname, ftype, fid) = iprot.readFieldBegin()
11725 
      if ftype == TType.STOP:
11726 
        break
11727 
      if fid == 1:
11728 
        if ftype == TType.STRUCT:
11729 
          self.scx = ShoppingCartException()
11730 
          self.scx.read(iprot)
11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      else:
11734 
        iprot.skip(ftype)
11735 
      iprot.readFieldEnd()
11736 
    iprot.readStructEnd()
11737 
 
11738 
  def write(self, oprot):
11739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11741 
      return
11742 
    oprot.writeStructBegin('addStoreToCart_result')
11743 
    if self.scx is not None:
11744 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11745 
      self.scx.write(oprot)
11746 
      oprot.writeFieldEnd()
11747 
    oprot.writeFieldStop()
11748 
    oprot.writeStructEnd()
11749 
 
11750 
  def validate(self):
11751 
    return
11752 
 
11753 
 
11754 
  def __repr__(self):
11755 
    L = ['%s=%r' % (key, value)
11756 
      for key, value in self.__dict__.iteritems()]
11757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11758 
 
11759 
  def __eq__(self, other):
11760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11761 
 
11762 
  def __ne__(self, other):
11763 
    return not (self == other)
11764 
 
1976 varun.gupt 11765 
class applyCouponToCart_args:
11766 
  """
11767 
  Attributes:
6922 anupam.sin 11768 
   - cart
1976 varun.gupt 11769 
   - couponCode
11770 
  """
11771 
 
11772 
  thrift_spec = (
11773 
    None, # 0
6922 anupam.sin 11774 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11775 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11776 
  )
11777 
 
6922 anupam.sin 11778 
  def __init__(self, cart=None, couponCode=None,):
11779 
    self.cart = cart
1976 varun.gupt 11780 
    self.couponCode = couponCode
11781 
 
11782 
  def read(self, iprot):
11783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11785 
      return
11786 
    iprot.readStructBegin()
11787 
    while True:
11788 
      (fname, ftype, fid) = iprot.readFieldBegin()
11789 
      if ftype == TType.STOP:
11790 
        break
11791 
      if fid == 1:
6922 anupam.sin 11792 
        if ftype == TType.STRUCT:
11793 
          self.cart = Cart()
11794 
          self.cart.read(iprot)
1976 varun.gupt 11795 
        else:
11796 
          iprot.skip(ftype)
11797 
      elif fid == 2:
11798 
        if ftype == TType.STRING:
11799 
          self.couponCode = iprot.readString();
11800 
        else:
11801 
          iprot.skip(ftype)
11802 
      else:
11803 
        iprot.skip(ftype)
11804 
      iprot.readFieldEnd()
11805 
    iprot.readStructEnd()
11806 
 
11807 
  def write(self, oprot):
11808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11810 
      return
11811 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11812 
    if self.cart is not None:
11813 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11814 
      self.cart.write(oprot)
1976 varun.gupt 11815 
      oprot.writeFieldEnd()
3431 rajveer 11816 
    if self.couponCode is not None:
1976 varun.gupt 11817 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11818 
      oprot.writeString(self.couponCode)
11819 
      oprot.writeFieldEnd()
11820 
    oprot.writeFieldStop()
11821 
    oprot.writeStructEnd()
11822 
 
3431 rajveer 11823 
  def validate(self):
11824 
    return
11825 
 
11826 
 
1976 varun.gupt 11827 
  def __repr__(self):
11828 
    L = ['%s=%r' % (key, value)
11829 
      for key, value in self.__dict__.iteritems()]
11830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11831 
 
11832 
  def __eq__(self, other):
11833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11834 
 
11835 
  def __ne__(self, other):
11836 
    return not (self == other)
11837 
 
11838 
class applyCouponToCart_result:
11839 
  """
11840 
  Attributes:
11841 
   - scx
11842 
  """
11843 
 
11844 
  thrift_spec = (
11845 
    None, # 0
11846 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11847 
  )
11848 
 
11849 
  def __init__(self, scx=None,):
11850 
    self.scx = scx
11851 
 
11852 
  def read(self, iprot):
11853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11855 
      return
11856 
    iprot.readStructBegin()
11857 
    while True:
11858 
      (fname, ftype, fid) = iprot.readFieldBegin()
11859 
      if ftype == TType.STOP:
11860 
        break
11861 
      if fid == 1:
11862 
        if ftype == TType.STRUCT:
11863 
          self.scx = ShoppingCartException()
11864 
          self.scx.read(iprot)
11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      else:
11868 
        iprot.skip(ftype)
11869 
      iprot.readFieldEnd()
11870 
    iprot.readStructEnd()
11871 
 
11872 
  def write(self, oprot):
11873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11875 
      return
11876 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11877 
    if self.scx is not None:
1976 varun.gupt 11878 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11879 
      self.scx.write(oprot)
11880 
      oprot.writeFieldEnd()
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
3431 rajveer 11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
1976 varun.gupt 11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
11899 
class removeCoupon_args:
11900 
  """
11901 
  Attributes:
11902 
   - cartId
11903 
  """
11904 
 
11905 
  thrift_spec = (
11906 
    None, # 0
11907 
    (1, TType.I64, 'cartId', None, None, ), # 1
11908 
  )
11909 
 
11910 
  def __init__(self, cartId=None,):
11911 
    self.cartId = cartId
11912 
 
11913 
  def read(self, iprot):
11914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11916 
      return
11917 
    iprot.readStructBegin()
11918 
    while True:
11919 
      (fname, ftype, fid) = iprot.readFieldBegin()
11920 
      if ftype == TType.STOP:
11921 
        break
11922 
      if fid == 1:
11923 
        if ftype == TType.I64:
11924 
          self.cartId = iprot.readI64();
11925 
        else:
11926 
          iprot.skip(ftype)
11927 
      else:
11928 
        iprot.skip(ftype)
11929 
      iprot.readFieldEnd()
11930 
    iprot.readStructEnd()
11931 
 
11932 
  def write(self, oprot):
11933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11935 
      return
11936 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11937 
    if self.cartId is not None:
1976 varun.gupt 11938 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11939 
      oprot.writeI64(self.cartId)
11940 
      oprot.writeFieldEnd()
11941 
    oprot.writeFieldStop()
11942 
    oprot.writeStructEnd()
11943 
 
3431 rajveer 11944 
  def validate(self):
11945 
    return
11946 
 
11947 
 
1976 varun.gupt 11948 
  def __repr__(self):
11949 
    L = ['%s=%r' % (key, value)
11950 
      for key, value in self.__dict__.iteritems()]
11951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11952 
 
11953 
  def __eq__(self, other):
11954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11955 
 
11956 
  def __ne__(self, other):
11957 
    return not (self == other)
11958 
 
11959 
class removeCoupon_result:
11960 
  """
11961 
  Attributes:
11962 
   - scx
11963 
  """
11964 
 
11965 
  thrift_spec = (
11966 
    None, # 0
11967 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11968 
  )
11969 
 
11970 
  def __init__(self, scx=None,):
11971 
    self.scx = scx
11972 
 
11973 
  def read(self, iprot):
11974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11976 
      return
11977 
    iprot.readStructBegin()
11978 
    while True:
11979 
      (fname, ftype, fid) = iprot.readFieldBegin()
11980 
      if ftype == TType.STOP:
11981 
        break
11982 
      if fid == 1:
11983 
        if ftype == TType.STRUCT:
11984 
          self.scx = ShoppingCartException()
11985 
          self.scx.read(iprot)
11986 
        else:
11987 
          iprot.skip(ftype)
11988 
      else:
11989 
        iprot.skip(ftype)
11990 
      iprot.readFieldEnd()
11991 
    iprot.readStructEnd()
11992 
 
11993 
  def write(self, oprot):
11994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11996 
      return
11997 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11998 
    if self.scx is not None:
1976 varun.gupt 11999 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12000 
      self.scx.write(oprot)
12001 
      oprot.writeFieldEnd()
12002 
    oprot.writeFieldStop()
12003 
    oprot.writeStructEnd()
12004 
 
3431 rajveer 12005 
  def validate(self):
12006 
    return
12007 
 
12008 
 
1976 varun.gupt 12009 
  def __repr__(self):
12010 
    L = ['%s=%r' % (key, value)
12011 
      for key, value in self.__dict__.iteritems()]
12012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12013 
 
12014 
  def __eq__(self, other):
12015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12016 
 
12017 
  def __ne__(self, other):
12018 
    return not (self == other)
12019 
 
3554 varun.gupt 12020 
class deleteDiscountsFromCart_args:
12021 
  """
12022 
  Attributes:
12023 
   - cartId
12024 
  """
12025 
 
12026 
  thrift_spec = (
12027 
    None, # 0
12028 
    (1, TType.I64, 'cartId', None, None, ), # 1
12029 
  )
12030 
 
12031 
  def __init__(self, cartId=None,):
12032 
    self.cartId = cartId
12033 
 
12034 
  def read(self, iprot):
12035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12037 
      return
12038 
    iprot.readStructBegin()
12039 
    while True:
12040 
      (fname, ftype, fid) = iprot.readFieldBegin()
12041 
      if ftype == TType.STOP:
12042 
        break
12043 
      if fid == 1:
12044 
        if ftype == TType.I64:
12045 
          self.cartId = iprot.readI64();
12046 
        else:
12047 
          iprot.skip(ftype)
12048 
      else:
12049 
        iprot.skip(ftype)
12050 
      iprot.readFieldEnd()
12051 
    iprot.readStructEnd()
12052 
 
12053 
  def write(self, oprot):
12054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12056 
      return
12057 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12058 
    if self.cartId is not None:
12059 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12060 
      oprot.writeI64(self.cartId)
12061 
      oprot.writeFieldEnd()
12062 
    oprot.writeFieldStop()
12063 
    oprot.writeStructEnd()
12064 
 
12065 
  def validate(self):
12066 
    return
12067 
 
12068 
 
12069 
  def __repr__(self):
12070 
    L = ['%s=%r' % (key, value)
12071 
      for key, value in self.__dict__.iteritems()]
12072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12073 
 
12074 
  def __eq__(self, other):
12075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12076 
 
12077 
  def __ne__(self, other):
12078 
    return not (self == other)
12079 
 
12080 
class deleteDiscountsFromCart_result:
12081 
  """
12082 
  Attributes:
12083 
   - scx
12084 
  """
12085 
 
12086 
  thrift_spec = (
12087 
    None, # 0
12088 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12089 
  )
12090 
 
12091 
  def __init__(self, scx=None,):
12092 
    self.scx = scx
12093 
 
12094 
  def read(self, iprot):
12095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12097 
      return
12098 
    iprot.readStructBegin()
12099 
    while True:
12100 
      (fname, ftype, fid) = iprot.readFieldBegin()
12101 
      if ftype == TType.STOP:
12102 
        break
12103 
      if fid == 1:
12104 
        if ftype == TType.STRUCT:
12105 
          self.scx = ShoppingCartException()
12106 
          self.scx.read(iprot)
12107 
        else:
12108 
          iprot.skip(ftype)
12109 
      else:
12110 
        iprot.skip(ftype)
12111 
      iprot.readFieldEnd()
12112 
    iprot.readStructEnd()
12113 
 
12114 
  def write(self, oprot):
12115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12117 
      return
12118 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12119 
    if self.scx is not None:
12120 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12121 
      self.scx.write(oprot)
12122 
      oprot.writeFieldEnd()
12123 
    oprot.writeFieldStop()
12124 
    oprot.writeStructEnd()
12125 
 
12126 
  def validate(self):
12127 
    return
12128 
 
12129 
 
12130 
  def __repr__(self):
12131 
    L = ['%s=%r' % (key, value)
12132 
      for key, value in self.__dict__.iteritems()]
12133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12134 
 
12135 
  def __eq__(self, other):
12136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12137 
 
12138 
  def __ne__(self, other):
12139 
    return not (self == other)
12140 
 
12141 
class saveDiscounts_args:
12142 
  """
12143 
  Attributes:
12144 
   - discounts
12145 
  """
12146 
 
12147 
  thrift_spec = (
12148 
    None, # 0
12149 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12150 
  )
12151 
 
12152 
  def __init__(self, discounts=None,):
12153 
    self.discounts = discounts
12154 
 
12155 
  def read(self, iprot):
12156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12158 
      return
12159 
    iprot.readStructBegin()
12160 
    while True:
12161 
      (fname, ftype, fid) = iprot.readFieldBegin()
12162 
      if ftype == TType.STOP:
12163 
        break
12164 
      if fid == 1:
12165 
        if ftype == TType.LIST:
12166 
          self.discounts = []
11592 amit.gupta 12167 
          (_etype163, _size160) = iprot.readListBegin()
12168 
          for _i164 in xrange(_size160):
12169 
            _elem165 = Discount()
12170 
            _elem165.read(iprot)
12171 
            self.discounts.append(_elem165)
3554 varun.gupt 12172 
          iprot.readListEnd()
12173 
        else:
12174 
          iprot.skip(ftype)
12175 
      else:
12176 
        iprot.skip(ftype)
12177 
      iprot.readFieldEnd()
12178 
    iprot.readStructEnd()
12179 
 
12180 
  def write(self, oprot):
12181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12183 
      return
12184 
    oprot.writeStructBegin('saveDiscounts_args')
12185 
    if self.discounts is not None:
12186 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12187 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12188 
      for iter166 in self.discounts:
12189 
        iter166.write(oprot)
3554 varun.gupt 12190 
      oprot.writeListEnd()
12191 
      oprot.writeFieldEnd()
12192 
    oprot.writeFieldStop()
12193 
    oprot.writeStructEnd()
12194 
 
12195 
  def validate(self):
12196 
    return
12197 
 
12198 
 
12199 
  def __repr__(self):
12200 
    L = ['%s=%r' % (key, value)
12201 
      for key, value in self.__dict__.iteritems()]
12202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12203 
 
12204 
  def __eq__(self, other):
12205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12206 
 
12207 
  def __ne__(self, other):
12208 
    return not (self == other)
12209 
 
12210 
class saveDiscounts_result:
12211 
  """
12212 
  Attributes:
12213 
   - scx
12214 
  """
12215 
 
12216 
  thrift_spec = (
12217 
    None, # 0
12218 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12219 
  )
12220 
 
12221 
  def __init__(self, scx=None,):
12222 
    self.scx = scx
12223 
 
12224 
  def read(self, iprot):
12225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12227 
      return
12228 
    iprot.readStructBegin()
12229 
    while True:
12230 
      (fname, ftype, fid) = iprot.readFieldBegin()
12231 
      if ftype == TType.STOP:
12232 
        break
12233 
      if fid == 1:
12234 
        if ftype == TType.STRUCT:
12235 
          self.scx = ShoppingCartException()
12236 
          self.scx.read(iprot)
12237 
        else:
12238 
          iprot.skip(ftype)
12239 
      else:
12240 
        iprot.skip(ftype)
12241 
      iprot.readFieldEnd()
12242 
    iprot.readStructEnd()
12243 
 
12244 
  def write(self, oprot):
12245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12247 
      return
12248 
    oprot.writeStructBegin('saveDiscounts_result')
12249 
    if self.scx is not None:
12250 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12251 
      self.scx.write(oprot)
12252 
      oprot.writeFieldEnd()
12253 
    oprot.writeFieldStop()
12254 
    oprot.writeStructEnd()
12255 
 
12256 
  def validate(self):
12257 
    return
12258 
 
12259 
 
12260 
  def __repr__(self):
12261 
    L = ['%s=%r' % (key, value)
12262 
      for key, value in self.__dict__.iteritems()]
12263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12264 
 
12265 
  def __eq__(self, other):
12266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12267 
 
12268 
  def __ne__(self, other):
12269 
    return not (self == other)
12270 
 
690 chandransh 12271 
class createOrders_args:
559 chandransh 12272 
  """
12273 
  Attributes:
12274 
   - cartId
2815 vikas 12275 
   - sessionSource
12276 
   - sessionStartTime
3858 vikas 12277 
   - firstSource
12278 
   - firstSourceTime
5326 rajveer 12279 
   - userId
6389 rajveer 12280 
   - schemeId
11526 amit.gupta 12281 
   - orderSource
559 chandransh 12282 
  """
12283 
 
12284 
  thrift_spec = (
12285 
    None, # 0
12286 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12287 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12288 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12289 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12290 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12291 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12292 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12293 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12294 
  )
12295 
 
11526 amit.gupta 12296 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12297 
    self.cartId = cartId
2815 vikas 12298 
    self.sessionSource = sessionSource
12299 
    self.sessionStartTime = sessionStartTime
3858 vikas 12300 
    self.firstSource = firstSource
12301 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12302 
    self.userId = userId
6389 rajveer 12303 
    self.schemeId = schemeId
11526 amit.gupta 12304 
    self.orderSource = orderSource
559 chandransh 12305 
 
12306 
  def read(self, iprot):
12307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12309 
      return
12310 
    iprot.readStructBegin()
12311 
    while True:
12312 
      (fname, ftype, fid) = iprot.readFieldBegin()
12313 
      if ftype == TType.STOP:
12314 
        break
12315 
      if fid == 1:
12316 
        if ftype == TType.I64:
12317 
          self.cartId = iprot.readI64();
12318 
        else:
12319 
          iprot.skip(ftype)
2815 vikas 12320 
      elif fid == 2:
12321 
        if ftype == TType.STRING:
12322 
          self.sessionSource = iprot.readString();
12323 
        else:
12324 
          iprot.skip(ftype)
12325 
      elif fid == 3:
12326 
        if ftype == TType.I64:
12327 
          self.sessionStartTime = iprot.readI64();
12328 
        else:
12329 
          iprot.skip(ftype)
3858 vikas 12330 
      elif fid == 4:
12331 
        if ftype == TType.STRING:
12332 
          self.firstSource = iprot.readString();
12333 
        else:
12334 
          iprot.skip(ftype)
12335 
      elif fid == 5:
12336 
        if ftype == TType.I64:
12337 
          self.firstSourceTime = iprot.readI64();
12338 
        else:
12339 
          iprot.skip(ftype)
5326 rajveer 12340 
      elif fid == 6:
12341 
        if ftype == TType.I64:
12342 
          self.userId = iprot.readI64();
12343 
        else:
12344 
          iprot.skip(ftype)
6389 rajveer 12345 
      elif fid == 7:
12346 
        if ftype == TType.I64:
12347 
          self.schemeId = iprot.readI64();
12348 
        else:
12349 
          iprot.skip(ftype)
11526 amit.gupta 12350 
      elif fid == 8:
12351 
        if ftype == TType.I64:
12352 
          self.orderSource = iprot.readI64();
12353 
        else:
12354 
          iprot.skip(ftype)
559 chandransh 12355 
      else:
12356 
        iprot.skip(ftype)
12357 
      iprot.readFieldEnd()
12358 
    iprot.readStructEnd()
12359 
 
12360 
  def write(self, oprot):
12361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12363 
      return
690 chandransh 12364 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12365 
    if self.cartId is not None:
559 chandransh 12366 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12367 
      oprot.writeI64(self.cartId)
12368 
      oprot.writeFieldEnd()
3431 rajveer 12369 
    if self.sessionSource is not None:
2815 vikas 12370 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12371 
      oprot.writeString(self.sessionSource)
12372 
      oprot.writeFieldEnd()
3431 rajveer 12373 
    if self.sessionStartTime is not None:
2815 vikas 12374 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12375 
      oprot.writeI64(self.sessionStartTime)
12376 
      oprot.writeFieldEnd()
3858 vikas 12377 
    if self.firstSource is not None:
12378 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12379 
      oprot.writeString(self.firstSource)
12380 
      oprot.writeFieldEnd()
12381 
    if self.firstSourceTime is not None:
12382 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12383 
      oprot.writeI64(self.firstSourceTime)
12384 
      oprot.writeFieldEnd()
5326 rajveer 12385 
    if self.userId is not None:
12386 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12387 
      oprot.writeI64(self.userId)
12388 
      oprot.writeFieldEnd()
6389 rajveer 12389 
    if self.schemeId is not None:
12390 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12391 
      oprot.writeI64(self.schemeId)
12392 
      oprot.writeFieldEnd()
11526 amit.gupta 12393 
    if self.orderSource is not None:
12394 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12395 
      oprot.writeI64(self.orderSource)
12396 
      oprot.writeFieldEnd()
559 chandransh 12397 
    oprot.writeFieldStop()
12398 
    oprot.writeStructEnd()
12399 
 
3431 rajveer 12400 
  def validate(self):
12401 
    return
12402 
 
12403 
 
559 chandransh 12404 
  def __repr__(self):
12405 
    L = ['%s=%r' % (key, value)
12406 
      for key, value in self.__dict__.iteritems()]
12407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12408 
 
12409 
  def __eq__(self, other):
12410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12411 
 
12412 
  def __ne__(self, other):
12413 
    return not (self == other)
12414 
 
690 chandransh 12415 
class createOrders_result:
559 chandransh 12416 
  """
12417 
  Attributes:
94 ashish 12418 
   - success
559 chandransh 12419 
   - scx
94 ashish 12420 
  """
12421 
 
12422 
  thrift_spec = (
575 chandransh 12423 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12424 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12425 
  )
12426 
 
559 chandransh 12427 
  def __init__(self, success=None, scx=None,):
94 ashish 12428 
    self.success = success
559 chandransh 12429 
    self.scx = scx
94 ashish 12430 
 
12431 
  def read(self, iprot):
12432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12434 
      return
12435 
    iprot.readStructBegin()
12436 
    while True:
12437 
      (fname, ftype, fid) = iprot.readFieldBegin()
12438 
      if ftype == TType.STOP:
12439 
        break
12440 
      if fid == 0:
575 chandransh 12441 
        if ftype == TType.I64:
12442 
          self.success = iprot.readI64();
94 ashish 12443 
        else:
12444 
          iprot.skip(ftype)
12445 
      elif fid == 1:
12446 
        if ftype == TType.STRUCT:
559 chandransh 12447 
          self.scx = ShoppingCartException()
12448 
          self.scx.read(iprot)
94 ashish 12449 
        else:
12450 
          iprot.skip(ftype)
12451 
      else:
12452 
        iprot.skip(ftype)
12453 
      iprot.readFieldEnd()
12454 
    iprot.readStructEnd()
12455 
 
12456 
  def write(self, oprot):
12457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12459 
      return
690 chandransh 12460 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12461 
    if self.success is not None:
575 chandransh 12462 
      oprot.writeFieldBegin('success', TType.I64, 0)
12463 
      oprot.writeI64(self.success)
94 ashish 12464 
      oprot.writeFieldEnd()
3431 rajveer 12465 
    if self.scx is not None:
559 chandransh 12466 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12467 
      self.scx.write(oprot)
94 ashish 12468 
      oprot.writeFieldEnd()
12469 
    oprot.writeFieldStop()
12470 
    oprot.writeStructEnd()
12471 
 
3431 rajveer 12472 
  def validate(self):
12473 
    return
12474 
 
12475 
 
94 ashish 12476 
  def __repr__(self):
12477 
    L = ['%s=%r' % (key, value)
12478 
      for key, value in self.__dict__.iteritems()]
12479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12480 
 
12481 
  def __eq__(self, other):
12482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12483 
 
12484 
  def __ne__(self, other):
12485 
    return not (self == other)
12486 
 
559 chandransh 12487 
class validateCart_args:
94 ashish 12488 
  """
12489 
  Attributes:
559 chandransh 12490 
   - cartId
3557 rajveer 12491 
   - sourceId
94 ashish 12492 
  """
12493 
 
12494 
  thrift_spec = (
12495 
    None, # 0
559 chandransh 12496 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12497 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12498 
  )
12499 
 
3557 rajveer 12500 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12501 
    self.cartId = cartId
3557 rajveer 12502 
    self.sourceId = sourceId
94 ashish 12503 
 
12504 
  def read(self, iprot):
12505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12507 
      return
12508 
    iprot.readStructBegin()
12509 
    while True:
12510 
      (fname, ftype, fid) = iprot.readFieldBegin()
12511 
      if ftype == TType.STOP:
12512 
        break
12513 
      if fid == 1:
12514 
        if ftype == TType.I64:
559 chandransh 12515 
          self.cartId = iprot.readI64();
94 ashish 12516 
        else:
12517 
          iprot.skip(ftype)
3557 rajveer 12518 
      elif fid == 2:
12519 
        if ftype == TType.I64:
12520 
          self.sourceId = iprot.readI64();
12521 
        else:
12522 
          iprot.skip(ftype)
94 ashish 12523 
      else:
12524 
        iprot.skip(ftype)
12525 
      iprot.readFieldEnd()
12526 
    iprot.readStructEnd()
12527 
 
12528 
  def write(self, oprot):
12529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12531 
      return
559 chandransh 12532 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12533 
    if self.cartId is not None:
559 chandransh 12534 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12535 
      oprot.writeI64(self.cartId)
94 ashish 12536 
      oprot.writeFieldEnd()
3557 rajveer 12537 
    if self.sourceId is not None:
12538 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12539 
      oprot.writeI64(self.sourceId)
12540 
      oprot.writeFieldEnd()
94 ashish 12541 
    oprot.writeFieldStop()
12542 
    oprot.writeStructEnd()
12543 
 
3431 rajveer 12544 
  def validate(self):
12545 
    return
12546 
 
12547 
 
94 ashish 12548 
  def __repr__(self):
12549 
    L = ['%s=%r' % (key, value)
12550 
      for key, value in self.__dict__.iteritems()]
12551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12552 
 
12553 
  def __eq__(self, other):
12554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12555 
 
12556 
  def __ne__(self, other):
12557 
    return not (self == other)
12558 
 
559 chandransh 12559 
class validateCart_result:
94 ashish 12560 
  """
12561 
  Attributes:
12562 
   - success
575 chandransh 12563 
   - scex
94 ashish 12564 
  """
12565 
 
12566 
  thrift_spec = (
6736 amit.gupta 12567 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12568 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12569 
  )
12570 
 
575 chandransh 12571 
  def __init__(self, success=None, scex=None,):
94 ashish 12572 
    self.success = success
575 chandransh 12573 
    self.scex = scex
94 ashish 12574 
 
12575 
  def read(self, iprot):
12576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12578 
      return
12579 
    iprot.readStructBegin()
12580 
    while True:
12581 
      (fname, ftype, fid) = iprot.readFieldBegin()
12582 
      if ftype == TType.STOP:
12583 
        break
12584 
      if fid == 0:
6736 amit.gupta 12585 
        if ftype == TType.LIST:
12586 
          self.success = []
11592 amit.gupta 12587 
          (_etype170, _size167) = iprot.readListBegin()
12588 
          for _i171 in xrange(_size167):
12589 
            _elem172 = iprot.readString();
12590 
            self.success.append(_elem172)
6736 amit.gupta 12591 
          iprot.readListEnd()
94 ashish 12592 
        else:
12593 
          iprot.skip(ftype)
575 chandransh 12594 
      elif fid == 1:
12595 
        if ftype == TType.STRUCT:
12596 
          self.scex = ShoppingCartException()
12597 
          self.scex.read(iprot)
12598 
        else:
12599 
          iprot.skip(ftype)
94 ashish 12600 
      else:
12601 
        iprot.skip(ftype)
12602 
      iprot.readFieldEnd()
12603 
    iprot.readStructEnd()
12604 
 
12605 
  def write(self, oprot):
12606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12608 
      return
559 chandransh 12609 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12610 
    if self.success is not None:
6736 amit.gupta 12611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12612 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12613 
      for iter173 in self.success:
12614 
        oprot.writeString(iter173)
6736 amit.gupta 12615 
      oprot.writeListEnd()
94 ashish 12616 
      oprot.writeFieldEnd()
3431 rajveer 12617 
    if self.scex is not None:
575 chandransh 12618 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12619 
      self.scex.write(oprot)
12620 
      oprot.writeFieldEnd()
559 chandransh 12621 
    oprot.writeFieldStop()
12622 
    oprot.writeStructEnd()
12623 
 
3431 rajveer 12624 
  def validate(self):
12625 
    return
12626 
 
12627 
 
559 chandransh 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 
 
11980 amit.gupta 12639 
class validateCartWithDealerCoupon_args:
12640 
  """
12641 
  Attributes:
12642 
   - cartId
12643 
   - sourceId
12644 
   - dealCoupon
12645 
  """
12646 
 
12647 
  thrift_spec = (
12648 
    None, # 0
12649 
    (1, TType.I64, 'cartId', None, None, ), # 1
12650 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12651 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12652 
  )
12653 
 
12654 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12655 
    self.cartId = cartId
12656 
    self.sourceId = sourceId
12657 
    self.dealCoupon = dealCoupon
12658 
 
12659 
  def read(self, iprot):
12660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12662 
      return
12663 
    iprot.readStructBegin()
12664 
    while True:
12665 
      (fname, ftype, fid) = iprot.readFieldBegin()
12666 
      if ftype == TType.STOP:
12667 
        break
12668 
      if fid == 1:
12669 
        if ftype == TType.I64:
12670 
          self.cartId = iprot.readI64();
12671 
        else:
12672 
          iprot.skip(ftype)
12673 
      elif fid == 2:
12674 
        if ftype == TType.I64:
12675 
          self.sourceId = iprot.readI64();
12676 
        else:
12677 
          iprot.skip(ftype)
12678 
      elif fid == 3:
12679 
        if ftype == TType.STRING:
12680 
          self.dealCoupon = iprot.readString();
12681 
        else:
12682 
          iprot.skip(ftype)
12683 
      else:
12684 
        iprot.skip(ftype)
12685 
      iprot.readFieldEnd()
12686 
    iprot.readStructEnd()
12687 
 
12688 
  def write(self, oprot):
12689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12691 
      return
12692 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12693 
    if self.cartId is not None:
12694 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12695 
      oprot.writeI64(self.cartId)
12696 
      oprot.writeFieldEnd()
12697 
    if self.sourceId is not None:
12698 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12699 
      oprot.writeI64(self.sourceId)
12700 
      oprot.writeFieldEnd()
12701 
    if self.dealCoupon is not None:
12702 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12703 
      oprot.writeString(self.dealCoupon)
12704 
      oprot.writeFieldEnd()
12705 
    oprot.writeFieldStop()
12706 
    oprot.writeStructEnd()
12707 
 
12708 
  def validate(self):
12709 
    return
12710 
 
12711 
 
12712 
  def __repr__(self):
12713 
    L = ['%s=%r' % (key, value)
12714 
      for key, value in self.__dict__.iteritems()]
12715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12716 
 
12717 
  def __eq__(self, other):
12718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12719 
 
12720 
  def __ne__(self, other):
12721 
    return not (self == other)
12722 
 
12723 
class validateCartWithDealerCoupon_result:
12724 
  """
12725 
  Attributes:
12726 
   - success
12727 
   - scex
12728 
  """
12729 
 
12730 
  thrift_spec = (
12731 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12732 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12733 
  )
12734 
 
12735 
  def __init__(self, success=None, scex=None,):
12736 
    self.success = success
12737 
    self.scex = scex
12738 
 
12739 
  def read(self, iprot):
12740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12742 
      return
12743 
    iprot.readStructBegin()
12744 
    while True:
12745 
      (fname, ftype, fid) = iprot.readFieldBegin()
12746 
      if ftype == TType.STOP:
12747 
        break
12748 
      if fid == 0:
12749 
        if ftype == TType.LIST:
12750 
          self.success = []
12751 
          (_etype177, _size174) = iprot.readListBegin()
12752 
          for _i178 in xrange(_size174):
12753 
            _elem179 = iprot.readString();
12754 
            self.success.append(_elem179)
12755 
          iprot.readListEnd()
12756 
        else:
12757 
          iprot.skip(ftype)
12758 
      elif fid == 1:
12759 
        if ftype == TType.STRUCT:
12760 
          self.scex = ShoppingCartException()
12761 
          self.scex.read(iprot)
12762 
        else:
12763 
          iprot.skip(ftype)
12764 
      else:
12765 
        iprot.skip(ftype)
12766 
      iprot.readFieldEnd()
12767 
    iprot.readStructEnd()
12768 
 
12769 
  def write(self, oprot):
12770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12772 
      return
12773 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12774 
    if self.success is not None:
12775 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12776 
      oprot.writeListBegin(TType.STRING, len(self.success))
12777 
      for iter180 in self.success:
12778 
        oprot.writeString(iter180)
12779 
      oprot.writeListEnd()
12780 
      oprot.writeFieldEnd()
12781 
    if self.scex is not None:
12782 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12783 
      self.scex.write(oprot)
12784 
      oprot.writeFieldEnd()
12785 
    oprot.writeFieldStop()
12786 
    oprot.writeStructEnd()
12787 
 
12788 
  def validate(self):
12789 
    return
12790 
 
12791 
 
12792 
  def __repr__(self):
12793 
    L = ['%s=%r' % (key, value)
12794 
      for key, value in self.__dict__.iteritems()]
12795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12796 
 
12797 
  def __eq__(self, other):
12798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12799 
 
12800 
  def __ne__(self, other):
12801 
    return not (self == other)
12802 
 
690 chandransh 12803 
class mergeCart_args:
575 chandransh 12804 
  """
12805 
  Attributes:
690 chandransh 12806 
   - fromCartId
12807 
   - toCartId
12808 
  """
12809 
 
12810 
  thrift_spec = (
12811 
    None, # 0
12812 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12813 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12814 
  )
12815 
 
12816 
  def __init__(self, fromCartId=None, toCartId=None,):
12817 
    self.fromCartId = fromCartId
12818 
    self.toCartId = toCartId
12819 
 
12820 
  def read(self, iprot):
12821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12823 
      return
12824 
    iprot.readStructBegin()
12825 
    while True:
12826 
      (fname, ftype, fid) = iprot.readFieldBegin()
12827 
      if ftype == TType.STOP:
12828 
        break
12829 
      if fid == 1:
12830 
        if ftype == TType.I64:
12831 
          self.fromCartId = iprot.readI64();
12832 
        else:
12833 
          iprot.skip(ftype)
12834 
      elif fid == 2:
12835 
        if ftype == TType.I64:
12836 
          self.toCartId = iprot.readI64();
12837 
        else:
12838 
          iprot.skip(ftype)
12839 
      else:
12840 
        iprot.skip(ftype)
12841 
      iprot.readFieldEnd()
12842 
    iprot.readStructEnd()
12843 
 
12844 
  def write(self, oprot):
12845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12847 
      return
12848 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12849 
    if self.fromCartId is not None:
690 chandransh 12850 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12851 
      oprot.writeI64(self.fromCartId)
12852 
      oprot.writeFieldEnd()
3431 rajveer 12853 
    if self.toCartId is not None:
690 chandransh 12854 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12855 
      oprot.writeI64(self.toCartId)
12856 
      oprot.writeFieldEnd()
12857 
    oprot.writeFieldStop()
12858 
    oprot.writeStructEnd()
12859 
 
3431 rajveer 12860 
  def validate(self):
12861 
    return
12862 
 
12863 
 
690 chandransh 12864 
  def __repr__(self):
12865 
    L = ['%s=%r' % (key, value)
12866 
      for key, value in self.__dict__.iteritems()]
12867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12868 
 
12869 
  def __eq__(self, other):
12870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12871 
 
12872 
  def __ne__(self, other):
12873 
    return not (self == other)
12874 
 
12875 
class mergeCart_result:
12876 
 
12877 
  thrift_spec = (
12878 
  )
12879 
 
12880 
  def read(self, iprot):
12881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12883 
      return
12884 
    iprot.readStructBegin()
12885 
    while True:
12886 
      (fname, ftype, fid) = iprot.readFieldBegin()
12887 
      if ftype == TType.STOP:
12888 
        break
12889 
      else:
12890 
        iprot.skip(ftype)
12891 
      iprot.readFieldEnd()
12892 
    iprot.readStructEnd()
12893 
 
12894 
  def write(self, oprot):
12895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12897 
      return
12898 
    oprot.writeStructBegin('mergeCart_result')
12899 
    oprot.writeFieldStop()
12900 
    oprot.writeStructEnd()
12901 
 
3431 rajveer 12902 
  def validate(self):
12903 
    return
12904 
 
12905 
 
690 chandransh 12906 
  def __repr__(self):
12907 
    L = ['%s=%r' % (key, value)
12908 
      for key, value in self.__dict__.iteritems()]
12909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12910 
 
12911 
  def __eq__(self, other):
12912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12913 
 
12914 
  def __ne__(self, other):
12915 
    return not (self == other)
12916 
 
12917 
class checkOut_args:
12918 
  """
12919 
  Attributes:
575 chandransh 12920 
   - cartId
12921 
  """
12922 
 
12923 
  thrift_spec = (
12924 
    None, # 0
12925 
    (1, TType.I64, 'cartId', None, None, ), # 1
12926 
  )
12927 
 
12928 
  def __init__(self, cartId=None,):
12929 
    self.cartId = cartId
12930 
 
12931 
  def read(self, iprot):
12932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12934 
      return
12935 
    iprot.readStructBegin()
12936 
    while True:
12937 
      (fname, ftype, fid) = iprot.readFieldBegin()
12938 
      if ftype == TType.STOP:
12939 
        break
12940 
      if fid == 1:
12941 
        if ftype == TType.I64:
12942 
          self.cartId = iprot.readI64();
12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      else:
12946 
        iprot.skip(ftype)
12947 
      iprot.readFieldEnd()
12948 
    iprot.readStructEnd()
12949 
 
12950 
  def write(self, oprot):
12951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12953 
      return
690 chandransh 12954 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12955 
    if self.cartId is not None:
575 chandransh 12956 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12957 
      oprot.writeI64(self.cartId)
12958 
      oprot.writeFieldEnd()
12959 
    oprot.writeFieldStop()
12960 
    oprot.writeStructEnd()
12961 
 
3431 rajveer 12962 
  def validate(self):
12963 
    return
12964 
 
12965 
 
575 chandransh 12966 
  def __repr__(self):
12967 
    L = ['%s=%r' % (key, value)
12968 
      for key, value in self.__dict__.iteritems()]
12969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12970 
 
12971 
  def __eq__(self, other):
12972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12973 
 
12974 
  def __ne__(self, other):
12975 
    return not (self == other)
12976 
 
690 chandransh 12977 
class checkOut_result:
575 chandransh 12978 
  """
12979 
  Attributes:
12980 
   - success
12981 
   - scex
12982 
  """
12983 
 
12984 
  thrift_spec = (
12985 
    (0, TType.BOOL, 'success', None, None, ), # 0
12986 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12987 
  )
12988 
 
12989 
  def __init__(self, success=None, scex=None,):
12990 
    self.success = success
12991 
    self.scex = scex
12992 
 
12993 
  def read(self, iprot):
12994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12996 
      return
12997 
    iprot.readStructBegin()
12998 
    while True:
12999 
      (fname, ftype, fid) = iprot.readFieldBegin()
13000 
      if ftype == TType.STOP:
13001 
        break
13002 
      if fid == 0:
13003 
        if ftype == TType.BOOL:
13004 
          self.success = iprot.readBool();
13005 
        else:
13006 
          iprot.skip(ftype)
13007 
      elif fid == 1:
13008 
        if ftype == TType.STRUCT:
13009 
          self.scex = ShoppingCartException()
13010 
          self.scex.read(iprot)
13011 
        else:
13012 
          iprot.skip(ftype)
13013 
      else:
13014 
        iprot.skip(ftype)
13015 
      iprot.readFieldEnd()
13016 
    iprot.readStructEnd()
13017 
 
13018 
  def write(self, oprot):
13019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13021 
      return
690 chandransh 13022 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 13023 
    if self.success is not None:
575 chandransh 13024 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13025 
      oprot.writeBool(self.success)
13026 
      oprot.writeFieldEnd()
3431 rajveer 13027 
    if self.scex is not None:
575 chandransh 13028 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13029 
      self.scex.write(oprot)
13030 
      oprot.writeFieldEnd()
13031 
    oprot.writeFieldStop()
13032 
    oprot.writeStructEnd()
13033 
 
3431 rajveer 13034 
  def validate(self):
13035 
    return
13036 
 
13037 
 
575 chandransh 13038 
  def __repr__(self):
13039 
    L = ['%s=%r' % (key, value)
13040 
      for key, value in self.__dict__.iteritems()]
13041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13042 
 
13043 
  def __eq__(self, other):
13044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13045 
 
13046 
  def __ne__(self, other):
13047 
    return not (self == other)
13048 
 
690 chandransh 13049 
class resetCart_args:
559 chandransh 13050 
  """
13051 
  Attributes:
690 chandransh 13052 
   - cartId
13053 
   - items
559 chandransh 13054 
  """
13055 
 
13056 
  thrift_spec = (
13057 
    None, # 0
690 chandransh 13058 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13059 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13060 
  )
13061 
 
690 chandransh 13062 
  def __init__(self, cartId=None, items=None,):
13063 
    self.cartId = cartId
13064 
    self.items = items
559 chandransh 13065 
 
13066 
  def read(self, iprot):
13067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13069 
      return
13070 
    iprot.readStructBegin()
13071 
    while True:
13072 
      (fname, ftype, fid) = iprot.readFieldBegin()
13073 
      if ftype == TType.STOP:
13074 
        break
13075 
      if fid == 1:
13076 
        if ftype == TType.I64:
690 chandransh 13077 
          self.cartId = iprot.readI64();
559 chandransh 13078 
        else:
13079 
          iprot.skip(ftype)
13080 
      elif fid == 2:
690 chandransh 13081 
        if ftype == TType.MAP:
13082 
          self.items = {}
11980 amit.gupta 13083 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13084 
          for _i185 in xrange(_size181):
13085 
            _key186 = iprot.readI64();
13086 
            _val187 = iprot.readDouble();
13087 
            self.items[_key186] = _val187
690 chandransh 13088 
          iprot.readMapEnd()
559 chandransh 13089 
        else:
13090 
          iprot.skip(ftype)
13091 
      else:
13092 
        iprot.skip(ftype)
13093 
      iprot.readFieldEnd()
13094 
    iprot.readStructEnd()
13095 
 
13096 
  def write(self, oprot):
13097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13099 
      return
690 chandransh 13100 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13101 
    if self.cartId is not None:
690 chandransh 13102 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13103 
      oprot.writeI64(self.cartId)
94 ashish 13104 
      oprot.writeFieldEnd()
3431 rajveer 13105 
    if self.items is not None:
690 chandransh 13106 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13107 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13108 
      for kiter188,viter189 in self.items.items():
13109 
        oprot.writeI64(kiter188)
13110 
        oprot.writeDouble(viter189)
690 chandransh 13111 
      oprot.writeMapEnd()
559 chandransh 13112 
      oprot.writeFieldEnd()
94 ashish 13113 
    oprot.writeFieldStop()
13114 
    oprot.writeStructEnd()
13115 
 
3431 rajveer 13116 
  def validate(self):
13117 
    return
13118 
 
13119 
 
94 ashish 13120 
  def __repr__(self):
13121 
    L = ['%s=%r' % (key, value)
13122 
      for key, value in self.__dict__.iteritems()]
13123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13124 
 
13125 
  def __eq__(self, other):
13126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13127 
 
13128 
  def __ne__(self, other):
13129 
    return not (self == other)
13130 
 
690 chandransh 13131 
class resetCart_result:
13132 
  """
13133 
  Attributes:
13134 
   - success
13135 
   - scex
13136 
  """
559 chandransh 13137 
 
13138 
  thrift_spec = (
690 chandransh 13139 
    (0, TType.BOOL, 'success', None, None, ), # 0
13140 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13141 
  )
13142 
 
690 chandransh 13143 
  def __init__(self, success=None, scex=None,):
13144 
    self.success = success
13145 
    self.scex = scex
13146 
 
559 chandransh 13147 
  def read(self, iprot):
13148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13150 
      return
13151 
    iprot.readStructBegin()
13152 
    while True:
13153 
      (fname, ftype, fid) = iprot.readFieldBegin()
13154 
      if ftype == TType.STOP:
13155 
        break
690 chandransh 13156 
      if fid == 0:
13157 
        if ftype == TType.BOOL:
13158 
          self.success = iprot.readBool();
13159 
        else:
13160 
          iprot.skip(ftype)
13161 
      elif fid == 1:
13162 
        if ftype == TType.STRUCT:
13163 
          self.scex = ShoppingCartException()
13164 
          self.scex.read(iprot)
13165 
        else:
13166 
          iprot.skip(ftype)
559 chandransh 13167 
      else:
13168 
        iprot.skip(ftype)
13169 
      iprot.readFieldEnd()
13170 
    iprot.readStructEnd()
13171 
 
13172 
  def write(self, oprot):
13173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13175 
      return
690 chandransh 13176 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13177 
    if self.success is not None:
690 chandransh 13178 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13179 
      oprot.writeBool(self.success)
13180 
      oprot.writeFieldEnd()
3431 rajveer 13181 
    if self.scex is not None:
690 chandransh 13182 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13183 
      self.scex.write(oprot)
13184 
      oprot.writeFieldEnd()
559 chandransh 13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
3431 rajveer 13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
559 chandransh 13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
2981 rajveer 13203 
class getUserCount_args:
94 ashish 13204 
  """
13205 
  Attributes:
2981 rajveer 13206 
   - userType
559 chandransh 13207 
  """
13208 
 
13209 
  thrift_spec = (
13210 
    None, # 0
2981 rajveer 13211 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13212 
  )
13213 
 
2981 rajveer 13214 
  def __init__(self, userType=None,):
13215 
    self.userType = userType
559 chandransh 13216 
 
13217 
  def read(self, iprot):
13218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13220 
      return
13221 
    iprot.readStructBegin()
13222 
    while True:
13223 
      (fname, ftype, fid) = iprot.readFieldBegin()
13224 
      if ftype == TType.STOP:
13225 
        break
13226 
      if fid == 1:
2981 rajveer 13227 
        if ftype == TType.I32:
13228 
          self.userType = iprot.readI32();
559 chandransh 13229 
        else:
13230 
          iprot.skip(ftype)
13231 
      else:
13232 
        iprot.skip(ftype)
13233 
      iprot.readFieldEnd()
13234 
    iprot.readStructEnd()
13235 
 
13236 
  def write(self, oprot):
13237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13239 
      return
2981 rajveer 13240 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13241 
    if self.userType is not None:
2981 rajveer 13242 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13243 
      oprot.writeI32(self.userType)
559 chandransh 13244 
      oprot.writeFieldEnd()
13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
3431 rajveer 13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
559 chandransh 13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
2981 rajveer 13263 
class getUserCount_result:
94 ashish 13264 
  """
13265 
  Attributes:
13266 
   - success
13267 
  """
13268 
 
13269 
  thrift_spec = (
2981 rajveer 13270 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13271 
  )
13272 
 
2981 rajveer 13273 
  def __init__(self, success=None,):
94 ashish 13274 
    self.success = success
13275 
 
13276 
  def read(self, iprot):
13277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13279 
      return
13280 
    iprot.readStructBegin()
13281 
    while True:
13282 
      (fname, ftype, fid) = iprot.readFieldBegin()
13283 
      if ftype == TType.STOP:
13284 
        break
13285 
      if fid == 0:
2981 rajveer 13286 
        if ftype == TType.I64:
13287 
          self.success = iprot.readI64();
94 ashish 13288 
        else:
13289 
          iprot.skip(ftype)
13290 
      else:
13291 
        iprot.skip(ftype)
13292 
      iprot.readFieldEnd()
13293 
    iprot.readStructEnd()
13294 
 
13295 
  def write(self, oprot):
13296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13298 
      return
2981 rajveer 13299 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13300 
    if self.success is not None:
2981 rajveer 13301 
      oprot.writeFieldBegin('success', TType.I64, 0)
13302 
      oprot.writeI64(self.success)
94 ashish 13303 
      oprot.writeFieldEnd()
13304 
    oprot.writeFieldStop()
13305 
    oprot.writeStructEnd()
13306 
 
3431 rajveer 13307 
  def validate(self):
13308 
    return
13309 
 
13310 
 
94 ashish 13311 
  def __repr__(self):
13312 
    L = ['%s=%r' % (key, value)
13313 
      for key, value in self.__dict__.iteritems()]
13314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13315 
 
13316 
  def __eq__(self, other):
13317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13318 
 
13319 
  def __ne__(self, other):
13320 
    return not (self == other)
13321 
 
2981 rajveer 13322 
class getAllUsers_args:
94 ashish 13323 
  """
13324 
  Attributes:
2981 rajveer 13325 
   - userType
13326 
   - startDate
13327 
   - endDate
94 ashish 13328 
  """
13329 
 
13330 
  thrift_spec = (
13331 
    None, # 0
2981 rajveer 13332 
    (1, TType.I32, 'userType', None, None, ), # 1
13333 
    (2, TType.I64, 'startDate', None, None, ), # 2
13334 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13335 
  )
13336 
 
2981 rajveer 13337 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13338 
    self.userType = userType
13339 
    self.startDate = startDate
13340 
    self.endDate = endDate
94 ashish 13341 
 
13342 
  def read(self, iprot):
13343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13345 
      return
13346 
    iprot.readStructBegin()
13347 
    while True:
13348 
      (fname, ftype, fid) = iprot.readFieldBegin()
13349 
      if ftype == TType.STOP:
13350 
        break
13351 
      if fid == 1:
2981 rajveer 13352 
        if ftype == TType.I32:
13353 
          self.userType = iprot.readI32();
94 ashish 13354 
        else:
13355 
          iprot.skip(ftype)
13356 
      elif fid == 2:
559 chandransh 13357 
        if ftype == TType.I64:
2981 rajveer 13358 
          self.startDate = iprot.readI64();
94 ashish 13359 
        else:
13360 
          iprot.skip(ftype)
2981 rajveer 13361 
      elif fid == 3:
13362 
        if ftype == TType.I64:
13363 
          self.endDate = iprot.readI64();
13364 
        else:
13365 
          iprot.skip(ftype)
94 ashish 13366 
      else:
13367 
        iprot.skip(ftype)
13368 
      iprot.readFieldEnd()
13369 
    iprot.readStructEnd()
13370 
 
13371 
  def write(self, oprot):
13372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13374 
      return
2981 rajveer 13375 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13376 
    if self.userType is not None:
2981 rajveer 13377 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13378 
      oprot.writeI32(self.userType)
94 ashish 13379 
      oprot.writeFieldEnd()
3431 rajveer 13380 
    if self.startDate is not None:
2981 rajveer 13381 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13382 
      oprot.writeI64(self.startDate)
94 ashish 13383 
      oprot.writeFieldEnd()
3431 rajveer 13384 
    if self.endDate is not None:
2981 rajveer 13385 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13386 
      oprot.writeI64(self.endDate)
13387 
      oprot.writeFieldEnd()
94 ashish 13388 
    oprot.writeFieldStop()
13389 
    oprot.writeStructEnd()
13390 
 
3431 rajveer 13391 
  def validate(self):
13392 
    return
13393 
 
13394 
 
94 ashish 13395 
  def __repr__(self):
13396 
    L = ['%s=%r' % (key, value)
13397 
      for key, value in self.__dict__.iteritems()]
13398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13399 
 
13400 
  def __eq__(self, other):
13401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13402 
 
13403 
  def __ne__(self, other):
13404 
    return not (self == other)
13405 
 
2981 rajveer 13406 
class getAllUsers_result:
94 ashish 13407 
  """
13408 
  Attributes:
13409 
   - success
13410 
  """
13411 
 
13412 
  thrift_spec = (
2981 rajveer 13413 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13414 
  )
13415 
 
2981 rajveer 13416 
  def __init__(self, success=None,):
94 ashish 13417 
    self.success = success
13418 
 
13419 
  def read(self, iprot):
13420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13422 
      return
13423 
    iprot.readStructBegin()
13424 
    while True:
13425 
      (fname, ftype, fid) = iprot.readFieldBegin()
13426 
      if ftype == TType.STOP:
13427 
        break
13428 
      if fid == 0:
2981 rajveer 13429 
        if ftype == TType.LIST:
13430 
          self.success = []
11980 amit.gupta 13431 
          (_etype193, _size190) = iprot.readListBegin()
13432 
          for _i194 in xrange(_size190):
13433 
            _elem195 = User()
13434 
            _elem195.read(iprot)
13435 
            self.success.append(_elem195)
2981 rajveer 13436 
          iprot.readListEnd()
94 ashish 13437 
        else:
13438 
          iprot.skip(ftype)
13439 
      else:
13440 
        iprot.skip(ftype)
13441 
      iprot.readFieldEnd()
13442 
    iprot.readStructEnd()
13443 
 
13444 
  def write(self, oprot):
13445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13447 
      return
2981 rajveer 13448 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13449 
    if self.success is not None:
2981 rajveer 13450 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13451 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13452 
      for iter196 in self.success:
13453 
        iter196.write(oprot)
2981 rajveer 13454 
      oprot.writeListEnd()
94 ashish 13455 
      oprot.writeFieldEnd()
13456 
    oprot.writeFieldStop()
13457 
    oprot.writeStructEnd()
13458 
 
3431 rajveer 13459 
  def validate(self):
13460 
    return
13461 
 
13462 
 
94 ashish 13463 
  def __repr__(self):
13464 
    L = ['%s=%r' % (key, value)
13465 
      for key, value in self.__dict__.iteritems()]
13466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13467 
 
13468 
  def __eq__(self, other):
13469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13470 
 
13471 
  def __ne__(self, other):
13472 
    return not (self == other)
13473 
 
2981 rajveer 13474 
class getMyResearchItems_args:
559 chandransh 13475 
  """
13476 
  Attributes:
772 rajveer 13477 
   - userId
559 chandransh 13478 
  """
13479 
 
13480 
  thrift_spec = (
13481 
    None, # 0
772 rajveer 13482 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13483 
  )
13484 
 
772 rajveer 13485 
  def __init__(self, userId=None,):
13486 
    self.userId = userId
559 chandransh 13487 
 
13488 
  def read(self, iprot):
13489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13491 
      return
13492 
    iprot.readStructBegin()
13493 
    while True:
13494 
      (fname, ftype, fid) = iprot.readFieldBegin()
13495 
      if ftype == TType.STOP:
13496 
        break
13497 
      if fid == 1:
13498 
        if ftype == TType.I64:
772 rajveer 13499 
          self.userId = iprot.readI64();
559 chandransh 13500 
        else:
13501 
          iprot.skip(ftype)
13502 
      else:
13503 
        iprot.skip(ftype)
13504 
      iprot.readFieldEnd()
13505 
    iprot.readStructEnd()
13506 
 
13507 
  def write(self, oprot):
13508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13510 
      return
2981 rajveer 13511 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13512 
    if self.userId is not None:
772 rajveer 13513 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13514 
      oprot.writeI64(self.userId)
559 chandransh 13515 
      oprot.writeFieldEnd()
13516 
    oprot.writeFieldStop()
13517 
    oprot.writeStructEnd()
13518 
 
3431 rajveer 13519 
  def validate(self):
13520 
    return
13521 
 
13522 
 
559 chandransh 13523 
  def __repr__(self):
13524 
    L = ['%s=%r' % (key, value)
13525 
      for key, value in self.__dict__.iteritems()]
13526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13527 
 
13528 
  def __eq__(self, other):
13529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13530 
 
13531 
  def __ne__(self, other):
13532 
    return not (self == other)
13533 
 
2981 rajveer 13534 
class getMyResearchItems_result:
559 chandransh 13535 
  """
13536 
  Attributes:
130 ashish 13537 
   - success
559 chandransh 13538 
   - scx
130 ashish 13539 
  """
13540 
 
13541 
  thrift_spec = (
2981 rajveer 13542 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13543 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13544 
  )
13545 
 
559 chandransh 13546 
  def __init__(self, success=None, scx=None,):
130 ashish 13547 
    self.success = success
559 chandransh 13548 
    self.scx = scx
130 ashish 13549 
 
13550 
  def read(self, iprot):
13551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13553 
      return
13554 
    iprot.readStructBegin()
13555 
    while True:
13556 
      (fname, ftype, fid) = iprot.readFieldBegin()
13557 
      if ftype == TType.STOP:
13558 
        break
13559 
      if fid == 0:
2981 rajveer 13560 
        if ftype == TType.LIST:
13561 
          self.success = []
11980 amit.gupta 13562 
          (_etype200, _size197) = iprot.readListBegin()
13563 
          for _i201 in xrange(_size197):
13564 
            _elem202 = iprot.readI64();
13565 
            self.success.append(_elem202)
2981 rajveer 13566 
          iprot.readListEnd()
130 ashish 13567 
        else:
13568 
          iprot.skip(ftype)
13569 
      elif fid == 1:
13570 
        if ftype == TType.STRUCT:
559 chandransh 13571 
          self.scx = WidgetException()
13572 
          self.scx.read(iprot)
130 ashish 13573 
        else:
13574 
          iprot.skip(ftype)
13575 
      else:
13576 
        iprot.skip(ftype)
13577 
      iprot.readFieldEnd()
13578 
    iprot.readStructEnd()
13579 
 
13580 
  def write(self, oprot):
13581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13583 
      return
2981 rajveer 13584 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13585 
    if self.success is not None:
2981 rajveer 13586 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13587 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13588 
      for iter203 in self.success:
13589 
        oprot.writeI64(iter203)
2981 rajveer 13590 
      oprot.writeListEnd()
130 ashish 13591 
      oprot.writeFieldEnd()
3431 rajveer 13592 
    if self.scx is not None:
559 chandransh 13593 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13594 
      self.scx.write(oprot)
130 ashish 13595 
      oprot.writeFieldEnd()
13596 
    oprot.writeFieldStop()
13597 
    oprot.writeStructEnd()
13598 
 
3431 rajveer 13599 
  def validate(self):
13600 
    return
13601 
 
13602 
 
130 ashish 13603 
  def __repr__(self):
13604 
    L = ['%s=%r' % (key, value)
13605 
      for key, value in self.__dict__.iteritems()]
13606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13607 
 
13608 
  def __eq__(self, other):
13609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13610 
 
13611 
  def __ne__(self, other):
13612 
    return not (self == other)
13613 
 
2981 rajveer 13614 
class updateMyResearch_args:
130 ashish 13615 
  """
13616 
  Attributes:
2981 rajveer 13617 
   - userId
13618 
   - itemId
130 ashish 13619 
  """
13620 
 
13621 
  thrift_spec = (
13622 
    None, # 0
2981 rajveer 13623 
    (1, TType.I64, 'userId', None, None, ), # 1
13624 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13625 
  )
13626 
 
2981 rajveer 13627 
  def __init__(self, userId=None, itemId=None,):
13628 
    self.userId = userId
13629 
    self.itemId = itemId
130 ashish 13630 
 
13631 
  def read(self, iprot):
13632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13634 
      return
13635 
    iprot.readStructBegin()
13636 
    while True:
13637 
      (fname, ftype, fid) = iprot.readFieldBegin()
13638 
      if ftype == TType.STOP:
13639 
        break
13640 
      if fid == 1:
559 chandransh 13641 
        if ftype == TType.I64:
2981 rajveer 13642 
          self.userId = iprot.readI64();
130 ashish 13643 
        else:
13644 
          iprot.skip(ftype)
13645 
      elif fid == 2:
559 chandransh 13646 
        if ftype == TType.I64:
2981 rajveer 13647 
          self.itemId = iprot.readI64();
559 chandransh 13648 
        else:
13649 
          iprot.skip(ftype)
130 ashish 13650 
      else:
13651 
        iprot.skip(ftype)
13652 
      iprot.readFieldEnd()
13653 
    iprot.readStructEnd()
13654 
 
13655 
  def write(self, oprot):
13656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13658 
      return
2981 rajveer 13659 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13660 
    if self.userId is not None:
2981 rajveer 13661 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13662 
      oprot.writeI64(self.userId)
130 ashish 13663 
      oprot.writeFieldEnd()
3431 rajveer 13664 
    if self.itemId is not None:
2981 rajveer 13665 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13666 
      oprot.writeI64(self.itemId)
130 ashish 13667 
      oprot.writeFieldEnd()
13668 
    oprot.writeFieldStop()
13669 
    oprot.writeStructEnd()
13670 
 
3431 rajveer 13671 
  def validate(self):
13672 
    return
13673 
 
13674 
 
130 ashish 13675 
  def __repr__(self):
13676 
    L = ['%s=%r' % (key, value)
13677 
      for key, value in self.__dict__.iteritems()]
13678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13679 
 
13680 
  def __eq__(self, other):
13681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13682 
 
13683 
  def __ne__(self, other):
13684 
    return not (self == other)
13685 
 
2981 rajveer 13686 
class updateMyResearch_result:
13687 
  """
13688 
  Attributes:
13689 
   - success
13690 
   - scx
13691 
  """
559 chandransh 13692 
 
13693 
  thrift_spec = (
2981 rajveer 13694 
    (0, TType.BOOL, 'success', None, None, ), # 0
13695 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13696 
  )
13697 
 
2981 rajveer 13698 
  def __init__(self, success=None, scx=None,):
13699 
    self.success = success
13700 
    self.scx = scx
13701 
 
559 chandransh 13702 
  def read(self, iprot):
13703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13705 
      return
13706 
    iprot.readStructBegin()
13707 
    while True:
13708 
      (fname, ftype, fid) = iprot.readFieldBegin()
13709 
      if ftype == TType.STOP:
13710 
        break
2981 rajveer 13711 
      if fid == 0:
13712 
        if ftype == TType.BOOL:
13713 
          self.success = iprot.readBool();
13714 
        else:
13715 
          iprot.skip(ftype)
13716 
      elif fid == 1:
13717 
        if ftype == TType.STRUCT:
13718 
          self.scx = WidgetException()
13719 
          self.scx.read(iprot)
13720 
        else:
13721 
          iprot.skip(ftype)
559 chandransh 13722 
      else:
13723 
        iprot.skip(ftype)
13724 
      iprot.readFieldEnd()
13725 
    iprot.readStructEnd()
13726 
 
13727 
  def write(self, oprot):
13728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13730 
      return
2981 rajveer 13731 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13732 
    if self.success is not None:
2981 rajveer 13733 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13734 
      oprot.writeBool(self.success)
13735 
      oprot.writeFieldEnd()
3431 rajveer 13736 
    if self.scx is not None:
2981 rajveer 13737 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13738 
      self.scx.write(oprot)
13739 
      oprot.writeFieldEnd()
559 chandransh 13740 
    oprot.writeFieldStop()
13741 
    oprot.writeStructEnd()
13742 
 
3431 rajveer 13743 
  def validate(self):
13744 
    return
13745 
 
13746 
 
559 chandransh 13747 
  def __repr__(self):
13748 
    L = ['%s=%r' % (key, value)
13749 
      for key, value in self.__dict__.iteritems()]
13750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13751 
 
13752 
  def __eq__(self, other):
13753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13754 
 
13755 
  def __ne__(self, other):
13756 
    return not (self == other)
13757 
 
2981 rajveer 13758 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13759 
  """
13760 
  Attributes:
2981 rajveer 13761 
   - userId
13762 
   - itemId
1596 ankur.sing 13763 
  """
559 chandransh 13764 
 
1596 ankur.sing 13765 
  thrift_spec = (
13766 
    None, # 0
2981 rajveer 13767 
    (1, TType.I64, 'userId', None, None, ), # 1
13768 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13769 
  )
13770 
 
2981 rajveer 13771 
  def __init__(self, userId=None, itemId=None,):
13772 
    self.userId = userId
13773 
    self.itemId = itemId
1596 ankur.sing 13774 
 
13775 
  def read(self, iprot):
13776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13778 
      return
13779 
    iprot.readStructBegin()
13780 
    while True:
13781 
      (fname, ftype, fid) = iprot.readFieldBegin()
13782 
      if ftype == TType.STOP:
13783 
        break
13784 
      if fid == 1:
2981 rajveer 13785 
        if ftype == TType.I64:
13786 
          self.userId = iprot.readI64();
1596 ankur.sing 13787 
        else:
13788 
          iprot.skip(ftype)
2981 rajveer 13789 
      elif fid == 2:
13790 
        if ftype == TType.I64:
13791 
          self.itemId = iprot.readI64();
13792 
        else:
13793 
          iprot.skip(ftype)
1596 ankur.sing 13794 
      else:
13795 
        iprot.skip(ftype)
13796 
      iprot.readFieldEnd()
13797 
    iprot.readStructEnd()
13798 
 
13799 
  def write(self, oprot):
13800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13802 
      return
2981 rajveer 13803 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13804 
    if self.userId is not None:
2981 rajveer 13805 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13806 
      oprot.writeI64(self.userId)
1596 ankur.sing 13807 
      oprot.writeFieldEnd()
3431 rajveer 13808 
    if self.itemId is not None:
2981 rajveer 13809 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13810 
      oprot.writeI64(self.itemId)
13811 
      oprot.writeFieldEnd()
1596 ankur.sing 13812 
    oprot.writeFieldStop()
13813 
    oprot.writeStructEnd()
13814 
 
3431 rajveer 13815 
  def validate(self):
13816 
    return
13817 
 
13818 
 
1596 ankur.sing 13819 
  def __repr__(self):
13820 
    L = ['%s=%r' % (key, value)
13821 
      for key, value in self.__dict__.iteritems()]
13822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13823 
 
13824 
  def __eq__(self, other):
13825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13826 
 
13827 
  def __ne__(self, other):
13828 
    return not (self == other)
13829 
 
2981 rajveer 13830 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13831 
  """
13832 
  Attributes:
2981 rajveer 13833 
   - scx
1596 ankur.sing 13834 
  """
13835 
 
13836 
  thrift_spec = (
2981 rajveer 13837 
    None, # 0
13838 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13839 
  )
13840 
 
2981 rajveer 13841 
  def __init__(self, scx=None,):
13842 
    self.scx = scx
1596 ankur.sing 13843 
 
13844 
  def read(self, iprot):
13845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13847 
      return
13848 
    iprot.readStructBegin()
13849 
    while True:
13850 
      (fname, ftype, fid) = iprot.readFieldBegin()
13851 
      if ftype == TType.STOP:
13852 
        break
2981 rajveer 13853 
      if fid == 1:
13854 
        if ftype == TType.STRUCT:
13855 
          self.scx = WidgetException()
13856 
          self.scx.read(iprot)
1596 ankur.sing 13857 
        else:
13858 
          iprot.skip(ftype)
13859 
      else:
13860 
        iprot.skip(ftype)
13861 
      iprot.readFieldEnd()
13862 
    iprot.readStructEnd()
13863 
 
13864 
  def write(self, oprot):
13865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13867 
      return
2981 rajveer 13868 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13869 
    if self.scx is not None:
2981 rajveer 13870 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13871 
      self.scx.write(oprot)
1596 ankur.sing 13872 
      oprot.writeFieldEnd()
13873 
    oprot.writeFieldStop()
13874 
    oprot.writeStructEnd()
13875 
 
3431 rajveer 13876 
  def validate(self):
13877 
    return
13878 
 
13879 
 
1596 ankur.sing 13880 
  def __repr__(self):
13881 
    L = ['%s=%r' % (key, value)
13882 
      for key, value in self.__dict__.iteritems()]
13883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13884 
 
13885 
  def __eq__(self, other):
13886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13887 
 
13888 
  def __ne__(self, other):
13889 
    return not (self == other)
13890 
 
2981 rajveer 13891 
class getBrowseHistoryItems_args:
1673 ankur.sing 13892 
  """
13893 
  Attributes:
2981 rajveer 13894 
   - userId
1673 ankur.sing 13895 
  """
1596 ankur.sing 13896 
 
1673 ankur.sing 13897 
  thrift_spec = (
13898 
    None, # 0
2981 rajveer 13899 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13900 
  )
13901 
 
2981 rajveer 13902 
  def __init__(self, userId=None,):
13903 
    self.userId = userId
1673 ankur.sing 13904 
 
13905 
  def read(self, iprot):
13906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13908 
      return
13909 
    iprot.readStructBegin()
13910 
    while True:
13911 
      (fname, ftype, fid) = iprot.readFieldBegin()
13912 
      if ftype == TType.STOP:
13913 
        break
13914 
      if fid == 1:
1891 ankur.sing 13915 
        if ftype == TType.I64:
2981 rajveer 13916 
          self.userId = iprot.readI64();
1891 ankur.sing 13917 
        else:
13918 
          iprot.skip(ftype)
1673 ankur.sing 13919 
      else:
13920 
        iprot.skip(ftype)
13921 
      iprot.readFieldEnd()
13922 
    iprot.readStructEnd()
13923 
 
13924 
  def write(self, oprot):
13925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13927 
      return
2981 rajveer 13928 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13929 
    if self.userId is not None:
2981 rajveer 13930 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13931 
      oprot.writeI64(self.userId)
1673 ankur.sing 13932 
      oprot.writeFieldEnd()
13933 
    oprot.writeFieldStop()
13934 
    oprot.writeStructEnd()
13935 
 
3431 rajveer 13936 
  def validate(self):
13937 
    return
13938 
 
13939 
 
1673 ankur.sing 13940 
  def __repr__(self):
13941 
    L = ['%s=%r' % (key, value)
13942 
      for key, value in self.__dict__.iteritems()]
13943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13944 
 
13945 
  def __eq__(self, other):
13946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13947 
 
13948 
  def __ne__(self, other):
13949 
    return not (self == other)
13950 
 
2981 rajveer 13951 
class getBrowseHistoryItems_result:
1673 ankur.sing 13952 
  """
13953 
  Attributes:
13954 
   - success
2981 rajveer 13955 
   - scx
1673 ankur.sing 13956 
  """
13957 
 
13958 
  thrift_spec = (
2981 rajveer 13959 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13960 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13961 
  )
13962 
 
2981 rajveer 13963 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13964 
    self.success = success
2981 rajveer 13965 
    self.scx = scx
1673 ankur.sing 13966 
 
13967 
  def read(self, iprot):
13968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13970 
      return
13971 
    iprot.readStructBegin()
13972 
    while True:
13973 
      (fname, ftype, fid) = iprot.readFieldBegin()
13974 
      if ftype == TType.STOP:
13975 
        break
13976 
      if fid == 0:
13977 
        if ftype == TType.LIST:
13978 
          self.success = []
11980 amit.gupta 13979 
          (_etype207, _size204) = iprot.readListBegin()
13980 
          for _i208 in xrange(_size204):
13981 
            _elem209 = iprot.readI64();
13982 
            self.success.append(_elem209)
1673 ankur.sing 13983 
          iprot.readListEnd()
13984 
        else:
13985 
          iprot.skip(ftype)
2981 rajveer 13986 
      elif fid == 1:
13987 
        if ftype == TType.STRUCT:
13988 
          self.scx = WidgetException()
13989 
          self.scx.read(iprot)
13990 
        else:
13991 
          iprot.skip(ftype)
1673 ankur.sing 13992 
      else:
13993 
        iprot.skip(ftype)
13994 
      iprot.readFieldEnd()
13995 
    iprot.readStructEnd()
13996 
 
13997 
  def write(self, oprot):
13998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14000 
      return
2981 rajveer 14001 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 14002 
    if self.success is not None:
1673 ankur.sing 14003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 14004 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14005 
      for iter210 in self.success:
14006 
        oprot.writeI64(iter210)
1673 ankur.sing 14007 
      oprot.writeListEnd()
14008 
      oprot.writeFieldEnd()
3431 rajveer 14009 
    if self.scx is not None:
2981 rajveer 14010 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14011 
      self.scx.write(oprot)
2642 varun.gupt 14012 
      oprot.writeFieldEnd()
14013 
    oprot.writeFieldStop()
14014 
    oprot.writeStructEnd()
14015 
 
3431 rajveer 14016 
  def validate(self):
14017 
    return
14018 
 
14019 
 
2642 varun.gupt 14020 
  def __repr__(self):
14021 
    L = ['%s=%r' % (key, value)
14022 
      for key, value in self.__dict__.iteritems()]
14023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14024 
 
14025 
  def __eq__(self, other):
14026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14027 
 
14028 
  def __ne__(self, other):
14029 
    return not (self == other)
14030 
 
2981 rajveer 14031 
class updateBrowseHistory_args:
2642 varun.gupt 14032 
  """
14033 
  Attributes:
2981 rajveer 14034 
   - userId
14035 
   - itemId
2642 varun.gupt 14036 
  """
14037 
 
14038 
  thrift_spec = (
14039 
    None, # 0
2981 rajveer 14040 
    (1, TType.I64, 'userId', None, None, ), # 1
14041 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 14042 
  )
14043 
 
2981 rajveer 14044 
  def __init__(self, userId=None, itemId=None,):
14045 
    self.userId = userId
14046 
    self.itemId = itemId
2642 varun.gupt 14047 
 
14048 
  def read(self, iprot):
14049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14051 
      return
14052 
    iprot.readStructBegin()
14053 
    while True:
14054 
      (fname, ftype, fid) = iprot.readFieldBegin()
14055 
      if ftype == TType.STOP:
14056 
        break
14057 
      if fid == 1:
14058 
        if ftype == TType.I64:
2981 rajveer 14059 
          self.userId = iprot.readI64();
2642 varun.gupt 14060 
        else:
14061 
          iprot.skip(ftype)
14062 
      elif fid == 2:
14063 
        if ftype == TType.I64:
2981 rajveer 14064 
          self.itemId = iprot.readI64();
2642 varun.gupt 14065 
        else:
14066 
          iprot.skip(ftype)
14067 
      else:
14068 
        iprot.skip(ftype)
14069 
      iprot.readFieldEnd()
14070 
    iprot.readStructEnd()
14071 
 
14072 
  def write(self, oprot):
14073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14075 
      return
2981 rajveer 14076 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14077 
    if self.userId is not None:
2981 rajveer 14078 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14079 
      oprot.writeI64(self.userId)
2642 varun.gupt 14080 
      oprot.writeFieldEnd()
3431 rajveer 14081 
    if self.itemId is not None:
2981 rajveer 14082 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14083 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14084 
      oprot.writeFieldEnd()
14085 
    oprot.writeFieldStop()
14086 
    oprot.writeStructEnd()
14087 
 
3431 rajveer 14088 
  def validate(self):
14089 
    return
14090 
 
14091 
 
2642 varun.gupt 14092 
  def __repr__(self):
14093 
    L = ['%s=%r' % (key, value)
14094 
      for key, value in self.__dict__.iteritems()]
14095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14096 
 
14097 
  def __eq__(self, other):
14098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14099 
 
14100 
  def __ne__(self, other):
14101 
    return not (self == other)
14102 
 
2981 rajveer 14103 
class updateBrowseHistory_result:
2642 varun.gupt 14104 
 
14105 
  thrift_spec = (
14106 
  )
14107 
 
14108 
  def read(self, iprot):
14109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14111 
      return
14112 
    iprot.readStructBegin()
14113 
    while True:
14114 
      (fname, ftype, fid) = iprot.readFieldBegin()
14115 
      if ftype == TType.STOP:
14116 
        break
14117 
      else:
14118 
        iprot.skip(ftype)
14119 
      iprot.readFieldEnd()
14120 
    iprot.readStructEnd()
14121 
 
14122 
  def write(self, oprot):
14123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14125 
      return
2981 rajveer 14126 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14127 
    oprot.writeFieldStop()
14128 
    oprot.writeStructEnd()
14129 
 
3431 rajveer 14130 
  def validate(self):
14131 
    return
14132 
 
14133 
 
2642 varun.gupt 14134 
  def __repr__(self):
14135 
    L = ['%s=%r' % (key, value)
14136 
      for key, value in self.__dict__.iteritems()]
14137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14138 
 
14139 
  def __eq__(self, other):
14140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14141 
 
14142 
  def __ne__(self, other):
14143 
    return not (self == other)
14144 
 
3385 varun.gupt 14145 
class getCartsWithCouponCount_args:
14146 
  """
14147 
  Attributes:
14148 
   - couponCode
14149 
  """
2642 varun.gupt 14150 
 
3385 varun.gupt 14151 
  thrift_spec = (
14152 
    None, # 0
14153 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14154 
  )
14155 
 
14156 
  def __init__(self, couponCode=None,):
14157 
    self.couponCode = couponCode
14158 
 
14159 
  def read(self, iprot):
14160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14162 
      return
14163 
    iprot.readStructBegin()
14164 
    while True:
14165 
      (fname, ftype, fid) = iprot.readFieldBegin()
14166 
      if ftype == TType.STOP:
14167 
        break
14168 
      if fid == 1:
14169 
        if ftype == TType.STRING:
14170 
          self.couponCode = iprot.readString();
14171 
        else:
14172 
          iprot.skip(ftype)
14173 
      else:
14174 
        iprot.skip(ftype)
14175 
      iprot.readFieldEnd()
14176 
    iprot.readStructEnd()
14177 
 
14178 
  def write(self, oprot):
14179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14181 
      return
14182 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14183 
    if self.couponCode is not None:
3385 varun.gupt 14184 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14185 
      oprot.writeString(self.couponCode)
14186 
      oprot.writeFieldEnd()
14187 
    oprot.writeFieldStop()
14188 
    oprot.writeStructEnd()
14189 
 
3431 rajveer 14190 
  def validate(self):
14191 
    return
14192 
 
14193 
 
3385 varun.gupt 14194 
  def __repr__(self):
14195 
    L = ['%s=%r' % (key, value)
14196 
      for key, value in self.__dict__.iteritems()]
14197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14198 
 
14199 
  def __eq__(self, other):
14200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14201 
 
14202 
  def __ne__(self, other):
14203 
    return not (self == other)
14204 
 
14205 
class getCartsWithCouponCount_result:
14206 
  """
14207 
  Attributes:
14208 
   - success
14209 
  """
14210 
 
14211 
  thrift_spec = (
14212 
    (0, TType.I64, 'success', None, None, ), # 0
14213 
  )
14214 
 
14215 
  def __init__(self, success=None,):
14216 
    self.success = success
14217 
 
14218 
  def read(self, iprot):
14219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14221 
      return
14222 
    iprot.readStructBegin()
14223 
    while True:
14224 
      (fname, ftype, fid) = iprot.readFieldBegin()
14225 
      if ftype == TType.STOP:
14226 
        break
14227 
      if fid == 0:
14228 
        if ftype == TType.I64:
14229 
          self.success = iprot.readI64();
14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      else:
14233 
        iprot.skip(ftype)
14234 
      iprot.readFieldEnd()
14235 
    iprot.readStructEnd()
14236 
 
14237 
  def write(self, oprot):
14238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14240 
      return
14241 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14242 
    if self.success is not None:
3385 varun.gupt 14243 
      oprot.writeFieldBegin('success', TType.I64, 0)
14244 
      oprot.writeI64(self.success)
14245 
      oprot.writeFieldEnd()
14246 
    oprot.writeFieldStop()
14247 
    oprot.writeStructEnd()
14248 
 
3431 rajveer 14249 
  def validate(self):
14250 
    return
14251 
 
14252 
 
3385 varun.gupt 14253 
  def __repr__(self):
14254 
    L = ['%s=%r' % (key, value)
14255 
      for key, value in self.__dict__.iteritems()]
14256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14257 
 
14258 
  def __eq__(self, other):
14259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14260 
 
14261 
  def __ne__(self, other):
14262 
    return not (self == other)
3499 mandeep.dh 14263 
 
14264 
class increaseTrustLevel_args:
14265 
  """
14266 
  Attributes:
14267 
   - userId
14268 
   - trustLevelDelta
14269 
  """
14270 
 
14271 
  thrift_spec = (
14272 
    None, # 0
14273 
    (1, TType.I64, 'userId', None, None, ), # 1
14274 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14275 
  )
14276 
 
14277 
  def __init__(self, userId=None, trustLevelDelta=None,):
14278 
    self.userId = userId
14279 
    self.trustLevelDelta = trustLevelDelta
14280 
 
14281 
  def read(self, iprot):
14282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14284 
      return
14285 
    iprot.readStructBegin()
14286 
    while True:
14287 
      (fname, ftype, fid) = iprot.readFieldBegin()
14288 
      if ftype == TType.STOP:
14289 
        break
14290 
      if fid == 1:
14291 
        if ftype == TType.I64:
14292 
          self.userId = iprot.readI64();
14293 
        else:
14294 
          iprot.skip(ftype)
14295 
      elif fid == 2:
14296 
        if ftype == TType.DOUBLE:
14297 
          self.trustLevelDelta = iprot.readDouble();
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
14309 
    oprot.writeStructBegin('increaseTrustLevel_args')
14310 
    if self.userId is not None:
14311 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14312 
      oprot.writeI64(self.userId)
14313 
      oprot.writeFieldEnd()
14314 
    if self.trustLevelDelta is not None:
14315 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14316 
      oprot.writeDouble(self.trustLevelDelta)
14317 
      oprot.writeFieldEnd()
14318 
    oprot.writeFieldStop()
14319 
    oprot.writeStructEnd()
14320 
 
14321 
  def validate(self):
14322 
    return
14323 
 
14324 
 
14325 
  def __repr__(self):
14326 
    L = ['%s=%r' % (key, value)
14327 
      for key, value in self.__dict__.iteritems()]
14328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14329 
 
14330 
  def __eq__(self, other):
14331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14332 
 
14333 
  def __ne__(self, other):
14334 
    return not (self == other)
4668 varun.gupt 14335 
 
5407 amar.kumar 14336 
class getTrustLevel_args:
14337 
  """
14338 
  Attributes:
14339 
   - userId
14340 
  """
14341 
 
14342 
  thrift_spec = (
14343 
    None, # 0
14344 
    (1, TType.I64, 'userId', None, None, ), # 1
14345 
  )
14346 
 
14347 
  def __init__(self, userId=None,):
14348 
    self.userId = userId
14349 
 
14350 
  def read(self, iprot):
14351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14353 
      return
14354 
    iprot.readStructBegin()
14355 
    while True:
14356 
      (fname, ftype, fid) = iprot.readFieldBegin()
14357 
      if ftype == TType.STOP:
14358 
        break
14359 
      if fid == 1:
14360 
        if ftype == TType.I64:
14361 
          self.userId = iprot.readI64();
14362 
        else:
14363 
          iprot.skip(ftype)
14364 
      else:
14365 
        iprot.skip(ftype)
14366 
      iprot.readFieldEnd()
14367 
    iprot.readStructEnd()
14368 
 
14369 
  def write(self, oprot):
14370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14372 
      return
14373 
    oprot.writeStructBegin('getTrustLevel_args')
14374 
    if self.userId is not None:
14375 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14376 
      oprot.writeI64(self.userId)
14377 
      oprot.writeFieldEnd()
14378 
    oprot.writeFieldStop()
14379 
    oprot.writeStructEnd()
14380 
 
14381 
  def validate(self):
14382 
    return
14383 
 
14384 
 
14385 
  def __repr__(self):
14386 
    L = ['%s=%r' % (key, value)
14387 
      for key, value in self.__dict__.iteritems()]
14388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14389 
 
14390 
  def __eq__(self, other):
14391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14392 
 
14393 
  def __ne__(self, other):
14394 
    return not (self == other)
14395 
 
14396 
class getTrustLevel_result:
14397 
  """
14398 
  Attributes:
14399 
   - success
14400 
  """
14401 
 
14402 
  thrift_spec = (
14403 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14404 
  )
14405 
 
14406 
  def __init__(self, success=None,):
14407 
    self.success = success
14408 
 
14409 
  def read(self, iprot):
14410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14412 
      return
14413 
    iprot.readStructBegin()
14414 
    while True:
14415 
      (fname, ftype, fid) = iprot.readFieldBegin()
14416 
      if ftype == TType.STOP:
14417 
        break
14418 
      if fid == 0:
14419 
        if ftype == TType.DOUBLE:
14420 
          self.success = iprot.readDouble();
14421 
        else:
14422 
          iprot.skip(ftype)
14423 
      else:
14424 
        iprot.skip(ftype)
14425 
      iprot.readFieldEnd()
14426 
    iprot.readStructEnd()
14427 
 
14428 
  def write(self, oprot):
14429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14431 
      return
14432 
    oprot.writeStructBegin('getTrustLevel_result')
14433 
    if self.success is not None:
14434 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14435 
      oprot.writeDouble(self.success)
14436 
      oprot.writeFieldEnd()
14437 
    oprot.writeFieldStop()
14438 
    oprot.writeStructEnd()
14439 
 
14440 
  def validate(self):
14441 
    return
14442 
 
14443 
 
14444 
  def __repr__(self):
14445 
    L = ['%s=%r' % (key, value)
14446 
      for key, value in self.__dict__.iteritems()]
14447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14448 
 
14449 
  def __eq__(self, other):
14450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14451 
 
14452 
  def __ne__(self, other):
14453 
    return not (self == other)
14454 
 
4668 varun.gupt 14455 
class showCODOption_args:
14456 
  """
14457 
  Attributes:
14458 
   - cartId
14459 
   - sourceId
14460 
   - pincode
14461 
  """
14462 
 
14463 
  thrift_spec = (
14464 
    None, # 0
14465 
    (1, TType.I64, 'cartId', None, None, ), # 1
14466 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14467 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14468 
  )
14469 
 
14470 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14471 
    self.cartId = cartId
14472 
    self.sourceId = sourceId
14473 
    self.pincode = pincode
14474 
 
14475 
  def read(self, iprot):
14476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14478 
      return
14479 
    iprot.readStructBegin()
14480 
    while True:
14481 
      (fname, ftype, fid) = iprot.readFieldBegin()
14482 
      if ftype == TType.STOP:
14483 
        break
14484 
      if fid == 1:
14485 
        if ftype == TType.I64:
14486 
          self.cartId = iprot.readI64();
14487 
        else:
14488 
          iprot.skip(ftype)
14489 
      elif fid == 2:
14490 
        if ftype == TType.I64:
14491 
          self.sourceId = iprot.readI64();
14492 
        else:
14493 
          iprot.skip(ftype)
14494 
      elif fid == 3:
14495 
        if ftype == TType.STRING:
14496 
          self.pincode = iprot.readString();
14497 
        else:
14498 
          iprot.skip(ftype)
14499 
      else:
14500 
        iprot.skip(ftype)
14501 
      iprot.readFieldEnd()
14502 
    iprot.readStructEnd()
14503 
 
14504 
  def write(self, oprot):
14505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14507 
      return
14508 
    oprot.writeStructBegin('showCODOption_args')
14509 
    if self.cartId is not None:
14510 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14511 
      oprot.writeI64(self.cartId)
14512 
      oprot.writeFieldEnd()
14513 
    if self.sourceId is not None:
14514 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14515 
      oprot.writeI64(self.sourceId)
14516 
      oprot.writeFieldEnd()
14517 
    if self.pincode is not None:
14518 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14519 
      oprot.writeString(self.pincode)
14520 
      oprot.writeFieldEnd()
14521 
    oprot.writeFieldStop()
14522 
    oprot.writeStructEnd()
14523 
 
14524 
  def validate(self):
14525 
    return
14526 
 
14527 
 
14528 
  def __repr__(self):
14529 
    L = ['%s=%r' % (key, value)
14530 
      for key, value in self.__dict__.iteritems()]
14531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14532 
 
14533 
  def __eq__(self, other):
14534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14535 
 
14536 
  def __ne__(self, other):
14537 
    return not (self == other)
14538 
 
14539 
class showCODOption_result:
14540 
  """
14541 
  Attributes:
14542 
   - success
14543 
  """
14544 
 
14545 
  thrift_spec = (
14546 
    (0, TType.BOOL, 'success', None, None, ), # 0
14547 
  )
14548 
 
14549 
  def __init__(self, success=None,):
14550 
    self.success = success
14551 
 
14552 
  def read(self, iprot):
14553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14555 
      return
14556 
    iprot.readStructBegin()
14557 
    while True:
14558 
      (fname, ftype, fid) = iprot.readFieldBegin()
14559 
      if ftype == TType.STOP:
14560 
        break
14561 
      if fid == 0:
14562 
        if ftype == TType.BOOL:
14563 
          self.success = iprot.readBool();
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('showCODOption_result')
14576 
    if self.success is not None:
14577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14578 
      oprot.writeBool(self.success)
14579 
      oprot.writeFieldEnd()
14580 
    oprot.writeFieldStop()
14581 
    oprot.writeStructEnd()
14582 
 
14583 
  def validate(self):
14584 
    return
14585 
 
14586 
 
14587 
  def __repr__(self):
14588 
    L = ['%s=%r' % (key, value)
14589 
      for key, value in self.__dict__.iteritems()]
14590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14591 
 
14592 
  def __eq__(self, other):
14593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14594 
 
14595 
  def __ne__(self, other):
14596 
    return not (self == other)
5623 anupam.sin 14597 
 
14598 
class getUserEmails_args:
14599 
  """
14600 
  Attributes:
14601 
   - startDate
14602 
   - endDate
14603 
  """
14604 
 
14605 
  thrift_spec = (
14606 
    None, # 0
14607 
    (1, TType.I64, 'startDate', None, None, ), # 1
14608 
    (2, TType.I64, 'endDate', None, None, ), # 2
14609 
  )
14610 
 
14611 
  def __init__(self, startDate=None, endDate=None,):
14612 
    self.startDate = startDate
14613 
    self.endDate = endDate
14614 
 
14615 
  def read(self, iprot):
14616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14618 
      return
14619 
    iprot.readStructBegin()
14620 
    while True:
14621 
      (fname, ftype, fid) = iprot.readFieldBegin()
14622 
      if ftype == TType.STOP:
14623 
        break
14624 
      if fid == 1:
14625 
        if ftype == TType.I64:
14626 
          self.startDate = iprot.readI64();
14627 
        else:
14628 
          iprot.skip(ftype)
14629 
      elif fid == 2:
14630 
        if ftype == TType.I64:
14631 
          self.endDate = iprot.readI64();
14632 
        else:
14633 
          iprot.skip(ftype)
14634 
      else:
14635 
        iprot.skip(ftype)
14636 
      iprot.readFieldEnd()
14637 
    iprot.readStructEnd()
14638 
 
14639 
  def write(self, oprot):
14640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14642 
      return
14643 
    oprot.writeStructBegin('getUserEmails_args')
14644 
    if self.startDate is not None:
14645 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14646 
      oprot.writeI64(self.startDate)
14647 
      oprot.writeFieldEnd()
14648 
    if self.endDate is not None:
14649 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14650 
      oprot.writeI64(self.endDate)
14651 
      oprot.writeFieldEnd()
14652 
    oprot.writeFieldStop()
14653 
    oprot.writeStructEnd()
14654 
 
14655 
  def validate(self):
14656 
    return
14657 
 
14658 
 
14659 
  def __repr__(self):
14660 
    L = ['%s=%r' % (key, value)
14661 
      for key, value in self.__dict__.iteritems()]
14662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14663 
 
14664 
  def __eq__(self, other):
14665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14666 
 
14667 
  def __ne__(self, other):
14668 
    return not (self == other)
14669 
 
14670 
class getUserEmails_result:
14671 
  """
14672 
  Attributes:
14673 
   - success
14674 
  """
14675 
 
14676 
  thrift_spec = (
14677 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14678 
  )
14679 
 
14680 
  def __init__(self, success=None,):
14681 
    self.success = success
14682 
 
14683 
  def read(self, iprot):
14684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14686 
      return
14687 
    iprot.readStructBegin()
14688 
    while True:
14689 
      (fname, ftype, fid) = iprot.readFieldBegin()
14690 
      if ftype == TType.STOP:
14691 
        break
14692 
      if fid == 0:
14693 
        if ftype == TType.LIST:
14694 
          self.success = []
11980 amit.gupta 14695 
          (_etype214, _size211) = iprot.readListBegin()
14696 
          for _i215 in xrange(_size211):
14697 
            _elem216 = iprot.readString();
14698 
            self.success.append(_elem216)
5623 anupam.sin 14699 
          iprot.readListEnd()
14700 
        else:
14701 
          iprot.skip(ftype)
14702 
      else:
14703 
        iprot.skip(ftype)
14704 
      iprot.readFieldEnd()
14705 
    iprot.readStructEnd()
14706 
 
14707 
  def write(self, oprot):
14708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14710 
      return
14711 
    oprot.writeStructBegin('getUserEmails_result')
14712 
    if self.success is not None:
14713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14714 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14715 
      for iter217 in self.success:
14716 
        oprot.writeString(iter217)
5623 anupam.sin 14717 
      oprot.writeListEnd()
14718 
      oprot.writeFieldEnd()
14719 
    oprot.writeFieldStop()
14720 
    oprot.writeStructEnd()
14721 
 
14722 
  def validate(self):
14723 
    return
14724 
 
14725 
 
14726 
  def __repr__(self):
14727 
    L = ['%s=%r' % (key, value)
14728 
      for key, value in self.__dict__.iteritems()]
14729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14730 
 
14731 
  def __eq__(self, other):
14732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14733 
 
14734 
  def __ne__(self, other):
14735 
    return not (self == other)
6821 amar.kumar 14736 
 
6903 anupam.sin 14737 
class insureItem_args:
14738 
  """
14739 
  Attributes:
14740 
   - itemId
14741 
   - cartId
14742 
   - toInsure
9299 kshitij.so 14743 
   - insurerType
6903 anupam.sin 14744 
  """
14745 
 
14746 
  thrift_spec = (
14747 
    None, # 0
14748 
    (1, TType.I64, 'itemId', None, None, ), # 1
14749 
    (2, TType.I64, 'cartId', None, None, ), # 2
14750 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14751 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14752 
  )
14753 
 
9299 kshitij.so 14754 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14755 
    self.itemId = itemId
14756 
    self.cartId = cartId
14757 
    self.toInsure = toInsure
9299 kshitij.so 14758 
    self.insurerType = insurerType
6903 anupam.sin 14759 
 
14760 
  def read(self, iprot):
14761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14763 
      return
14764 
    iprot.readStructBegin()
14765 
    while True:
14766 
      (fname, ftype, fid) = iprot.readFieldBegin()
14767 
      if ftype == TType.STOP:
14768 
        break
14769 
      if fid == 1:
14770 
        if ftype == TType.I64:
14771 
          self.itemId = iprot.readI64();
14772 
        else:
14773 
          iprot.skip(ftype)
14774 
      elif fid == 2:
14775 
        if ftype == TType.I64:
14776 
          self.cartId = iprot.readI64();
14777 
        else:
14778 
          iprot.skip(ftype)
14779 
      elif fid == 3:
14780 
        if ftype == TType.BOOL:
14781 
          self.toInsure = iprot.readBool();
14782 
        else:
14783 
          iprot.skip(ftype)
9299 kshitij.so 14784 
      elif fid == 4:
14785 
        if ftype == TType.I32:
14786 
          self.insurerType = iprot.readI32();
14787 
        else:
14788 
          iprot.skip(ftype)
6903 anupam.sin 14789 
      else:
14790 
        iprot.skip(ftype)
14791 
      iprot.readFieldEnd()
14792 
    iprot.readStructEnd()
14793 
 
14794 
  def write(self, oprot):
14795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14797 
      return
14798 
    oprot.writeStructBegin('insureItem_args')
14799 
    if self.itemId is not None:
14800 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14801 
      oprot.writeI64(self.itemId)
14802 
      oprot.writeFieldEnd()
14803 
    if self.cartId is not None:
14804 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14805 
      oprot.writeI64(self.cartId)
14806 
      oprot.writeFieldEnd()
14807 
    if self.toInsure is not None:
14808 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14809 
      oprot.writeBool(self.toInsure)
14810 
      oprot.writeFieldEnd()
9299 kshitij.so 14811 
    if self.insurerType is not None:
14812 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14813 
      oprot.writeI32(self.insurerType)
14814 
      oprot.writeFieldEnd()
6903 anupam.sin 14815 
    oprot.writeFieldStop()
14816 
    oprot.writeStructEnd()
14817 
 
14818 
  def validate(self):
14819 
    return
14820 
 
14821 
 
14822 
  def __repr__(self):
14823 
    L = ['%s=%r' % (key, value)
14824 
      for key, value in self.__dict__.iteritems()]
14825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14826 
 
14827 
  def __eq__(self, other):
14828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14829 
 
14830 
  def __ne__(self, other):
14831 
    return not (self == other)
14832 
 
14833 
class insureItem_result:
14834 
  """
14835 
  Attributes:
14836 
   - success
14837 
  """
14838 
 
14839 
  thrift_spec = (
14840 
    (0, TType.BOOL, 'success', None, None, ), # 0
14841 
  )
14842 
 
14843 
  def __init__(self, success=None,):
14844 
    self.success = success
14845 
 
14846 
  def read(self, iprot):
14847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14849 
      return
14850 
    iprot.readStructBegin()
14851 
    while True:
14852 
      (fname, ftype, fid) = iprot.readFieldBegin()
14853 
      if ftype == TType.STOP:
14854 
        break
14855 
      if fid == 0:
14856 
        if ftype == TType.BOOL:
14857 
          self.success = iprot.readBool();
14858 
        else:
14859 
          iprot.skip(ftype)
14860 
      else:
14861 
        iprot.skip(ftype)
14862 
      iprot.readFieldEnd()
14863 
    iprot.readStructEnd()
14864 
 
14865 
  def write(self, oprot):
14866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14868 
      return
14869 
    oprot.writeStructBegin('insureItem_result')
14870 
    if self.success is not None:
14871 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14872 
      oprot.writeBool(self.success)
14873 
      oprot.writeFieldEnd()
14874 
    oprot.writeFieldStop()
14875 
    oprot.writeStructEnd()
14876 
 
14877 
  def validate(self):
14878 
    return
14879 
 
14880 
 
14881 
  def __repr__(self):
14882 
    L = ['%s=%r' % (key, value)
14883 
      for key, value in self.__dict__.iteritems()]
14884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14885 
 
14886 
  def __eq__(self, other):
14887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14888 
 
14889 
  def __ne__(self, other):
14890 
    return not (self == other)
14891 
 
14892 
class cancelInsurance_args:
14893 
  """
14894 
  Attributes:
14895 
   - cartId
14896 
  """
14897 
 
14898 
  thrift_spec = (
14899 
    None, # 0
14900 
    (1, TType.I64, 'cartId', None, None, ), # 1
14901 
  )
14902 
 
14903 
  def __init__(self, cartId=None,):
14904 
    self.cartId = cartId
14905 
 
14906 
  def read(self, iprot):
14907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14909 
      return
14910 
    iprot.readStructBegin()
14911 
    while True:
14912 
      (fname, ftype, fid) = iprot.readFieldBegin()
14913 
      if ftype == TType.STOP:
14914 
        break
14915 
      if fid == 1:
14916 
        if ftype == TType.I64:
14917 
          self.cartId = iprot.readI64();
14918 
        else:
14919 
          iprot.skip(ftype)
14920 
      else:
14921 
        iprot.skip(ftype)
14922 
      iprot.readFieldEnd()
14923 
    iprot.readStructEnd()
14924 
 
14925 
  def write(self, oprot):
14926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14928 
      return
14929 
    oprot.writeStructBegin('cancelInsurance_args')
14930 
    if self.cartId is not None:
14931 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14932 
      oprot.writeI64(self.cartId)
14933 
      oprot.writeFieldEnd()
14934 
    oprot.writeFieldStop()
14935 
    oprot.writeStructEnd()
14936 
 
14937 
  def validate(self):
14938 
    return
14939 
 
14940 
 
14941 
  def __repr__(self):
14942 
    L = ['%s=%r' % (key, value)
14943 
      for key, value in self.__dict__.iteritems()]
14944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14945 
 
14946 
  def __eq__(self, other):
14947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14948 
 
14949 
  def __ne__(self, other):
14950 
    return not (self == other)
14951 
 
14952 
class cancelInsurance_result:
14953 
  """
14954 
  Attributes:
14955 
   - success
14956 
  """
14957 
 
14958 
  thrift_spec = (
14959 
    (0, TType.BOOL, 'success', None, None, ), # 0
14960 
  )
14961 
 
14962 
  def __init__(self, success=None,):
14963 
    self.success = success
14964 
 
14965 
  def read(self, iprot):
14966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14968 
      return
14969 
    iprot.readStructBegin()
14970 
    while True:
14971 
      (fname, ftype, fid) = iprot.readFieldBegin()
14972 
      if ftype == TType.STOP:
14973 
        break
14974 
      if fid == 0:
14975 
        if ftype == TType.BOOL:
14976 
          self.success = iprot.readBool();
14977 
        else:
14978 
          iprot.skip(ftype)
14979 
      else:
14980 
        iprot.skip(ftype)
14981 
      iprot.readFieldEnd()
14982 
    iprot.readStructEnd()
14983 
 
14984 
  def write(self, oprot):
14985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14987 
      return
14988 
    oprot.writeStructBegin('cancelInsurance_result')
14989 
    if self.success is not None:
14990 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14991 
      oprot.writeBool(self.success)
14992 
      oprot.writeFieldEnd()
14993 
    oprot.writeFieldStop()
14994 
    oprot.writeStructEnd()
14995 
 
14996 
  def validate(self):
14997 
    return
14998 
 
14999 
 
15000 
  def __repr__(self):
15001 
    L = ['%s=%r' % (key, value)
15002 
      for key, value in self.__dict__.iteritems()]
15003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15004 
 
15005 
  def __eq__(self, other):
15006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15007 
 
15008 
  def __ne__(self, other):
15009 
    return not (self == other)
15010 
 
15011 
class storeInsuranceSpecificDetails_args:
15012 
  """
15013 
  Attributes:
15014 
   - addressId
15015 
   - dob
15016 
   - guardianName
15017 
  """
15018 
 
15019 
  thrift_spec = (
15020 
    None, # 0
15021 
    (1, TType.I64, 'addressId', None, None, ), # 1
15022 
    (2, TType.STRING, 'dob', None, None, ), # 2
15023 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
15024 
  )
15025 
 
15026 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
15027 
    self.addressId = addressId
15028 
    self.dob = dob
15029 
    self.guardianName = guardianName
15030 
 
15031 
  def read(self, iprot):
15032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15034 
      return
15035 
    iprot.readStructBegin()
15036 
    while True:
15037 
      (fname, ftype, fid) = iprot.readFieldBegin()
15038 
      if ftype == TType.STOP:
15039 
        break
15040 
      if fid == 1:
15041 
        if ftype == TType.I64:
15042 
          self.addressId = iprot.readI64();
15043 
        else:
15044 
          iprot.skip(ftype)
15045 
      elif fid == 2:
15046 
        if ftype == TType.STRING:
15047 
          self.dob = iprot.readString();
15048 
        else:
15049 
          iprot.skip(ftype)
15050 
      elif fid == 3:
15051 
        if ftype == TType.STRING:
15052 
          self.guardianName = iprot.readString();
15053 
        else:
15054 
          iprot.skip(ftype)
15055 
      else:
15056 
        iprot.skip(ftype)
15057 
      iprot.readFieldEnd()
15058 
    iprot.readStructEnd()
15059 
 
15060 
  def write(self, oprot):
15061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15063 
      return
15064 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15065 
    if self.addressId is not None:
15066 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15067 
      oprot.writeI64(self.addressId)
15068 
      oprot.writeFieldEnd()
15069 
    if self.dob is not None:
15070 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15071 
      oprot.writeString(self.dob)
15072 
      oprot.writeFieldEnd()
15073 
    if self.guardianName is not None:
15074 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15075 
      oprot.writeString(self.guardianName)
15076 
      oprot.writeFieldEnd()
15077 
    oprot.writeFieldStop()
15078 
    oprot.writeStructEnd()
15079 
 
15080 
  def validate(self):
15081 
    return
15082 
 
15083 
 
15084 
  def __repr__(self):
15085 
    L = ['%s=%r' % (key, value)
15086 
      for key, value in self.__dict__.iteritems()]
15087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15088 
 
15089 
  def __eq__(self, other):
15090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15091 
 
15092 
  def __ne__(self, other):
15093 
    return not (self == other)
15094 
 
15095 
class storeInsuranceSpecificDetails_result:
15096 
  """
15097 
  Attributes:
15098 
   - success
15099 
  """
15100 
 
15101 
  thrift_spec = (
15102 
    (0, TType.BOOL, 'success', None, None, ), # 0
15103 
  )
15104 
 
15105 
  def __init__(self, success=None,):
15106 
    self.success = success
15107 
 
15108 
  def read(self, iprot):
15109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15111 
      return
15112 
    iprot.readStructBegin()
15113 
    while True:
15114 
      (fname, ftype, fid) = iprot.readFieldBegin()
15115 
      if ftype == TType.STOP:
15116 
        break
15117 
      if fid == 0:
15118 
        if ftype == TType.BOOL:
15119 
          self.success = iprot.readBool();
15120 
        else:
15121 
          iprot.skip(ftype)
15122 
      else:
15123 
        iprot.skip(ftype)
15124 
      iprot.readFieldEnd()
15125 
    iprot.readStructEnd()
15126 
 
15127 
  def write(self, oprot):
15128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15130 
      return
15131 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15132 
    if self.success is not None:
15133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15134 
      oprot.writeBool(self.success)
15135 
      oprot.writeFieldEnd()
15136 
    oprot.writeFieldStop()
15137 
    oprot.writeStructEnd()
15138 
 
15139 
  def validate(self):
15140 
    return
15141 
 
15142 
 
15143 
  def __repr__(self):
15144 
    L = ['%s=%r' % (key, value)
15145 
      for key, value in self.__dict__.iteritems()]
15146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15147 
 
15148 
  def __eq__(self, other):
15149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15150 
 
15151 
  def __ne__(self, other):
15152 
    return not (self == other)
15153 
 
15154 
class isInsuranceDetailPresent_args:
15155 
  """
15156 
  Attributes:
15157 
   - addressId
15158 
  """
15159 
 
15160 
  thrift_spec = (
15161 
    None, # 0
15162 
    (1, TType.I64, 'addressId', None, None, ), # 1
15163 
  )
15164 
 
15165 
  def __init__(self, addressId=None,):
15166 
    self.addressId = addressId
15167 
 
15168 
  def read(self, iprot):
15169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15171 
      return
15172 
    iprot.readStructBegin()
15173 
    while True:
15174 
      (fname, ftype, fid) = iprot.readFieldBegin()
15175 
      if ftype == TType.STOP:
15176 
        break
15177 
      if fid == 1:
15178 
        if ftype == TType.I64:
15179 
          self.addressId = iprot.readI64();
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      else:
15183 
        iprot.skip(ftype)
15184 
      iprot.readFieldEnd()
15185 
    iprot.readStructEnd()
15186 
 
15187 
  def write(self, oprot):
15188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15190 
      return
15191 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15192 
    if self.addressId is not None:
15193 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15194 
      oprot.writeI64(self.addressId)
15195 
      oprot.writeFieldEnd()
15196 
    oprot.writeFieldStop()
15197 
    oprot.writeStructEnd()
15198 
 
15199 
  def validate(self):
15200 
    return
15201 
 
15202 
 
15203 
  def __repr__(self):
15204 
    L = ['%s=%r' % (key, value)
15205 
      for key, value in self.__dict__.iteritems()]
15206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15207 
 
15208 
  def __eq__(self, other):
15209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15210 
 
15211 
  def __ne__(self, other):
15212 
    return not (self == other)
15213 
 
15214 
class isInsuranceDetailPresent_result:
15215 
  """
15216 
  Attributes:
15217 
   - success
15218 
  """
15219 
 
15220 
  thrift_spec = (
15221 
    (0, TType.BOOL, 'success', None, None, ), # 0
15222 
  )
15223 
 
15224 
  def __init__(self, success=None,):
15225 
    self.success = success
15226 
 
15227 
  def read(self, iprot):
15228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15230 
      return
15231 
    iprot.readStructBegin()
15232 
    while True:
15233 
      (fname, ftype, fid) = iprot.readFieldBegin()
15234 
      if ftype == TType.STOP:
15235 
        break
15236 
      if fid == 0:
15237 
        if ftype == TType.BOOL:
15238 
          self.success = iprot.readBool();
15239 
        else:
15240 
          iprot.skip(ftype)
15241 
      else:
15242 
        iprot.skip(ftype)
15243 
      iprot.readFieldEnd()
15244 
    iprot.readStructEnd()
15245 
 
15246 
  def write(self, oprot):
15247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15249 
      return
15250 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15251 
    if self.success is not None:
15252 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15253 
      oprot.writeBool(self.success)
15254 
      oprot.writeFieldEnd()
15255 
    oprot.writeFieldStop()
15256 
    oprot.writeStructEnd()
15257 
 
15258 
  def validate(self):
15259 
    return
15260 
 
15261 
 
15262 
  def __repr__(self):
15263 
    L = ['%s=%r' % (key, value)
15264 
      for key, value in self.__dict__.iteritems()]
15265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15266 
 
15267 
  def __eq__(self, other):
15268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15269 
 
15270 
  def __ne__(self, other):
15271 
    return not (self == other)
15272 
 
9791 rajveer 15273 
class getProductsAddedToCart_args:
6821 amar.kumar 15274 
  """
15275 
  Attributes:
15276 
   - startDate
15277 
   - endDate
15278 
  """
15279 
 
15280 
  thrift_spec = (
15281 
    None, # 0
9791 rajveer 15282 
    (1, TType.I64, 'startDate', None, None, ), # 1
15283 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15284 
  )
15285 
 
9791 rajveer 15286 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15287 
    self.startDate = startDate
15288 
    self.endDate = endDate
15289 
 
15290 
  def read(self, iprot):
15291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15293 
      return
15294 
    iprot.readStructBegin()
15295 
    while True:
15296 
      (fname, ftype, fid) = iprot.readFieldBegin()
15297 
      if ftype == TType.STOP:
15298 
        break
15299 
      if fid == 1:
15300 
        if ftype == TType.I64:
9791 rajveer 15301 
          self.startDate = iprot.readI64();
6821 amar.kumar 15302 
        else:
15303 
          iprot.skip(ftype)
15304 
      elif fid == 2:
15305 
        if ftype == TType.I64:
15306 
          self.endDate = iprot.readI64();
15307 
        else:
15308 
          iprot.skip(ftype)
15309 
      else:
15310 
        iprot.skip(ftype)
15311 
      iprot.readFieldEnd()
15312 
    iprot.readStructEnd()
15313 
 
15314 
  def write(self, oprot):
15315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15317 
      return
9791 rajveer 15318 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15319 
    if self.startDate is not None:
9791 rajveer 15320 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15321 
      oprot.writeI64(self.startDate)
15322 
      oprot.writeFieldEnd()
15323 
    if self.endDate is not None:
9791 rajveer 15324 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15325 
      oprot.writeI64(self.endDate)
15326 
      oprot.writeFieldEnd()
15327 
    oprot.writeFieldStop()
15328 
    oprot.writeStructEnd()
15329 
 
15330 
  def validate(self):
15331 
    return
15332 
 
15333 
 
15334 
  def __repr__(self):
15335 
    L = ['%s=%r' % (key, value)
15336 
      for key, value in self.__dict__.iteritems()]
15337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15338 
 
15339 
  def __eq__(self, other):
15340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15341 
 
15342 
  def __ne__(self, other):
15343 
    return not (self == other)
15344 
 
9791 rajveer 15345 
class getProductsAddedToCart_result:
6821 amar.kumar 15346 
  """
15347 
  Attributes:
15348 
   - success
15349 
  """
15350 
 
15351 
  thrift_spec = (
9791 rajveer 15352 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15353 
  )
15354 
 
15355 
  def __init__(self, success=None,):
15356 
    self.success = success
15357 
 
15358 
  def read(self, iprot):
15359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15361 
      return
15362 
    iprot.readStructBegin()
15363 
    while True:
15364 
      (fname, ftype, fid) = iprot.readFieldBegin()
15365 
      if ftype == TType.STOP:
15366 
        break
15367 
      if fid == 0:
9791 rajveer 15368 
        if ftype == TType.LIST:
15369 
          self.success = []
11980 amit.gupta 15370 
          (_etype221, _size218) = iprot.readListBegin()
15371 
          for _i222 in xrange(_size218):
15372 
            _elem223 = iprot.readI64();
15373 
            self.success.append(_elem223)
9791 rajveer 15374 
          iprot.readListEnd()
6821 amar.kumar 15375 
        else:
15376 
          iprot.skip(ftype)
15377 
      else:
15378 
        iprot.skip(ftype)
15379 
      iprot.readFieldEnd()
15380 
    iprot.readStructEnd()
15381 
 
15382 
  def write(self, oprot):
15383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15385 
      return
9791 rajveer 15386 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15387 
    if self.success is not None:
9791 rajveer 15388 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15389 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15390 
      for iter224 in self.success:
15391 
        oprot.writeI64(iter224)
9791 rajveer 15392 
      oprot.writeListEnd()
6821 amar.kumar 15393 
      oprot.writeFieldEnd()
15394 
    oprot.writeFieldStop()
15395 
    oprot.writeStructEnd()
15396 
 
15397 
  def validate(self):
15398 
    return
15399 
 
15400 
 
15401 
  def __repr__(self):
15402 
    L = ['%s=%r' % (key, value)
15403 
      for key, value in self.__dict__.iteritems()]
15404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15405 
 
15406 
  def __eq__(self, other):
15407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15408 
 
15409 
  def __ne__(self, other):
15410 
    return not (self == other)
11592 amit.gupta 15411 
 
15412 
class validateCartPlus_args:
15413 
  """
15414 
  Attributes:
15415 
   - cartId
15416 
   - sourceId
11980 amit.gupta 15417 
   - dealerCoupon
11592 amit.gupta 15418 
  """
15419 
 
15420 
  thrift_spec = (
15421 
    None, # 0
15422 
    (1, TType.I64, 'cartId', None, None, ), # 1
15423 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15424 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15425 
  )
15426 
 
11980 amit.gupta 15427 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15428 
    self.cartId = cartId
15429 
    self.sourceId = sourceId
11980 amit.gupta 15430 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15431 
 
15432 
  def read(self, iprot):
15433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15435 
      return
15436 
    iprot.readStructBegin()
15437 
    while True:
15438 
      (fname, ftype, fid) = iprot.readFieldBegin()
15439 
      if ftype == TType.STOP:
15440 
        break
15441 
      if fid == 1:
15442 
        if ftype == TType.I64:
15443 
          self.cartId = iprot.readI64();
15444 
        else:
15445 
          iprot.skip(ftype)
15446 
      elif fid == 2:
15447 
        if ftype == TType.I64:
15448 
          self.sourceId = iprot.readI64();
15449 
        else:
15450 
          iprot.skip(ftype)
11980 amit.gupta 15451 
      elif fid == 3:
15452 
        if ftype == TType.STRING:
15453 
          self.dealerCoupon = iprot.readString();
15454 
        else:
15455 
          iprot.skip(ftype)
11592 amit.gupta 15456 
      else:
15457 
        iprot.skip(ftype)
15458 
      iprot.readFieldEnd()
15459 
    iprot.readStructEnd()
15460 
 
15461 
  def write(self, oprot):
15462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15464 
      return
15465 
    oprot.writeStructBegin('validateCartPlus_args')
15466 
    if self.cartId is not None:
15467 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15468 
      oprot.writeI64(self.cartId)
15469 
      oprot.writeFieldEnd()
15470 
    if self.sourceId is not None:
15471 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15472 
      oprot.writeI64(self.sourceId)
15473 
      oprot.writeFieldEnd()
11980 amit.gupta 15474 
    if self.dealerCoupon is not None:
15475 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15476 
      oprot.writeString(self.dealerCoupon)
15477 
      oprot.writeFieldEnd()
11592 amit.gupta 15478 
    oprot.writeFieldStop()
15479 
    oprot.writeStructEnd()
15480 
 
15481 
  def validate(self):
15482 
    return
15483 
 
15484 
 
15485 
  def __repr__(self):
15486 
    L = ['%s=%r' % (key, value)
15487 
      for key, value in self.__dict__.iteritems()]
15488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15489 
 
15490 
  def __eq__(self, other):
15491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15492 
 
15493 
  def __ne__(self, other):
15494 
    return not (self == other)
15495 
 
15496 
class validateCartPlus_result:
15497 
  """
15498 
  Attributes:
15499 
   - success
15500 
   - scex
15501 
  """
15502 
 
15503 
  thrift_spec = (
15504 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15505 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15506 
  )
15507 
 
15508 
  def __init__(self, success=None, scex=None,):
15509 
    self.success = success
15510 
    self.scex = scex
15511 
 
15512 
  def read(self, iprot):
15513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15515 
      return
15516 
    iprot.readStructBegin()
15517 
    while True:
15518 
      (fname, ftype, fid) = iprot.readFieldBegin()
15519 
      if ftype == TType.STOP:
15520 
        break
15521 
      if fid == 0:
15522 
        if ftype == TType.STRUCT:
15523 
          self.success = CartPlus()
15524 
          self.success.read(iprot)
15525 
        else:
15526 
          iprot.skip(ftype)
15527 
      elif fid == 1:
15528 
        if ftype == TType.STRUCT:
15529 
          self.scex = ShoppingCartException()
15530 
          self.scex.read(iprot)
15531 
        else:
15532 
          iprot.skip(ftype)
15533 
      else:
15534 
        iprot.skip(ftype)
15535 
      iprot.readFieldEnd()
15536 
    iprot.readStructEnd()
15537 
 
15538 
  def write(self, oprot):
15539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15541 
      return
15542 
    oprot.writeStructBegin('validateCartPlus_result')
15543 
    if self.success is not None:
15544 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15545 
      self.success.write(oprot)
15546 
      oprot.writeFieldEnd()
15547 
    if self.scex is not None:
15548 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15549 
      self.scex.write(oprot)
15550 
      oprot.writeFieldEnd()
15551 
    oprot.writeFieldStop()
15552 
    oprot.writeStructEnd()
15553 
 
15554 
  def validate(self):
15555 
    return
15556 
 
15557 
 
15558 
  def __repr__(self):
15559 
    L = ['%s=%r' % (key, value)
15560 
      for key, value in self.__dict__.iteritems()]
15561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15562 
 
15563 
  def __eq__(self, other):
15564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15565 
 
15566 
  def __ne__(self, other):
15567 
    return not (self == other)
11679 vikram.rag 15568 
 
15569 
class isPrivateDealUser_args:
15570 
  """
15571 
  Attributes:
15572 
   - userId
15573 
  """
15574 
 
15575 
  thrift_spec = (
15576 
    None, # 0
15577 
    (1, TType.I64, 'userId', None, None, ), # 1
15578 
  )
15579 
 
15580 
  def __init__(self, userId=None,):
15581 
    self.userId = userId
15582 
 
15583 
  def read(self, iprot):
15584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15586 
      return
15587 
    iprot.readStructBegin()
15588 
    while True:
15589 
      (fname, ftype, fid) = iprot.readFieldBegin()
15590 
      if ftype == TType.STOP:
15591 
        break
15592 
      if fid == 1:
15593 
        if ftype == TType.I64:
15594 
          self.userId = iprot.readI64();
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
15606 
    oprot.writeStructBegin('isPrivateDealUser_args')
15607 
    if self.userId is not None:
15608 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15609 
      oprot.writeI64(self.userId)
15610 
      oprot.writeFieldEnd()
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
15628 
 
15629 
class isPrivateDealUser_result:
15630 
  """
15631 
  Attributes:
15632 
   - success
15633 
  """
15634 
 
15635 
  thrift_spec = (
15636 
    (0, TType.BOOL, 'success', None, None, ), # 0
15637 
  )
15638 
 
15639 
  def __init__(self, success=None,):
15640 
    self.success = success
15641 
 
15642 
  def read(self, iprot):
15643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15645 
      return
15646 
    iprot.readStructBegin()
15647 
    while True:
15648 
      (fname, ftype, fid) = iprot.readFieldBegin()
15649 
      if ftype == TType.STOP:
15650 
        break
15651 
      if fid == 0:
15652 
        if ftype == TType.BOOL:
15653 
          self.success = iprot.readBool();
15654 
        else:
15655 
          iprot.skip(ftype)
15656 
      else:
15657 
        iprot.skip(ftype)
15658 
      iprot.readFieldEnd()
15659 
    iprot.readStructEnd()
15660 
 
15661 
  def write(self, oprot):
15662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15664 
      return
15665 
    oprot.writeStructBegin('isPrivateDealUser_result')
15666 
    if self.success is not None:
15667 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15668 
      oprot.writeBool(self.success)
15669 
      oprot.writeFieldEnd()
15670 
    oprot.writeFieldStop()
15671 
    oprot.writeStructEnd()
15672 
 
15673 
  def validate(self):
15674 
    return
15675 
 
15676 
 
15677 
  def __repr__(self):
15678 
    L = ['%s=%r' % (key, value)
15679 
      for key, value in self.__dict__.iteritems()]
15680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15681 
 
15682 
  def __eq__(self, other):
15683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15684 
 
15685 
  def __ne__(self, other):
15686 
    return not (self == other)
11890 kshitij.so 15687 
 
15688 
class addPrivateDealUser_args:
15689 
  """
15690 
  Attributes:
15691 
   - userId
15692 
  """
15693 
 
15694 
  thrift_spec = (
15695 
    None, # 0
15696 
    (1, TType.I64, 'userId', None, None, ), # 1
15697 
  )
15698 
 
15699 
  def __init__(self, userId=None,):
15700 
    self.userId = userId
15701 
 
15702 
  def read(self, iprot):
15703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15705 
      return
15706 
    iprot.readStructBegin()
15707 
    while True:
15708 
      (fname, ftype, fid) = iprot.readFieldBegin()
15709 
      if ftype == TType.STOP:
15710 
        break
15711 
      if fid == 1:
15712 
        if ftype == TType.I64:
15713 
          self.userId = iprot.readI64();
15714 
        else:
15715 
          iprot.skip(ftype)
15716 
      else:
15717 
        iprot.skip(ftype)
15718 
      iprot.readFieldEnd()
15719 
    iprot.readStructEnd()
15720 
 
15721 
  def write(self, oprot):
15722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15724 
      return
15725 
    oprot.writeStructBegin('addPrivateDealUser_args')
15726 
    if self.userId is not None:
15727 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15728 
      oprot.writeI64(self.userId)
15729 
      oprot.writeFieldEnd()
15730 
    oprot.writeFieldStop()
15731 
    oprot.writeStructEnd()
15732 
 
15733 
  def validate(self):
15734 
    return
15735 
 
15736 
 
15737 
  def __repr__(self):
15738 
    L = ['%s=%r' % (key, value)
15739 
      for key, value in self.__dict__.iteritems()]
15740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15741 
 
15742 
  def __eq__(self, other):
15743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15744 
 
15745 
  def __ne__(self, other):
15746 
    return not (self == other)
15747 
 
15748 
class addPrivateDealUser_result:
15749 
  """
15750 
  Attributes:
15751 
   - success
15752 
  """
15753 
 
15754 
  thrift_spec = (
15755 
    (0, TType.BOOL, 'success', None, None, ), # 0
15756 
  )
15757 
 
15758 
  def __init__(self, success=None,):
15759 
    self.success = success
15760 
 
15761 
  def read(self, iprot):
15762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15764 
      return
15765 
    iprot.readStructBegin()
15766 
    while True:
15767 
      (fname, ftype, fid) = iprot.readFieldBegin()
15768 
      if ftype == TType.STOP:
15769 
        break
15770 
      if fid == 0:
15771 
        if ftype == TType.BOOL:
15772 
          self.success = iprot.readBool();
15773 
        else:
15774 
          iprot.skip(ftype)
15775 
      else:
15776 
        iprot.skip(ftype)
15777 
      iprot.readFieldEnd()
15778 
    iprot.readStructEnd()
15779 
 
15780 
  def write(self, oprot):
15781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15783 
      return
15784 
    oprot.writeStructBegin('addPrivateDealUser_result')
15785 
    if self.success is not None:
15786 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15787 
      oprot.writeBool(self.success)
15788 
      oprot.writeFieldEnd()
15789 
    oprot.writeFieldStop()
15790 
    oprot.writeStructEnd()
15791 
 
15792 
  def validate(self):
15793 
    return
15794 
 
15795 
 
15796 
  def __repr__(self):
15797 
    L = ['%s=%r' % (key, value)
15798 
      for key, value in self.__dict__.iteritems()]
15799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15800 
 
15801 
  def __eq__(self, other):
15802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15803 
 
15804 
  def __ne__(self, other):
15805 
    return not (self == other)
15806 
 
15807 
class changePrivateDealUserStatus_args:
15808 
  """
15809 
  Attributes:
15810 
   - userId
15811 
   - isActive
15812 
  """
15813 
 
15814 
  thrift_spec = (
15815 
    None, # 0
15816 
    (1, TType.I64, 'userId', None, None, ), # 1
15817 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15818 
  )
15819 
 
15820 
  def __init__(self, userId=None, isActive=None,):
15821 
    self.userId = userId
15822 
    self.isActive = isActive
15823 
 
15824 
  def read(self, iprot):
15825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15827 
      return
15828 
    iprot.readStructBegin()
15829 
    while True:
15830 
      (fname, ftype, fid) = iprot.readFieldBegin()
15831 
      if ftype == TType.STOP:
15832 
        break
15833 
      if fid == 1:
15834 
        if ftype == TType.I64:
15835 
          self.userId = iprot.readI64();
15836 
        else:
15837 
          iprot.skip(ftype)
15838 
      elif fid == 2:
15839 
        if ftype == TType.BOOL:
15840 
          self.isActive = iprot.readBool();
15841 
        else:
15842 
          iprot.skip(ftype)
15843 
      else:
15844 
        iprot.skip(ftype)
15845 
      iprot.readFieldEnd()
15846 
    iprot.readStructEnd()
15847 
 
15848 
  def write(self, oprot):
15849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15851 
      return
15852 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15853 
    if self.userId is not None:
15854 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15855 
      oprot.writeI64(self.userId)
15856 
      oprot.writeFieldEnd()
15857 
    if self.isActive is not None:
15858 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15859 
      oprot.writeBool(self.isActive)
15860 
      oprot.writeFieldEnd()
15861 
    oprot.writeFieldStop()
15862 
    oprot.writeStructEnd()
15863 
 
15864 
  def validate(self):
15865 
    return
15866 
 
15867 
 
15868 
  def __repr__(self):
15869 
    L = ['%s=%r' % (key, value)
15870 
      for key, value in self.__dict__.iteritems()]
15871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15872 
 
15873 
  def __eq__(self, other):
15874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15875 
 
15876 
  def __ne__(self, other):
15877 
    return not (self == other)
15878 
 
15879 
class changePrivateDealUserStatus_result:
15880 
  """
15881 
  Attributes:
15882 
   - success
15883 
  """
15884 
 
15885 
  thrift_spec = (
15886 
    (0, TType.BOOL, 'success', None, None, ), # 0
15887 
  )
15888 
 
15889 
  def __init__(self, success=None,):
15890 
    self.success = success
15891 
 
15892 
  def read(self, iprot):
15893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15895 
      return
15896 
    iprot.readStructBegin()
15897 
    while True:
15898 
      (fname, ftype, fid) = iprot.readFieldBegin()
15899 
      if ftype == TType.STOP:
15900 
        break
15901 
      if fid == 0:
15902 
        if ftype == TType.BOOL:
15903 
          self.success = iprot.readBool();
15904 
        else:
15905 
          iprot.skip(ftype)
15906 
      else:
15907 
        iprot.skip(ftype)
15908 
      iprot.readFieldEnd()
15909 
    iprot.readStructEnd()
15910 
 
15911 
  def write(self, oprot):
15912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15914 
      return
15915 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15916 
    if self.success is not None:
15917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15918 
      oprot.writeBool(self.success)
15919 
      oprot.writeFieldEnd()
15920 
    oprot.writeFieldStop()
15921 
    oprot.writeStructEnd()
15922 
 
15923 
  def validate(self):
15924 
    return
15925 
 
15926 
 
15927 
  def __repr__(self):
15928 
    L = ['%s=%r' % (key, value)
15929 
      for key, value in self.__dict__.iteritems()]
15930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15931 
 
15932 
  def __eq__(self, other):
15933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15934 
 
15935 
  def __ne__(self, other):
15936 
    return not (self == other)
15937 
 
15938 
class getPrivateDealUser_args:
15939 
  """
15940 
  Attributes:
15941 
   - userId
15942 
  """
15943 
 
15944 
  thrift_spec = (
15945 
    None, # 0
15946 
    (1, TType.I64, 'userId', None, None, ), # 1
15947 
  )
15948 
 
15949 
  def __init__(self, userId=None,):
15950 
    self.userId = userId
15951 
 
15952 
  def read(self, iprot):
15953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15955 
      return
15956 
    iprot.readStructBegin()
15957 
    while True:
15958 
      (fname, ftype, fid) = iprot.readFieldBegin()
15959 
      if ftype == TType.STOP:
15960 
        break
15961 
      if fid == 1:
15962 
        if ftype == TType.I64:
15963 
          self.userId = iprot.readI64();
15964 
        else:
15965 
          iprot.skip(ftype)
15966 
      else:
15967 
        iprot.skip(ftype)
15968 
      iprot.readFieldEnd()
15969 
    iprot.readStructEnd()
15970 
 
15971 
  def write(self, oprot):
15972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15974 
      return
15975 
    oprot.writeStructBegin('getPrivateDealUser_args')
15976 
    if self.userId is not None:
15977 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15978 
      oprot.writeI64(self.userId)
15979 
      oprot.writeFieldEnd()
15980 
    oprot.writeFieldStop()
15981 
    oprot.writeStructEnd()
15982 
 
15983 
  def validate(self):
15984 
    return
15985 
 
15986 
 
15987 
  def __repr__(self):
15988 
    L = ['%s=%r' % (key, value)
15989 
      for key, value in self.__dict__.iteritems()]
15990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15991 
 
15992 
  def __eq__(self, other):
15993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15994 
 
15995 
  def __ne__(self, other):
15996 
    return not (self == other)
15997 
 
15998 
class getPrivateDealUser_result:
15999 
  """
16000 
  Attributes:
16001 
   - success
16002 
  """
16003 
 
16004 
  thrift_spec = (
16005 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
16006 
  )
16007 
 
16008 
  def __init__(self, success=None,):
16009 
    self.success = success
16010 
 
16011 
  def read(self, iprot):
16012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16014 
      return
16015 
    iprot.readStructBegin()
16016 
    while True:
16017 
      (fname, ftype, fid) = iprot.readFieldBegin()
16018 
      if ftype == TType.STOP:
16019 
        break
16020 
      if fid == 0:
16021 
        if ftype == TType.STRUCT:
16022 
          self.success = PrivateDealUser()
16023 
          self.success.read(iprot)
16024 
        else:
16025 
          iprot.skip(ftype)
16026 
      else:
16027 
        iprot.skip(ftype)
16028 
      iprot.readFieldEnd()
16029 
    iprot.readStructEnd()
16030 
 
16031 
  def write(self, oprot):
16032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16034 
      return
16035 
    oprot.writeStructBegin('getPrivateDealUser_result')
16036 
    if self.success is not None:
16037 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16038 
      self.success.write(oprot)
16039 
      oprot.writeFieldEnd()
16040 
    oprot.writeFieldStop()
16041 
    oprot.writeStructEnd()
16042 
 
16043 
  def validate(self):
16044 
    return
16045 
 
16046 
 
16047 
  def __repr__(self):
16048 
    L = ['%s=%r' % (key, value)
16049 
      for key, value in self.__dict__.iteritems()]
16050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16051 
 
16052 
  def __eq__(self, other):
16053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16054 
 
16055 
  def __ne__(self, other):
16056 
    return not (self == other)
12696 amit.gupta 16057 
 
16058 
class registerCounter_args:
16059 
  """
16060 
  Attributes:
16061 
   - counter
16062 
   - userId
16063 
  """
16064 
 
16065 
  thrift_spec = (
16066 
    None, # 0
16067 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16068 
    (2, TType.I64, 'userId', None, None, ), # 2
16069 
  )
16070 
 
16071 
  def __init__(self, counter=None, userId=None,):
16072 
    self.counter = counter
16073 
    self.userId = userId
16074 
 
16075 
  def read(self, iprot):
16076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16078 
      return
16079 
    iprot.readStructBegin()
16080 
    while True:
16081 
      (fname, ftype, fid) = iprot.readFieldBegin()
16082 
      if ftype == TType.STOP:
16083 
        break
16084 
      if fid == 1:
16085 
        if ftype == TType.STRUCT:
16086 
          self.counter = Counter()
16087 
          self.counter.read(iprot)
16088 
        else:
16089 
          iprot.skip(ftype)
16090 
      elif fid == 2:
16091 
        if ftype == TType.I64:
16092 
          self.userId = iprot.readI64();
16093 
        else:
16094 
          iprot.skip(ftype)
16095 
      else:
16096 
        iprot.skip(ftype)
16097 
      iprot.readFieldEnd()
16098 
    iprot.readStructEnd()
16099 
 
16100 
  def write(self, oprot):
16101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16103 
      return
16104 
    oprot.writeStructBegin('registerCounter_args')
16105 
    if self.counter is not None:
16106 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16107 
      self.counter.write(oprot)
16108 
      oprot.writeFieldEnd()
16109 
    if self.userId is not None:
16110 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16111 
      oprot.writeI64(self.userId)
16112 
      oprot.writeFieldEnd()
16113 
    oprot.writeFieldStop()
16114 
    oprot.writeStructEnd()
16115 
 
16116 
  def validate(self):
16117 
    return
16118 
 
16119 
 
16120 
  def __repr__(self):
16121 
    L = ['%s=%r' % (key, value)
16122 
      for key, value in self.__dict__.iteritems()]
16123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16124 
 
16125 
  def __eq__(self, other):
16126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16127 
 
16128 
  def __ne__(self, other):
16129 
    return not (self == other)
16130 
 
16131 
class registerCounter_result:
16132 
  """
16133 
  Attributes:
16134 
   - success
16135 
  """
16136 
 
16137 
  thrift_spec = (
16138 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16139 
  )
16140 
 
16141 
  def __init__(self, success=None,):
16142 
    self.success = success
16143 
 
16144 
  def read(self, iprot):
16145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16147 
      return
16148 
    iprot.readStructBegin()
16149 
    while True:
16150 
      (fname, ftype, fid) = iprot.readFieldBegin()
16151 
      if ftype == TType.STOP:
16152 
        break
16153 
      if fid == 0:
16154 
        if ftype == TType.MAP:
16155 
          self.success = {}
16156 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16157 
          for _i229 in xrange(_size225):
16158 
            _key230 = iprot.readString();
16159 
            _val231 = iprot.readString();
16160 
            self.success[_key230] = _val231
16161 
          iprot.readMapEnd()
16162 
        else:
16163 
          iprot.skip(ftype)
16164 
      else:
16165 
        iprot.skip(ftype)
16166 
      iprot.readFieldEnd()
16167 
    iprot.readStructEnd()
16168 
 
16169 
  def write(self, oprot):
16170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16172 
      return
16173 
    oprot.writeStructBegin('registerCounter_result')
16174 
    if self.success is not None:
16175 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16176 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16177 
      for kiter232,viter233 in self.success.items():
16178 
        oprot.writeString(kiter232)
16179 
        oprot.writeString(viter233)
16180 
      oprot.writeMapEnd()
16181 
      oprot.writeFieldEnd()
16182 
    oprot.writeFieldStop()
16183 
    oprot.writeStructEnd()
16184 
 
16185 
  def validate(self):
16186 
    return
16187 
 
16188 
 
16189 
  def __repr__(self):
16190 
    L = ['%s=%r' % (key, value)
16191 
      for key, value in self.__dict__.iteritems()]
16192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16193 
 
16194 
  def __eq__(self, other):
16195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16196 
 
16197 
  def __ne__(self, other):
16198 
    return not (self == other)
12722 amit.gupta 16199 
 
16200 
class searchCounter_args:
16201 
  """
16202 
  Attributes:
16203 
   - type1
16204 
   - searchString
16205 
  """
16206 
 
16207 
  thrift_spec = (
16208 
    None, # 0
16209 
    (1, TType.STRING, 'type1', None, None, ), # 1
16210 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16211 
  )
16212 
 
16213 
  def __init__(self, type1=None, searchString=None,):
16214 
    self.type1 = type1
16215 
    self.searchString = searchString
16216 
 
16217 
  def read(self, iprot):
16218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16220 
      return
16221 
    iprot.readStructBegin()
16222 
    while True:
16223 
      (fname, ftype, fid) = iprot.readFieldBegin()
16224 
      if ftype == TType.STOP:
16225 
        break
16226 
      if fid == 1:
16227 
        if ftype == TType.STRING:
16228 
          self.type1 = iprot.readString();
16229 
        else:
16230 
          iprot.skip(ftype)
16231 
      elif fid == 2:
16232 
        if ftype == TType.STRING:
16233 
          self.searchString = iprot.readString();
16234 
        else:
16235 
          iprot.skip(ftype)
16236 
      else:
16237 
        iprot.skip(ftype)
16238 
      iprot.readFieldEnd()
16239 
    iprot.readStructEnd()
16240 
 
16241 
  def write(self, oprot):
16242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16244 
      return
16245 
    oprot.writeStructBegin('searchCounter_args')
16246 
    if self.type1 is not None:
16247 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16248 
      oprot.writeString(self.type1)
16249 
      oprot.writeFieldEnd()
16250 
    if self.searchString is not None:
16251 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16252 
      oprot.writeString(self.searchString)
16253 
      oprot.writeFieldEnd()
16254 
    oprot.writeFieldStop()
16255 
    oprot.writeStructEnd()
16256 
 
16257 
  def validate(self):
16258 
    return
16259 
 
16260 
 
16261 
  def __repr__(self):
16262 
    L = ['%s=%r' % (key, value)
16263 
      for key, value in self.__dict__.iteritems()]
16264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16265 
 
16266 
  def __eq__(self, other):
16267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16268 
 
16269 
  def __ne__(self, other):
16270 
    return not (self == other)
16271 
 
16272 
class searchCounter_result:
16273 
  """
16274 
  Attributes:
16275 
   - success
16276 
  """
16277 
 
16278 
  thrift_spec = (
16279 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16280 
  )
16281 
 
16282 
  def __init__(self, success=None,):
16283 
    self.success = success
16284 
 
16285 
  def read(self, iprot):
16286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16288 
      return
16289 
    iprot.readStructBegin()
16290 
    while True:
16291 
      (fname, ftype, fid) = iprot.readFieldBegin()
16292 
      if ftype == TType.STOP:
16293 
        break
16294 
      if fid == 0:
16295 
        if ftype == TType.LIST:
16296 
          self.success = []
16297 
          (_etype237, _size234) = iprot.readListBegin()
16298 
          for _i238 in xrange(_size234):
16299 
            _elem239 = Counter()
16300 
            _elem239.read(iprot)
16301 
            self.success.append(_elem239)
16302 
          iprot.readListEnd()
16303 
        else:
16304 
          iprot.skip(ftype)
16305 
      else:
16306 
        iprot.skip(ftype)
16307 
      iprot.readFieldEnd()
16308 
    iprot.readStructEnd()
16309 
 
16310 
  def write(self, oprot):
16311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16313 
      return
16314 
    oprot.writeStructBegin('searchCounter_result')
16315 
    if self.success is not None:
16316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16318 
      for iter240 in self.success:
16319 
        iter240.write(oprot)
16320 
      oprot.writeListEnd()
16321 
      oprot.writeFieldEnd()
16322 
    oprot.writeFieldStop()
16323 
    oprot.writeStructEnd()
16324 
 
16325 
  def validate(self):
16326 
    return
16327 
 
16328 
 
16329 
  def __repr__(self):
16330 
    L = ['%s=%r' % (key, value)
16331 
      for key, value in self.__dict__.iteritems()]
16332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16333 
 
16334 
  def __eq__(self, other):
16335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16336 
 
16337 
  def __ne__(self, other):
16338 
    return not (self == other)
16339 
 
18977 amit.gupta 16340 
class getCounterByUserId_args:
16341 
  """
16342 
  Attributes:
16343 
   - userId
16344 
  """
16345 
 
16346 
  thrift_spec = (
16347 
    None, # 0
16348 
    (1, TType.I64, 'userId', None, None, ), # 1
16349 
  )
16350 
 
16351 
  def __init__(self, userId=None,):
16352 
    self.userId = userId
16353 
 
16354 
  def read(self, iprot):
16355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16357 
      return
16358 
    iprot.readStructBegin()
16359 
    while True:
16360 
      (fname, ftype, fid) = iprot.readFieldBegin()
16361 
      if ftype == TType.STOP:
16362 
        break
16363 
      if fid == 1:
16364 
        if ftype == TType.I64:
16365 
          self.userId = iprot.readI64();
16366 
        else:
16367 
          iprot.skip(ftype)
16368 
      else:
16369 
        iprot.skip(ftype)
16370 
      iprot.readFieldEnd()
16371 
    iprot.readStructEnd()
16372 
 
16373 
  def write(self, oprot):
16374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16376 
      return
16377 
    oprot.writeStructBegin('getCounterByUserId_args')
16378 
    if self.userId is not None:
16379 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16380 
      oprot.writeI64(self.userId)
16381 
      oprot.writeFieldEnd()
16382 
    oprot.writeFieldStop()
16383 
    oprot.writeStructEnd()
16384 
 
16385 
  def validate(self):
16386 
    return
16387 
 
16388 
 
16389 
  def __repr__(self):
16390 
    L = ['%s=%r' % (key, value)
16391 
      for key, value in self.__dict__.iteritems()]
16392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16393 
 
16394 
  def __eq__(self, other):
16395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16396 
 
16397 
  def __ne__(self, other):
16398 
    return not (self == other)
16399 
 
16400 
class getCounterByUserId_result:
16401 
  """
16402 
  Attributes:
16403 
   - success
16404 
  """
16405 
 
16406 
  thrift_spec = (
16407 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16408 
  )
16409 
 
16410 
  def __init__(self, success=None,):
16411 
    self.success = success
16412 
 
16413 
  def read(self, iprot):
16414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16416 
      return
16417 
    iprot.readStructBegin()
16418 
    while True:
16419 
      (fname, ftype, fid) = iprot.readFieldBegin()
16420 
      if ftype == TType.STOP:
16421 
        break
16422 
      if fid == 0:
16423 
        if ftype == TType.STRUCT:
16424 
          self.success = Counter()
16425 
          self.success.read(iprot)
16426 
        else:
16427 
          iprot.skip(ftype)
16428 
      else:
16429 
        iprot.skip(ftype)
16430 
      iprot.readFieldEnd()
16431 
    iprot.readStructEnd()
16432 
 
16433 
  def write(self, oprot):
16434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16436 
      return
16437 
    oprot.writeStructBegin('getCounterByUserId_result')
16438 
    if self.success is not None:
16439 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16440 
      self.success.write(oprot)
16441 
      oprot.writeFieldEnd()
16442 
    oprot.writeFieldStop()
16443 
    oprot.writeStructEnd()
16444 
 
16445 
  def validate(self):
16446 
    return
16447 
 
16448 
 
16449 
  def __repr__(self):
16450 
    L = ['%s=%r' % (key, value)
16451 
      for key, value in self.__dict__.iteritems()]
16452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16453 
 
16454 
  def __eq__(self, other):
16455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16456 
 
16457 
  def __ne__(self, other):
16458 
    return not (self == other)
16459 
 
12722 amit.gupta 16460 
class getAllUsersByCounter_args:
16461 
  """
16462 
  Attributes:
16463 
   - counterId
16464 
  """
16465 
 
16466 
  thrift_spec = (
16467 
    None, # 0
16468 
    (1, TType.I64, 'counterId', None, None, ), # 1
16469 
  )
16470 
 
16471 
  def __init__(self, counterId=None,):
16472 
    self.counterId = counterId
16473 
 
16474 
  def read(self, iprot):
16475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16477 
      return
16478 
    iprot.readStructBegin()
16479 
    while True:
16480 
      (fname, ftype, fid) = iprot.readFieldBegin()
16481 
      if ftype == TType.STOP:
16482 
        break
16483 
      if fid == 1:
16484 
        if ftype == TType.I64:
16485 
          self.counterId = iprot.readI64();
16486 
        else:
16487 
          iprot.skip(ftype)
16488 
      else:
16489 
        iprot.skip(ftype)
16490 
      iprot.readFieldEnd()
16491 
    iprot.readStructEnd()
16492 
 
16493 
  def write(self, oprot):
16494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16496 
      return
16497 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16498 
    if self.counterId is not None:
16499 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16500 
      oprot.writeI64(self.counterId)
16501 
      oprot.writeFieldEnd()
16502 
    oprot.writeFieldStop()
16503 
    oprot.writeStructEnd()
16504 
 
16505 
  def validate(self):
16506 
    return
16507 
 
16508 
 
16509 
  def __repr__(self):
16510 
    L = ['%s=%r' % (key, value)
16511 
      for key, value in self.__dict__.iteritems()]
16512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16513 
 
16514 
  def __eq__(self, other):
16515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16516 
 
16517 
  def __ne__(self, other):
16518 
    return not (self == other)
16519 
 
16520 
class getAllUsersByCounter_result:
16521 
  """
16522 
  Attributes:
16523 
   - success
16524 
  """
16525 
 
16526 
  thrift_spec = (
16527 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16528 
  )
16529 
 
16530 
  def __init__(self, success=None,):
16531 
    self.success = success
16532 
 
16533 
  def read(self, iprot):
16534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16536 
      return
16537 
    iprot.readStructBegin()
16538 
    while True:
16539 
      (fname, ftype, fid) = iprot.readFieldBegin()
16540 
      if ftype == TType.STOP:
16541 
        break
16542 
      if fid == 0:
16543 
        if ftype == TType.LIST:
16544 
          self.success = []
16545 
          (_etype244, _size241) = iprot.readListBegin()
16546 
          for _i245 in xrange(_size241):
16547 
            _elem246 = User()
16548 
            _elem246.read(iprot)
16549 
            self.success.append(_elem246)
16550 
          iprot.readListEnd()
16551 
        else:
16552 
          iprot.skip(ftype)
16553 
      else:
16554 
        iprot.skip(ftype)
16555 
      iprot.readFieldEnd()
16556 
    iprot.readStructEnd()
16557 
 
16558 
  def write(self, oprot):
16559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16561 
      return
16562 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16563 
    if self.success is not None:
16564 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16565 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16566 
      for iter247 in self.success:
16567 
        iter247.write(oprot)
16568 
      oprot.writeListEnd()
16569 
      oprot.writeFieldEnd()
16570 
    oprot.writeFieldStop()
16571 
    oprot.writeStructEnd()
16572 
 
16573 
  def validate(self):
16574 
    return
16575 
 
16576 
 
16577 
  def __repr__(self):
16578 
    L = ['%s=%r' % (key, value)
16579 
      for key, value in self.__dict__.iteritems()]
16580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16581 
 
16582 
  def __eq__(self, other):
16583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16584 
 
16585 
  def __ne__(self, other):
16586 
    return not (self == other)
15251 manish.sha 16587 
 
16588 
class getActiveAccessTokenForUser_args:
16589 
  """
16590 
  Attributes:
16591 
   - userId
16592 
   - source
16593 
  """
16594 
 
16595 
  thrift_spec = (
16596 
    None, # 0
16597 
    (1, TType.I64, 'userId', None, None, ), # 1
16598 
    (2, TType.STRING, 'source', None, None, ), # 2
16599 
  )
16600 
 
16601 
  def __init__(self, userId=None, source=None,):
16602 
    self.userId = userId
16603 
    self.source = source
16604 
 
16605 
  def read(self, iprot):
16606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16608 
      return
16609 
    iprot.readStructBegin()
16610 
    while True:
16611 
      (fname, ftype, fid) = iprot.readFieldBegin()
16612 
      if ftype == TType.STOP:
16613 
        break
16614 
      if fid == 1:
16615 
        if ftype == TType.I64:
16616 
          self.userId = iprot.readI64();
16617 
        else:
16618 
          iprot.skip(ftype)
16619 
      elif fid == 2:
16620 
        if ftype == TType.STRING:
16621 
          self.source = iprot.readString();
16622 
        else:
16623 
          iprot.skip(ftype)
16624 
      else:
16625 
        iprot.skip(ftype)
16626 
      iprot.readFieldEnd()
16627 
    iprot.readStructEnd()
16628 
 
16629 
  def write(self, oprot):
16630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16632 
      return
16633 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16634 
    if self.userId is not None:
16635 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16636 
      oprot.writeI64(self.userId)
16637 
      oprot.writeFieldEnd()
16638 
    if self.source is not None:
16639 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16640 
      oprot.writeString(self.source)
16641 
      oprot.writeFieldEnd()
16642 
    oprot.writeFieldStop()
16643 
    oprot.writeStructEnd()
16644 
 
16645 
  def validate(self):
16646 
    return
16647 
 
16648 
 
16649 
  def __repr__(self):
16650 
    L = ['%s=%r' % (key, value)
16651 
      for key, value in self.__dict__.iteritems()]
16652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16653 
 
16654 
  def __eq__(self, other):
16655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16656 
 
16657 
  def __ne__(self, other):
16658 
    return not (self == other)
16659 
 
16660 
class getActiveAccessTokenForUser_result:
16661 
  """
16662 
  Attributes:
16663 
   - success
16664 
  """
16665 
 
16666 
  thrift_spec = (
16667 
    (0, TType.STRING, 'success', None, None, ), # 0
16668 
  )
16669 
 
16670 
  def __init__(self, success=None,):
16671 
    self.success = success
16672 
 
16673 
  def read(self, iprot):
16674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16676 
      return
16677 
    iprot.readStructBegin()
16678 
    while True:
16679 
      (fname, ftype, fid) = iprot.readFieldBegin()
16680 
      if ftype == TType.STOP:
16681 
        break
16682 
      if fid == 0:
16683 
        if ftype == TType.STRING:
16684 
          self.success = iprot.readString();
16685 
        else:
16686 
          iprot.skip(ftype)
16687 
      else:
16688 
        iprot.skip(ftype)
16689 
      iprot.readFieldEnd()
16690 
    iprot.readStructEnd()
16691 
 
16692 
  def write(self, oprot):
16693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16695 
      return
16696 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16697 
    if self.success is not None:
16698 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16699 
      oprot.writeString(self.success)
16700 
      oprot.writeFieldEnd()
16701 
    oprot.writeFieldStop()
16702 
    oprot.writeStructEnd()
16703 
 
16704 
  def validate(self):
16705 
    return
16706 
 
16707 
 
16708 
  def __repr__(self):
16709 
    L = ['%s=%r' % (key, value)
16710 
      for key, value in self.__dict__.iteritems()]
16711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16712 
 
16713 
  def __eq__(self, other):
16714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16715 
 
16716 
  def __ne__(self, other):
16717 
    return not (self == other)
16718 
 
16719 
class validateAccessToken_args:
16720 
  """
16721 
  Attributes:
16722 
   - accessToken
16723 
  """
16724 
 
16725 
  thrift_spec = (
16726 
    None, # 0
16727 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16728 
  )
16729 
 
16730 
  def __init__(self, accessToken=None,):
16731 
    self.accessToken = accessToken
16732 
 
16733 
  def read(self, iprot):
16734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16736 
      return
16737 
    iprot.readStructBegin()
16738 
    while True:
16739 
      (fname, ftype, fid) = iprot.readFieldBegin()
16740 
      if ftype == TType.STOP:
16741 
        break
16742 
      if fid == 1:
16743 
        if ftype == TType.STRING:
16744 
          self.accessToken = iprot.readString();
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      else:
16748 
        iprot.skip(ftype)
16749 
      iprot.readFieldEnd()
16750 
    iprot.readStructEnd()
16751 
 
16752 
  def write(self, oprot):
16753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16755 
      return
16756 
    oprot.writeStructBegin('validateAccessToken_args')
16757 
    if self.accessToken is not None:
16758 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16759 
      oprot.writeString(self.accessToken)
16760 
      oprot.writeFieldEnd()
16761 
    oprot.writeFieldStop()
16762 
    oprot.writeStructEnd()
16763 
 
16764 
  def validate(self):
16765 
    return
16766 
 
16767 
 
16768 
  def __repr__(self):
16769 
    L = ['%s=%r' % (key, value)
16770 
      for key, value in self.__dict__.iteritems()]
16771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16772 
 
16773 
  def __eq__(self, other):
16774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16775 
 
16776 
  def __ne__(self, other):
16777 
    return not (self == other)
16778 
 
16779 
class validateAccessToken_result:
16780 
  """
16781 
  Attributes:
16782 
   - success
16783 
  """
16784 
 
16785 
  thrift_spec = (
16786 
    (0, TType.BOOL, 'success', None, None, ), # 0
16787 
  )
16788 
 
16789 
  def __init__(self, success=None,):
16790 
    self.success = success
16791 
 
16792 
  def read(self, iprot):
16793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16795 
      return
16796 
    iprot.readStructBegin()
16797 
    while True:
16798 
      (fname, ftype, fid) = iprot.readFieldBegin()
16799 
      if ftype == TType.STOP:
16800 
        break
16801 
      if fid == 0:
16802 
        if ftype == TType.BOOL:
16803 
          self.success = iprot.readBool();
16804 
        else:
16805 
          iprot.skip(ftype)
16806 
      else:
16807 
        iprot.skip(ftype)
16808 
      iprot.readFieldEnd()
16809 
    iprot.readStructEnd()
16810 
 
16811 
  def write(self, oprot):
16812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16814 
      return
16815 
    oprot.writeStructBegin('validateAccessToken_result')
16816 
    if self.success is not None:
16817 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16818 
      oprot.writeBool(self.success)
16819 
      oprot.writeFieldEnd()
16820 
    oprot.writeFieldStop()
16821 
    oprot.writeStructEnd()
16822 
 
16823 
  def validate(self):
16824 
    return
16825 
 
16826 
 
16827 
  def __repr__(self):
16828 
    L = ['%s=%r' % (key, value)
16829 
      for key, value in self.__dict__.iteritems()]
16830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16831 
 
16832 
  def __eq__(self, other):
16833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16834 
 
16835 
  def __ne__(self, other):
16836 
    return not (self == other)
17782 amit.gupta 16837 
 
16838 
class addItemsToCart_args:
16839 
  """
16840 
  Attributes:
16841 
   - cartId
16842 
   - itemQty
16843 
   - couponCode
16844 
  """
16845 
 
16846 
  thrift_spec = (
16847 
    None, # 0
16848 
    (1, TType.I64, 'cartId', None, None, ), # 1
16849 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16850 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16851 
  )
16852 
 
16853 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16854 
    self.cartId = cartId
16855 
    self.itemQty = itemQty
16856 
    self.couponCode = couponCode
16857 
 
16858 
  def read(self, iprot):
16859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16861 
      return
16862 
    iprot.readStructBegin()
16863 
    while True:
16864 
      (fname, ftype, fid) = iprot.readFieldBegin()
16865 
      if ftype == TType.STOP:
16866 
        break
16867 
      if fid == 1:
16868 
        if ftype == TType.I64:
16869 
          self.cartId = iprot.readI64();
16870 
        else:
16871 
          iprot.skip(ftype)
16872 
      elif fid == 2:
16873 
        if ftype == TType.LIST:
16874 
          self.itemQty = []
16875 
          (_etype251, _size248) = iprot.readListBegin()
16876 
          for _i252 in xrange(_size248):
16877 
            _elem253 = ItemQuantity()
16878 
            _elem253.read(iprot)
16879 
            self.itemQty.append(_elem253)
16880 
          iprot.readListEnd()
16881 
        else:
16882 
          iprot.skip(ftype)
16883 
      elif fid == 3:
16884 
        if ftype == TType.STRING:
16885 
          self.couponCode = iprot.readString();
16886 
        else:
16887 
          iprot.skip(ftype)
16888 
      else:
16889 
        iprot.skip(ftype)
16890 
      iprot.readFieldEnd()
16891 
    iprot.readStructEnd()
16892 
 
16893 
  def write(self, oprot):
16894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16896 
      return
16897 
    oprot.writeStructBegin('addItemsToCart_args')
16898 
    if self.cartId is not None:
16899 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16900 
      oprot.writeI64(self.cartId)
16901 
      oprot.writeFieldEnd()
16902 
    if self.itemQty is not None:
16903 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16904 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16905 
      for iter254 in self.itemQty:
16906 
        iter254.write(oprot)
16907 
      oprot.writeListEnd()
16908 
      oprot.writeFieldEnd()
16909 
    if self.couponCode is not None:
16910 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16911 
      oprot.writeString(self.couponCode)
16912 
      oprot.writeFieldEnd()
16913 
    oprot.writeFieldStop()
16914 
    oprot.writeStructEnd()
16915 
 
16916 
  def validate(self):
16917 
    return
16918 
 
16919 
 
16920 
  def __repr__(self):
16921 
    L = ['%s=%r' % (key, value)
16922 
      for key, value in self.__dict__.iteritems()]
16923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16924 
 
16925 
  def __eq__(self, other):
16926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16927 
 
16928 
  def __ne__(self, other):
16929 
    return not (self == other)
16930 
 
16931 
class addItemsToCart_result:
16932 
  """
16933 
  Attributes:
16934 
   - success
16935 
  """
16936 
 
16937 
  thrift_spec = (
16938 
    (0, TType.BOOL, 'success', None, None, ), # 0
16939 
  )
16940 
 
16941 
  def __init__(self, success=None,):
16942 
    self.success = success
16943 
 
16944 
  def read(self, iprot):
16945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16947 
      return
16948 
    iprot.readStructBegin()
16949 
    while True:
16950 
      (fname, ftype, fid) = iprot.readFieldBegin()
16951 
      if ftype == TType.STOP:
16952 
        break
16953 
      if fid == 0:
16954 
        if ftype == TType.BOOL:
16955 
          self.success = iprot.readBool();
16956 
        else:
16957 
          iprot.skip(ftype)
16958 
      else:
16959 
        iprot.skip(ftype)
16960 
      iprot.readFieldEnd()
16961 
    iprot.readStructEnd()
16962 
 
16963 
  def write(self, oprot):
16964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16966 
      return
16967 
    oprot.writeStructBegin('addItemsToCart_result')
16968 
    if self.success is not None:
16969 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16970 
      oprot.writeBool(self.success)
16971 
      oprot.writeFieldEnd()
16972 
    oprot.writeFieldStop()
16973 
    oprot.writeStructEnd()
16974 
 
16975 
  def validate(self):
16976 
    return
16977 
 
16978 
 
16979 
  def __repr__(self):
16980 
    L = ['%s=%r' % (key, value)
16981 
      for key, value in self.__dict__.iteritems()]
16982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16983 
 
16984 
  def __eq__(self, other):
16985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16986 
 
16987 
  def __ne__(self, other):
16988 
    return not (self == other)
16989 
 
16990 
class validateCartNew_args:
16991 
  """
16992 
  Attributes:
16993 
   - cartId
16994 
   - pinCode
16995 
   - sourceId
16996 
  """
16997 
 
16998 
  thrift_spec = (
16999 
    None, # 0
17000 
    (1, TType.I64, 'cartId', None, None, ), # 1
17001 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
17002 
    (3, TType.I64, 'sourceId', None, None, ), # 3
17003 
  )
17004 
 
17005 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
17006 
    self.cartId = cartId
17007 
    self.pinCode = pinCode
17008 
    self.sourceId = sourceId
17009 
 
17010 
  def read(self, iprot):
17011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17013 
      return
17014 
    iprot.readStructBegin()
17015 
    while True:
17016 
      (fname, ftype, fid) = iprot.readFieldBegin()
17017 
      if ftype == TType.STOP:
17018 
        break
17019 
      if fid == 1:
17020 
        if ftype == TType.I64:
17021 
          self.cartId = iprot.readI64();
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      elif fid == 2:
17025 
        if ftype == TType.STRING:
17026 
          self.pinCode = iprot.readString();
17027 
        else:
17028 
          iprot.skip(ftype)
17029 
      elif fid == 3:
17030 
        if ftype == TType.I64:
17031 
          self.sourceId = iprot.readI64();
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      else:
17035 
        iprot.skip(ftype)
17036 
      iprot.readFieldEnd()
17037 
    iprot.readStructEnd()
17038 
 
17039 
  def write(self, oprot):
17040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17042 
      return
17043 
    oprot.writeStructBegin('validateCartNew_args')
17044 
    if self.cartId is not None:
17045 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17046 
      oprot.writeI64(self.cartId)
17047 
      oprot.writeFieldEnd()
17048 
    if self.pinCode is not None:
17049 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17050 
      oprot.writeString(self.pinCode)
17051 
      oprot.writeFieldEnd()
17052 
    if self.sourceId is not None:
17053 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17054 
      oprot.writeI64(self.sourceId)
17055 
      oprot.writeFieldEnd()
17056 
    oprot.writeFieldStop()
17057 
    oprot.writeStructEnd()
17058 
 
17059 
  def validate(self):
17060 
    return
17061 
 
17062 
 
17063 
  def __repr__(self):
17064 
    L = ['%s=%r' % (key, value)
17065 
      for key, value in self.__dict__.iteritems()]
17066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17067 
 
17068 
  def __eq__(self, other):
17069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17070 
 
17071 
  def __ne__(self, other):
17072 
    return not (self == other)
17073 
 
17074 
class validateCartNew_result:
17075 
  """
17076 
  Attributes:
17077 
   - success
17078 
  """
17079 
 
17080 
  thrift_spec = (
17081 
    (0, TType.STRING, 'success', None, None, ), # 0
17082 
  )
17083 
 
17084 
  def __init__(self, success=None,):
17085 
    self.success = success
17086 
 
17087 
  def read(self, iprot):
17088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17090 
      return
17091 
    iprot.readStructBegin()
17092 
    while True:
17093 
      (fname, ftype, fid) = iprot.readFieldBegin()
17094 
      if ftype == TType.STOP:
17095 
        break
17096 
      if fid == 0:
17097 
        if ftype == TType.STRING:
17098 
          self.success = iprot.readString();
17099 
        else:
17100 
          iprot.skip(ftype)
17101 
      else:
17102 
        iprot.skip(ftype)
17103 
      iprot.readFieldEnd()
17104 
    iprot.readStructEnd()
17105 
 
17106 
  def write(self, oprot):
17107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17109 
      return
17110 
    oprot.writeStructBegin('validateCartNew_result')
17111 
    if self.success is not None:
17112 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17113 
      oprot.writeString(self.success)
17114 
      oprot.writeFieldEnd()
17115 
    oprot.writeFieldStop()
17116 
    oprot.writeStructEnd()
17117 
 
17118 
  def validate(self):
17119 
    return
17120 
 
17121 
 
17122 
  def __repr__(self):
17123 
    L = ['%s=%r' % (key, value)
17124 
      for key, value in self.__dict__.iteritems()]
17125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17126 
 
17127 
  def __eq__(self, other):
17128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17129 
 
17130 
  def __ne__(self, other):
17131 
    return not (self == other)
18530 manish.sha 17132 
 
18644 manish.sha 17133 
class isAddressEditableForCounter_args:
18530 manish.sha 17134 
  """
17135 
  Attributes:
17136 
   - userId
17137 
  """
17138 
 
17139 
  thrift_spec = (
17140 
    None, # 0
17141 
    (1, TType.I64, 'userId', None, None, ), # 1
17142 
  )
17143 
 
17144 
  def __init__(self, userId=None,):
17145 
    self.userId = userId
17146 
 
17147 
  def read(self, iprot):
17148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17150 
      return
17151 
    iprot.readStructBegin()
17152 
    while True:
17153 
      (fname, ftype, fid) = iprot.readFieldBegin()
17154 
      if ftype == TType.STOP:
17155 
        break
17156 
      if fid == 1:
17157 
        if ftype == TType.I64:
17158 
          self.userId = iprot.readI64();
17159 
        else:
17160 
          iprot.skip(ftype)
17161 
      else:
17162 
        iprot.skip(ftype)
17163 
      iprot.readFieldEnd()
17164 
    iprot.readStructEnd()
17165 
 
17166 
  def write(self, oprot):
17167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17169 
      return
18644 manish.sha 17170 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17171 
    if self.userId is not None:
17172 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17173 
      oprot.writeI64(self.userId)
17174 
      oprot.writeFieldEnd()
17175 
    oprot.writeFieldStop()
17176 
    oprot.writeStructEnd()
17177 
 
17178 
  def validate(self):
17179 
    return
17180 
 
17181 
 
17182 
  def __repr__(self):
17183 
    L = ['%s=%r' % (key, value)
17184 
      for key, value in self.__dict__.iteritems()]
17185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17186 
 
17187 
  def __eq__(self, other):
17188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17189 
 
17190 
  def __ne__(self, other):
17191 
    return not (self == other)
17192 
 
18644 manish.sha 17193 
class isAddressEditableForCounter_result:
18530 manish.sha 17194 
  """
17195 
  Attributes:
17196 
   - success
17197 
  """
17198 
 
17199 
  thrift_spec = (
17200 
    (0, TType.BOOL, 'success', None, None, ), # 0
17201 
  )
17202 
 
17203 
  def __init__(self, success=None,):
17204 
    self.success = success
17205 
 
17206 
  def read(self, iprot):
17207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17209 
      return
17210 
    iprot.readStructBegin()
17211 
    while True:
17212 
      (fname, ftype, fid) = iprot.readFieldBegin()
17213 
      if ftype == TType.STOP:
17214 
        break
17215 
      if fid == 0:
17216 
        if ftype == TType.BOOL:
17217 
          self.success = iprot.readBool();
17218 
        else:
17219 
          iprot.skip(ftype)
17220 
      else:
17221 
        iprot.skip(ftype)
17222 
      iprot.readFieldEnd()
17223 
    iprot.readStructEnd()
17224 
 
17225 
  def write(self, oprot):
17226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17228 
      return
18644 manish.sha 17229 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17230 
    if self.success is not None:
17231 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17232 
      oprot.writeBool(self.success)
17233 
      oprot.writeFieldEnd()
17234 
    oprot.writeFieldStop()
17235 
    oprot.writeStructEnd()
17236 
 
17237 
  def validate(self):
17238 
    return
17239 
 
17240 
 
17241 
  def __repr__(self):
17242 
    L = ['%s=%r' % (key, value)
17243 
      for key, value in self.__dict__.iteritems()]
17244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17245 
 
17246 
  def __eq__(self, other):
17247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17248 
 
17249 
  def __ne__(self, other):
17250 
    return not (self == other)
17251 
 
17252 
class getBillingAddressForUser_args:
17253 
  """
17254 
  Attributes:
17255 
   - userId
17256 
  """
17257 
 
17258 
  thrift_spec = (
17259 
    None, # 0
17260 
    (1, TType.I64, 'userId', None, None, ), # 1
17261 
  )
17262 
 
17263 
  def __init__(self, userId=None,):
17264 
    self.userId = userId
17265 
 
17266 
  def read(self, iprot):
17267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17269 
      return
17270 
    iprot.readStructBegin()
17271 
    while True:
17272 
      (fname, ftype, fid) = iprot.readFieldBegin()
17273 
      if ftype == TType.STOP:
17274 
        break
17275 
      if fid == 1:
17276 
        if ftype == TType.I64:
17277 
          self.userId = iprot.readI64();
17278 
        else:
17279 
          iprot.skip(ftype)
17280 
      else:
17281 
        iprot.skip(ftype)
17282 
      iprot.readFieldEnd()
17283 
    iprot.readStructEnd()
17284 
 
17285 
  def write(self, oprot):
17286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17288 
      return
17289 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17290 
    if self.userId is not None:
17291 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17292 
      oprot.writeI64(self.userId)
17293 
      oprot.writeFieldEnd()
17294 
    oprot.writeFieldStop()
17295 
    oprot.writeStructEnd()
17296 
 
17297 
  def validate(self):
17298 
    return
17299 
 
17300 
 
17301 
  def __repr__(self):
17302 
    L = ['%s=%r' % (key, value)
17303 
      for key, value in self.__dict__.iteritems()]
17304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17305 
 
17306 
  def __eq__(self, other):
17307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17308 
 
17309 
  def __ne__(self, other):
17310 
    return not (self == other)
17311 
 
17312 
class getBillingAddressForUser_result:
17313 
  """
17314 
  Attributes:
17315 
   - success
17316 
  """
17317 
 
17318 
  thrift_spec = (
17319 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17320 
  )
17321 
 
17322 
  def __init__(self, success=None,):
17323 
    self.success = success
17324 
 
17325 
  def read(self, iprot):
17326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17328 
      return
17329 
    iprot.readStructBegin()
17330 
    while True:
17331 
      (fname, ftype, fid) = iprot.readFieldBegin()
17332 
      if ftype == TType.STOP:
17333 
        break
17334 
      if fid == 0:
17335 
        if ftype == TType.STRUCT:
17336 
          self.success = Address()
17337 
          self.success.read(iprot)
17338 
        else:
17339 
          iprot.skip(ftype)
17340 
      else:
17341 
        iprot.skip(ftype)
17342 
      iprot.readFieldEnd()
17343 
    iprot.readStructEnd()
17344 
 
17345 
  def write(self, oprot):
17346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17348 
      return
17349 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17350 
    if self.success is not None:
17351 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17352 
      self.success.write(oprot)
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)
18590 manish.sha 17371 
 
17372 
class isCreditorAssigned_args:
17373 
  """
17374 
  Attributes:
17375 
   - userId
17376 
  """
17377 
 
17378 
  thrift_spec = (
17379 
    None, # 0
17380 
    (1, TType.I64, 'userId', None, None, ), # 1
17381 
  )
17382 
 
17383 
  def __init__(self, userId=None,):
17384 
    self.userId = userId
17385 
 
17386 
  def read(self, iprot):
17387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17389 
      return
17390 
    iprot.readStructBegin()
17391 
    while True:
17392 
      (fname, ftype, fid) = iprot.readFieldBegin()
17393 
      if ftype == TType.STOP:
17394 
        break
17395 
      if fid == 1:
17396 
        if ftype == TType.I64:
17397 
          self.userId = iprot.readI64();
17398 
        else:
17399 
          iprot.skip(ftype)
17400 
      else:
17401 
        iprot.skip(ftype)
17402 
      iprot.readFieldEnd()
17403 
    iprot.readStructEnd()
17404 
 
17405 
  def write(self, oprot):
17406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17408 
      return
17409 
    oprot.writeStructBegin('isCreditorAssigned_args')
17410 
    if self.userId is not None:
17411 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17412 
      oprot.writeI64(self.userId)
17413 
      oprot.writeFieldEnd()
17414 
    oprot.writeFieldStop()
17415 
    oprot.writeStructEnd()
17416 
 
17417 
  def validate(self):
17418 
    return
17419 
 
17420 
 
17421 
  def __repr__(self):
17422 
    L = ['%s=%r' % (key, value)
17423 
      for key, value in self.__dict__.iteritems()]
17424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17425 
 
17426 
  def __eq__(self, other):
17427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17428 
 
17429 
  def __ne__(self, other):
17430 
    return not (self == other)
17431 
 
17432 
class isCreditorAssigned_result:
17433 
  """
17434 
  Attributes:
17435 
   - success
17436 
  """
17437 
 
17438 
  thrift_spec = (
17439 
    (0, TType.BOOL, 'success', None, None, ), # 0
17440 
  )
17441 
 
17442 
  def __init__(self, success=None,):
17443 
    self.success = success
17444 
 
17445 
  def read(self, iprot):
17446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17448 
      return
17449 
    iprot.readStructBegin()
17450 
    while True:
17451 
      (fname, ftype, fid) = iprot.readFieldBegin()
17452 
      if ftype == TType.STOP:
17453 
        break
17454 
      if fid == 0:
17455 
        if ftype == TType.BOOL:
17456 
          self.success = iprot.readBool();
17457 
        else:
17458 
          iprot.skip(ftype)
17459 
      else:
17460 
        iprot.skip(ftype)
17461 
      iprot.readFieldEnd()
17462 
    iprot.readStructEnd()
17463 
 
17464 
  def write(self, oprot):
17465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17467 
      return
17468 
    oprot.writeStructBegin('isCreditorAssigned_result')
17469 
    if self.success is not None:
17470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17471 
      oprot.writeBool(self.success)
17472 
      oprot.writeFieldEnd()
17473 
    oprot.writeFieldStop()
17474 
    oprot.writeStructEnd()
17475 
 
17476 
  def validate(self):
17477 
    return
17478 
 
17479 
 
17480 
  def __repr__(self):
17481 
    L = ['%s=%r' % (key, value)
17482 
      for key, value in self.__dict__.iteritems()]
17483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17484 
 
17485 
  def __eq__(self, other):
17486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17487 
 
17488 
  def __ne__(self, other):
17489 
    return not (self == other)
18735 manish.sha 17490 
 
17491 
class isTaxInvoiceEnabledUser_args:
17492 
  """
17493 
  Attributes:
17494 
   - userId
17495 
  """
17496 
 
17497 
  thrift_spec = (
17498 
    None, # 0
17499 
    (1, TType.I64, 'userId', None, None, ), # 1
17500 
  )
17501 
 
17502 
  def __init__(self, userId=None,):
17503 
    self.userId = userId
17504 
 
17505 
  def read(self, iprot):
17506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17508 
      return
17509 
    iprot.readStructBegin()
17510 
    while True:
17511 
      (fname, ftype, fid) = iprot.readFieldBegin()
17512 
      if ftype == TType.STOP:
17513 
        break
17514 
      if fid == 1:
17515 
        if ftype == TType.I64:
17516 
          self.userId = iprot.readI64();
17517 
        else:
17518 
          iprot.skip(ftype)
17519 
      else:
17520 
        iprot.skip(ftype)
17521 
      iprot.readFieldEnd()
17522 
    iprot.readStructEnd()
17523 
 
17524 
  def write(self, oprot):
17525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17527 
      return
17528 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17529 
    if self.userId is not None:
17530 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17531 
      oprot.writeI64(self.userId)
17532 
      oprot.writeFieldEnd()
17533 
    oprot.writeFieldStop()
17534 
    oprot.writeStructEnd()
17535 
 
17536 
  def validate(self):
17537 
    return
17538 
 
17539 
 
17540 
  def __repr__(self):
17541 
    L = ['%s=%r' % (key, value)
17542 
      for key, value in self.__dict__.iteritems()]
17543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17544 
 
17545 
  def __eq__(self, other):
17546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17547 
 
17548 
  def __ne__(self, other):
17549 
    return not (self == other)
17550 
 
17551 
class isTaxInvoiceEnabledUser_result:
17552 
  """
17553 
  Attributes:
17554 
   - success
17555 
  """
17556 
 
17557 
  thrift_spec = (
17558 
    (0, TType.BOOL, 'success', None, None, ), # 0
17559 
  )
17560 
 
17561 
  def __init__(self, success=None,):
17562 
    self.success = success
17563 
 
17564 
  def read(self, iprot):
17565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17567 
      return
17568 
    iprot.readStructBegin()
17569 
    while True:
17570 
      (fname, ftype, fid) = iprot.readFieldBegin()
17571 
      if ftype == TType.STOP:
17572 
        break
17573 
      if fid == 0:
17574 
        if ftype == TType.BOOL:
17575 
          self.success = iprot.readBool();
17576 
        else:
17577 
          iprot.skip(ftype)
17578 
      else:
17579 
        iprot.skip(ftype)
17580 
      iprot.readFieldEnd()
17581 
    iprot.readStructEnd()
17582 
 
17583 
  def write(self, oprot):
17584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17586 
      return
17587 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17588 
    if self.success is not None:
17589 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17590 
      oprot.writeBool(self.success)
17591 
      oprot.writeFieldEnd()
17592 
    oprot.writeFieldStop()
17593 
    oprot.writeStructEnd()
17594 
 
17595 
  def validate(self):
17596 
    return
17597 
 
17598 
 
17599 
  def __repr__(self):
17600 
    L = ['%s=%r' % (key, value)
17601 
      for key, value in self.__dict__.iteritems()]
17602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17603 
 
17604 
  def __eq__(self, other):
17605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17606 
 
17607 
  def __ne__(self, other):
17608 
    return not (self == other)
18764 kshitij.so 17609 
 
19182 amit.gupta 17610 
class taxInvoiceAvailable_args:
17611 
  """
17612 
  Attributes:
17613 
   - addressId
17614 
  """
17615 
 
17616 
  thrift_spec = (
17617 
    None, # 0
17618 
    (1, TType.I64, 'addressId', None, None, ), # 1
17619 
  )
17620 
 
17621 
  def __init__(self, addressId=None,):
17622 
    self.addressId = addressId
17623 
 
17624 
  def read(self, iprot):
17625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17627 
      return
17628 
    iprot.readStructBegin()
17629 
    while True:
17630 
      (fname, ftype, fid) = iprot.readFieldBegin()
17631 
      if ftype == TType.STOP:
17632 
        break
17633 
      if fid == 1:
17634 
        if ftype == TType.I64:
17635 
          self.addressId = iprot.readI64();
17636 
        else:
17637 
          iprot.skip(ftype)
17638 
      else:
17639 
        iprot.skip(ftype)
17640 
      iprot.readFieldEnd()
17641 
    iprot.readStructEnd()
17642 
 
17643 
  def write(self, oprot):
17644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17646 
      return
17647 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
17648 
    if self.addressId is not None:
17649 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
17650 
      oprot.writeI64(self.addressId)
17651 
      oprot.writeFieldEnd()
17652 
    oprot.writeFieldStop()
17653 
    oprot.writeStructEnd()
17654 
 
17655 
  def validate(self):
17656 
    return
17657 
 
17658 
 
17659 
  def __repr__(self):
17660 
    L = ['%s=%r' % (key, value)
17661 
      for key, value in self.__dict__.iteritems()]
17662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17663 
 
17664 
  def __eq__(self, other):
17665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17666 
 
17667 
  def __ne__(self, other):
17668 
    return not (self == other)
17669 
 
17670 
class taxInvoiceAvailable_result:
17671 
  """
17672 
  Attributes:
17673 
   - success
17674 
  """
17675 
 
17676 
  thrift_spec = (
17677 
    (0, TType.BOOL, 'success', None, None, ), # 0
17678 
  )
17679 
 
17680 
  def __init__(self, success=None,):
17681 
    self.success = success
17682 
 
17683 
  def read(self, iprot):
17684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17686 
      return
17687 
    iprot.readStructBegin()
17688 
    while True:
17689 
      (fname, ftype, fid) = iprot.readFieldBegin()
17690 
      if ftype == TType.STOP:
17691 
        break
17692 
      if fid == 0:
17693 
        if ftype == TType.BOOL:
17694 
          self.success = iprot.readBool();
17695 
        else:
17696 
          iprot.skip(ftype)
17697 
      else:
17698 
        iprot.skip(ftype)
17699 
      iprot.readFieldEnd()
17700 
    iprot.readStructEnd()
17701 
 
17702 
  def write(self, oprot):
17703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17705 
      return
17706 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
17707 
    if self.success is not None:
17708 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17709 
      oprot.writeBool(self.success)
17710 
      oprot.writeFieldEnd()
17711 
    oprot.writeFieldStop()
17712 
    oprot.writeStructEnd()
17713 
 
17714 
  def validate(self):
17715 
    return
17716 
 
17717 
 
17718 
  def __repr__(self):
17719 
    L = ['%s=%r' % (key, value)
17720 
      for key, value in self.__dict__.iteritems()]
17721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17722 
 
17723 
  def __eq__(self, other):
17724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17725 
 
17726 
  def __ne__(self, other):
17727 
    return not (self == other)
17728 
 
18764 kshitij.so 17729 
class getCartByValue_args:
17730 
  """
17731 
  Attributes:
17732 
   - cartIds
17733 
  """
17734 
 
17735 
  thrift_spec = (
17736 
    None, # 0
17737 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17738 
  )
17739 
 
17740 
  def __init__(self, cartIds=None,):
17741 
    self.cartIds = cartIds
17742 
 
17743 
  def read(self, iprot):
17744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17746 
      return
17747 
    iprot.readStructBegin()
17748 
    while True:
17749 
      (fname, ftype, fid) = iprot.readFieldBegin()
17750 
      if ftype == TType.STOP:
17751 
        break
17752 
      if fid == 1:
17753 
        if ftype == TType.LIST:
17754 
          self.cartIds = []
17755 
          (_etype258, _size255) = iprot.readListBegin()
17756 
          for _i259 in xrange(_size255):
17757 
            _elem260 = iprot.readI64();
17758 
            self.cartIds.append(_elem260)
17759 
          iprot.readListEnd()
17760 
        else:
17761 
          iprot.skip(ftype)
17762 
      else:
17763 
        iprot.skip(ftype)
17764 
      iprot.readFieldEnd()
17765 
    iprot.readStructEnd()
17766 
 
17767 
  def write(self, oprot):
17768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17770 
      return
17771 
    oprot.writeStructBegin('getCartByValue_args')
17772 
    if self.cartIds is not None:
17773 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
17774 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
17775 
      for iter261 in self.cartIds:
17776 
        oprot.writeI64(iter261)
17777 
      oprot.writeListEnd()
17778 
      oprot.writeFieldEnd()
17779 
    oprot.writeFieldStop()
17780 
    oprot.writeStructEnd()
17781 
 
17782 
  def validate(self):
17783 
    return
17784 
 
17785 
 
17786 
  def __repr__(self):
17787 
    L = ['%s=%r' % (key, value)
17788 
      for key, value in self.__dict__.iteritems()]
17789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17790 
 
17791 
  def __eq__(self, other):
17792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17793 
 
17794 
  def __ne__(self, other):
17795 
    return not (self == other)
17796 
 
17797 
class getCartByValue_result:
17798 
  """
17799 
  Attributes:
17800 
   - success
17801 
  """
17802 
 
17803 
  thrift_spec = (
17804 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
17805 
  )
17806 
 
17807 
  def __init__(self, success=None,):
17808 
    self.success = success
17809 
 
17810 
  def read(self, iprot):
17811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17813 
      return
17814 
    iprot.readStructBegin()
17815 
    while True:
17816 
      (fname, ftype, fid) = iprot.readFieldBegin()
17817 
      if ftype == TType.STOP:
17818 
        break
17819 
      if fid == 0:
17820 
        if ftype == TType.MAP:
17821 
          self.success = {}
17822 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
17823 
          for _i266 in xrange(_size262):
17824 
            _key267 = iprot.readI64();
17825 
            _val268 = []
17826 
            (_etype272, _size269) = iprot.readListBegin()
17827 
            for _i273 in xrange(_size269):
17828 
              _elem274 = Line()
17829 
              _elem274.read(iprot)
17830 
              _val268.append(_elem274)
17831 
            iprot.readListEnd()
17832 
            self.success[_key267] = _val268
17833 
          iprot.readMapEnd()
17834 
        else:
17835 
          iprot.skip(ftype)
17836 
      else:
17837 
        iprot.skip(ftype)
17838 
      iprot.readFieldEnd()
17839 
    iprot.readStructEnd()
17840 
 
17841 
  def write(self, oprot):
17842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17844 
      return
17845 
    oprot.writeStructBegin('getCartByValue_result')
17846 
    if self.success is not None:
17847 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17848 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
17849 
      for kiter275,viter276 in self.success.items():
17850 
        oprot.writeI64(kiter275)
17851 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
17852 
        for iter277 in viter276:
17853 
          iter277.write(oprot)
17854 
        oprot.writeListEnd()
17855 
      oprot.writeMapEnd()
17856 
      oprot.writeFieldEnd()
17857 
    oprot.writeFieldStop()
17858 
    oprot.writeStructEnd()
17859 
 
17860 
  def validate(self):
17861 
    return
17862 
 
17863 
 
17864 
  def __repr__(self):
17865 
    L = ['%s=%r' % (key, value)
17866 
      for key, value in self.__dict__.iteritems()]
17867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17868 
 
17869 
  def __eq__(self, other):
17870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17871 
 
17872 
  def __ne__(self, other):
17873 
    return not (self == other)
19889 manas 17874 
 
17875 
class getCounterName_args:
17876 
  """
17877 
  Attributes:
17878 
   - userIds
17879 
  """
17880 
 
17881 
  thrift_spec = (
17882 
    None, # 0
17883 
    (1, TType.LIST, 'userIds', (TType.I64,None), None, ), # 1
17884 
  )
17885 
 
17886 
  def __init__(self, userIds=None,):
17887 
    self.userIds = userIds
17888 
 
17889 
  def read(self, iprot):
17890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17892 
      return
17893 
    iprot.readStructBegin()
17894 
    while True:
17895 
      (fname, ftype, fid) = iprot.readFieldBegin()
17896 
      if ftype == TType.STOP:
17897 
        break
17898 
      if fid == 1:
17899 
        if ftype == TType.LIST:
17900 
          self.userIds = []
17901 
          (_etype281, _size278) = iprot.readListBegin()
17902 
          for _i282 in xrange(_size278):
17903 
            _elem283 = iprot.readI64();
17904 
            self.userIds.append(_elem283)
17905 
          iprot.readListEnd()
17906 
        else:
17907 
          iprot.skip(ftype)
17908 
      else:
17909 
        iprot.skip(ftype)
17910 
      iprot.readFieldEnd()
17911 
    iprot.readStructEnd()
17912 
 
17913 
  def write(self, oprot):
17914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17916 
      return
17917 
    oprot.writeStructBegin('getCounterName_args')
17918 
    if self.userIds is not None:
17919 
      oprot.writeFieldBegin('userIds', TType.LIST, 1)
17920 
      oprot.writeListBegin(TType.I64, len(self.userIds))
17921 
      for iter284 in self.userIds:
17922 
        oprot.writeI64(iter284)
17923 
      oprot.writeListEnd()
17924 
      oprot.writeFieldEnd()
17925 
    oprot.writeFieldStop()
17926 
    oprot.writeStructEnd()
17927 
 
17928 
  def validate(self):
17929 
    return
17930 
 
17931 
 
17932 
  def __repr__(self):
17933 
    L = ['%s=%r' % (key, value)
17934 
      for key, value in self.__dict__.iteritems()]
17935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17936 
 
17937 
  def __eq__(self, other):
17938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17939 
 
17940 
  def __ne__(self, other):
17941 
    return not (self == other)
17942 
 
17943 
class getCounterName_result:
17944 
  """
17945 
  Attributes:
17946 
   - success
17947 
  """
17948 
 
17949 
  thrift_spec = (
17950 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
17951 
  )
17952 
 
17953 
  def __init__(self, success=None,):
17954 
    self.success = success
17955 
 
17956 
  def read(self, iprot):
17957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17959 
      return
17960 
    iprot.readStructBegin()
17961 
    while True:
17962 
      (fname, ftype, fid) = iprot.readFieldBegin()
17963 
      if ftype == TType.STOP:
17964 
        break
17965 
      if fid == 0:
17966 
        if ftype == TType.MAP:
17967 
          self.success = {}
17968 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
17969 
          for _i289 in xrange(_size285):
17970 
            _key290 = iprot.readI64();
17971 
            _val291 = iprot.readString();
17972 
            self.success[_key290] = _val291
17973 
          iprot.readMapEnd()
17974 
        else:
17975 
          iprot.skip(ftype)
17976 
      else:
17977 
        iprot.skip(ftype)
17978 
      iprot.readFieldEnd()
17979 
    iprot.readStructEnd()
17980 
 
17981 
  def write(self, oprot):
17982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17984 
      return
17985 
    oprot.writeStructBegin('getCounterName_result')
17986 
    if self.success is not None:
17987 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17988 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
17989 
      for kiter292,viter293 in self.success.items():
17990 
        oprot.writeI64(kiter292)
17991 
        oprot.writeString(viter293)
17992 
      oprot.writeMapEnd()
17993 
      oprot.writeFieldEnd()
17994 
    oprot.writeFieldStop()
17995 
    oprot.writeStructEnd()
17996 
 
17997 
  def validate(self):
17998 
    return
17999 
 
18000 
 
18001 
  def __repr__(self):
18002 
    L = ['%s=%r' % (key, value)
18003 
      for key, value in self.__dict__.iteritems()]
18004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18005 
 
18006 
  def __eq__(self, other):
18007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18008 
 
18009 
  def __ne__(self, other):
18010 
    return not (self == other)