Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
12722 amit.gupta 713 
  def getAllUsersByCounter(self, counterId):
714 
    """
715 
    Parameters:
716 
     - counterId
717 
    """
718 
    pass
719 
 
15251 manish.sha 720 
  def getActiveAccessTokenForUser(self, userId, source):
721 
    """
722 
    Parameters:
723 
     - userId
724 
     - source
725 
    """
726 
    pass
12722 amit.gupta 727 
 
15251 manish.sha 728 
  def validateAccessToken(self, accessToken):
729 
    """
730 
    Parameters:
731 
     - accessToken
732 
    """
733 
    pass
734 
 
17782 amit.gupta 735 
  def addItemsToCart(self, cartId, itemQty, couponCode):
736 
    """
737 
    Parameters:
738 
     - cartId
739 
     - itemQty
740 
     - couponCode
741 
    """
742 
    pass
15251 manish.sha 743 
 
17782 amit.gupta 744 
  def validateCartNew(self, cartId, pinCode, sourceId):
745 
    """
746 
    Parameters:
747 
     - cartId
748 
     - pinCode
749 
     - sourceId
750 
    """
751 
    pass
752 
 
18644 manish.sha 753 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 754 
    """
755 
    Parameters:
756 
     - userId
757 
    """
758 
    pass
17782 amit.gupta 759 
 
18530 manish.sha 760 
  def getBillingAddressForUser(self, userId):
761 
    """
762 
    Parameters:
763 
     - userId
764 
    """
765 
    pass
766 
 
18590 manish.sha 767 
  def isCreditorAssigned(self, userId):
768 
    """
769 
    Parameters:
770 
     - userId
771 
    """
772 
    pass
18530 manish.sha 773 
 
18735 manish.sha 774 
  def isTaxInvoiceEnabledUser(self, userId):
775 
    """
776 
    Parameters:
777 
     - userId
778 
    """
779 
    pass
18590 manish.sha 780 
 
18735 manish.sha 781 
 
3376 rajveer 782 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 783 
  """
784 
  service
785 
  """
786 
  def __init__(self, iprot, oprot=None):
3376 rajveer 787 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 788 
 
559 chandransh 789 
  def createAnonymousUser(self, jsessionId):
94 ashish 790 
    """
791 
    Parameters:
559 chandransh 792 
     - jsessionId
94 ashish 793 
    """
559 chandransh 794 
    self.send_createAnonymousUser(jsessionId)
795 
    return self.recv_createAnonymousUser()
94 ashish 796 
 
559 chandransh 797 
  def send_createAnonymousUser(self, jsessionId):
798 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
799 
    args = createAnonymousUser_args()
800 
    args.jsessionId = jsessionId
94 ashish 801 
    args.write(self._oprot)
802 
    self._oprot.writeMessageEnd()
803 
    self._oprot.trans.flush()
804 
 
559 chandransh 805 
  def recv_createAnonymousUser(self, ):
94 ashish 806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
807 
    if mtype == TMessageType.EXCEPTION:
808 
      x = TApplicationException()
809 
      x.read(self._iprot)
810 
      self._iprot.readMessageEnd()
811 
      raise x
559 chandransh 812 
    result = createAnonymousUser_result()
94 ashish 813 
    result.read(self._iprot)
814 
    self._iprot.readMessageEnd()
3431 rajveer 815 
    if result.success is not None:
94 ashish 816 
      return result.success
3431 rajveer 817 
    if result.ucex is not None:
559 chandransh 818 
      raise result.ucex
819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 820 
 
559 chandransh 821 
  def getUserById(self, userId):
94 ashish 822 
    """
823 
    Parameters:
824 
     - userId
825 
    """
559 chandransh 826 
    self.send_getUserById(userId)
827 
    return self.recv_getUserById()
94 ashish 828 
 
559 chandransh 829 
  def send_getUserById(self, userId):
830 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
831 
    args = getUserById_args()
94 ashish 832 
    args.userId = userId
833 
    args.write(self._oprot)
834 
    self._oprot.writeMessageEnd()
835 
    self._oprot.trans.flush()
836 
 
559 chandransh 837 
  def recv_getUserById(self, ):
94 ashish 838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
839 
    if mtype == TMessageType.EXCEPTION:
840 
      x = TApplicationException()
841 
      x.read(self._iprot)
842 
      self._iprot.readMessageEnd()
843 
      raise x
559 chandransh 844 
    result = getUserById_result()
94 ashish 845 
    result.read(self._iprot)
846 
    self._iprot.readMessageEnd()
3431 rajveer 847 
    if result.success is not None:
94 ashish 848 
      return result.success
3431 rajveer 849 
    if result.ucex is not None:
559 chandransh 850 
      raise result.ucex
851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 852 
 
5326 rajveer 853 
  def getUserByCartId(self, cartId):
854 
    """
855 
    Parameters:
856 
     - cartId
857 
    """
858 
    self.send_getUserByCartId(cartId)
859 
    return self.recv_getUserByCartId()
860 
 
861 
  def send_getUserByCartId(self, cartId):
862 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
863 
    args = getUserByCartId_args()
864 
    args.cartId = cartId
865 
    args.write(self._oprot)
866 
    self._oprot.writeMessageEnd()
867 
    self._oprot.trans.flush()
868 
 
869 
  def recv_getUserByCartId(self, ):
870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
871 
    if mtype == TMessageType.EXCEPTION:
872 
      x = TApplicationException()
873 
      x.read(self._iprot)
874 
      self._iprot.readMessageEnd()
875 
      raise x
876 
    result = getUserByCartId_result()
877 
    result.read(self._iprot)
878 
    self._iprot.readMessageEnd()
879 
    if result.success is not None:
880 
      return result.success
881 
    if result.ucex is not None:
882 
      raise result.ucex
883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
884 
 
1491 vikas 885 
  def getUserByEmail(self, email):
886 
    """
887 
    Parameters:
888 
     - email
889 
    """
890 
    self.send_getUserByEmail(email)
891 
    return self.recv_getUserByEmail()
892 
 
893 
  def send_getUserByEmail(self, email):
894 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
895 
    args = getUserByEmail_args()
896 
    args.email = email
897 
    args.write(self._oprot)
898 
    self._oprot.writeMessageEnd()
899 
    self._oprot.trans.flush()
900 
 
901 
  def recv_getUserByEmail(self, ):
902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
903 
    if mtype == TMessageType.EXCEPTION:
904 
      x = TApplicationException()
905 
      x.read(self._iprot)
906 
      self._iprot.readMessageEnd()
907 
      raise x
908 
    result = getUserByEmail_result()
909 
    result.read(self._iprot)
910 
    self._iprot.readMessageEnd()
3431 rajveer 911 
    if result.success is not None:
1491 vikas 912 
      return result.success
3431 rajveer 913 
    if result.ucex is not None:
1491 vikas 914 
      raise result.ucex
915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
916 
 
3032 mandeep.dh 917 
  def getUserByMobileNumber(self, mobileNumber):
918 
    """
919 
    Parameters:
920 
     - mobileNumber
921 
    """
922 
    self.send_getUserByMobileNumber(mobileNumber)
923 
    return self.recv_getUserByMobileNumber()
924 
 
925 
  def send_getUserByMobileNumber(self, mobileNumber):
926 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
927 
    args = getUserByMobileNumber_args()
928 
    args.mobileNumber = mobileNumber
929 
    args.write(self._oprot)
930 
    self._oprot.writeMessageEnd()
931 
    self._oprot.trans.flush()
932 
 
933 
  def recv_getUserByMobileNumber(self, ):
934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
935 
    if mtype == TMessageType.EXCEPTION:
936 
      x = TApplicationException()
937 
      x.read(self._iprot)
938 
      self._iprot.readMessageEnd()
939 
      raise x
940 
    result = getUserByMobileNumber_result()
941 
    result.read(self._iprot)
942 
    self._iprot.readMessageEnd()
3431 rajveer 943 
    if result.success is not None:
3032 mandeep.dh 944 
      return result.success
3431 rajveer 945 
    if result.ucex is not None:
3032 mandeep.dh 946 
      raise result.ucex
947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
948 
 
559 chandransh 949 
  def createUser(self, user):
94 ashish 950 
    """
951 
    Parameters:
559 chandransh 952 
     - user
94 ashish 953 
    """
559 chandransh 954 
    self.send_createUser(user)
955 
    return self.recv_createUser()
94 ashish 956 
 
559 chandransh 957 
  def send_createUser(self, user):
958 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
959 
    args = createUser_args()
960 
    args.user = user
94 ashish 961 
    args.write(self._oprot)
962 
    self._oprot.writeMessageEnd()
963 
    self._oprot.trans.flush()
964 
 
559 chandransh 965 
  def recv_createUser(self, ):
94 ashish 966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
967 
    if mtype == TMessageType.EXCEPTION:
968 
      x = TApplicationException()
969 
      x.read(self._iprot)
970 
      self._iprot.readMessageEnd()
971 
      raise x
559 chandransh 972 
    result = createUser_result()
94 ashish 973 
    result.read(self._iprot)
974 
    self._iprot.readMessageEnd()
3431 rajveer 975 
    if result.success is not None:
94 ashish 976 
      return result.success
3431 rajveer 977 
    if result.ucex is not None:
559 chandransh 978 
      raise result.ucex
979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 980 
 
559 chandransh 981 
  def updateUser(self, user):
94 ashish 982 
    """
983 
    Parameters:
559 chandransh 984 
     - user
94 ashish 985 
    """
559 chandransh 986 
    self.send_updateUser(user)
987 
    return self.recv_updateUser()
94 ashish 988 
 
559 chandransh 989 
  def send_updateUser(self, user):
990 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
991 
    args = updateUser_args()
992 
    args.user = user
94 ashish 993 
    args.write(self._oprot)
994 
    self._oprot.writeMessageEnd()
995 
    self._oprot.trans.flush()
996 
 
559 chandransh 997 
  def recv_updateUser(self, ):
94 ashish 998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
999 
    if mtype == TMessageType.EXCEPTION:
1000 
      x = TApplicationException()
1001 
      x.read(self._iprot)
1002 
      self._iprot.readMessageEnd()
1003 
      raise x
559 chandransh 1004 
    result = updateUser_result()
94 ashish 1005 
    result.read(self._iprot)
1006 
    self._iprot.readMessageEnd()
3431 rajveer 1007 
    if result.success is not None:
94 ashish 1008 
      return result.success
3431 rajveer 1009 
    if result.ucex is not None:
559 chandransh 1010 
      raise result.ucex
1011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1012 
 
559 chandransh 1013 
  def authenticateUser(self, email, password):
94 ashish 1014 
    """
1015 
    Parameters:
1016 
     - email
1017 
     - password
1018 
    """
559 chandransh 1019 
    self.send_authenticateUser(email, password)
122 ashish 1020 
    return self.recv_authenticateUser()
1021 
 
559 chandransh 1022 
  def send_authenticateUser(self, email, password):
122 ashish 1023 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1024 
    args = authenticateUser_args()
559 chandransh 1025 
    args.email = email
122 ashish 1026 
    args.password = password
1027 
    args.write(self._oprot)
1028 
    self._oprot.writeMessageEnd()
1029 
    self._oprot.trans.flush()
1030 
 
1031 
  def recv_authenticateUser(self, ):
1032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1033 
    if mtype == TMessageType.EXCEPTION:
1034 
      x = TApplicationException()
1035 
      x.read(self._iprot)
1036 
      self._iprot.readMessageEnd()
1037 
      raise x
1038 
    result = authenticateUser_result()
1039 
    result.read(self._iprot)
1040 
    self._iprot.readMessageEnd()
3431 rajveer 1041 
    if result.success is not None:
122 ashish 1042 
      return result.success
3431 rajveer 1043 
    if result.auex is not None:
559 chandransh 1044 
      raise result.auex
122 ashish 1045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1046 
 
94 ashish 1047 
  def userExists(self, email):
1048 
    """
1049 
    Parameters:
1050 
     - email
1051 
    """
1052 
    self.send_userExists(email)
1053 
    return self.recv_userExists()
1054 
 
1055 
  def send_userExists(self, email):
1056 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1057 
    args = userExists_args()
1058 
    args.email = email
1059 
    args.write(self._oprot)
1060 
    self._oprot.writeMessageEnd()
1061 
    self._oprot.trans.flush()
1062 
 
1063 
  def recv_userExists(self, ):
1064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1065 
    if mtype == TMessageType.EXCEPTION:
1066 
      x = TApplicationException()
1067 
      x.read(self._iprot)
1068 
      self._iprot.readMessageEnd()
1069 
      raise x
1070 
    result = userExists_result()
1071 
    result.read(self._iprot)
1072 
    self._iprot.readMessageEnd()
3431 rajveer 1073 
    if result.success is not None:
94 ashish 1074 
      return result.success
3431 rajveer 1075 
    if result.ucx is not None:
94 ashish 1076 
      raise result.ucx
1077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1078 
 
567 rajveer 1079 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1080 
    """
1081 
    Parameters:
1082 
     - userId
1083 
     - address
513 rajveer 1084 
     - setDefault
94 ashish 1085 
    """
567 rajveer 1086 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1087 
    return self.recv_addAddressForUser()
1088 
 
567 rajveer 1089 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1090 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1091 
    args = addAddressForUser_args()
559 chandransh 1092 
    args.userId = userId
94 ashish 1093 
    args.address = address
513 rajveer 1094 
    args.setDefault = setDefault
94 ashish 1095 
    args.write(self._oprot)
1096 
    self._oprot.writeMessageEnd()
1097 
    self._oprot.trans.flush()
1098 
 
1099 
  def recv_addAddressForUser(self, ):
1100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1101 
    if mtype == TMessageType.EXCEPTION:
1102 
      x = TApplicationException()
1103 
      x.read(self._iprot)
1104 
      self._iprot.readMessageEnd()
1105 
      raise x
1106 
    result = addAddressForUser_result()
1107 
    result.read(self._iprot)
1108 
    self._iprot.readMessageEnd()
3431 rajveer 1109 
    if result.success is not None:
94 ashish 1110 
      return result.success
3431 rajveer 1111 
    if result.ucx is not None:
94 ashish 1112 
      raise result.ucx
1113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1114 
 
1115 
  def removeAddressForUser(self, userid, addressId):
1116 
    """
1117 
    Parameters:
1118 
     - userid
1119 
     - addressId
1120 
    """
1121 
    self.send_removeAddressForUser(userid, addressId)
1122 
    return self.recv_removeAddressForUser()
1123 
 
1124 
  def send_removeAddressForUser(self, userid, addressId):
1125 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1126 
    args = removeAddressForUser_args()
1127 
    args.userid = userid
1128 
    args.addressId = addressId
1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_removeAddressForUser(self, ):
1134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1135 
    if mtype == TMessageType.EXCEPTION:
1136 
      x = TApplicationException()
1137 
      x.read(self._iprot)
1138 
      self._iprot.readMessageEnd()
1139 
      raise x
1140 
    result = removeAddressForUser_result()
1141 
    result.read(self._iprot)
1142 
    self._iprot.readMessageEnd()
3431 rajveer 1143 
    if result.success is not None:
94 ashish 1144 
      return result.success
3431 rajveer 1145 
    if result.ucx is not None:
94 ashish 1146 
      raise result.ucx
1147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1148 
 
1149 
  def setUserAsLoggedIn(self, userId, timestamp):
1150 
    """
1151 
    Parameters:
1152 
     - userId
1153 
     - timestamp
1154 
    """
1155 
    self.send_setUserAsLoggedIn(userId, timestamp)
1156 
    return self.recv_setUserAsLoggedIn()
1157 
 
1158 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1159 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1160 
    args = setUserAsLoggedIn_args()
1161 
    args.userId = userId
1162 
    args.timestamp = timestamp
1163 
    args.write(self._oprot)
1164 
    self._oprot.writeMessageEnd()
1165 
    self._oprot.trans.flush()
1166 
 
1167 
  def recv_setUserAsLoggedIn(self, ):
1168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1169 
    if mtype == TMessageType.EXCEPTION:
1170 
      x = TApplicationException()
1171 
      x.read(self._iprot)
1172 
      self._iprot.readMessageEnd()
1173 
      raise x
1174 
    result = setUserAsLoggedIn_result()
1175 
    result.read(self._iprot)
1176 
    self._iprot.readMessageEnd()
3431 rajveer 1177 
    if result.success is not None:
94 ashish 1178 
      return result.success
3431 rajveer 1179 
    if result.ucx is not None:
94 ashish 1180 
      raise result.ucx
1181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1182 
 
1183 
  def setUserAsLoggedOut(self, userid, timestamp):
1184 
    """
1185 
    Parameters:
1186 
     - userid
1187 
     - timestamp
1188 
    """
1189 
    self.send_setUserAsLoggedOut(userid, timestamp)
1190 
    return self.recv_setUserAsLoggedOut()
1191 
 
1192 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1193 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1194 
    args = setUserAsLoggedOut_args()
1195 
    args.userid = userid
1196 
    args.timestamp = timestamp
1197 
    args.write(self._oprot)
1198 
    self._oprot.writeMessageEnd()
1199 
    self._oprot.trans.flush()
1200 
 
1201 
  def recv_setUserAsLoggedOut(self, ):
1202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1203 
    if mtype == TMessageType.EXCEPTION:
1204 
      x = TApplicationException()
1205 
      x.read(self._iprot)
1206 
      self._iprot.readMessageEnd()
1207 
      raise x
1208 
    result = setUserAsLoggedOut_result()
1209 
    result.read(self._iprot)
1210 
    self._iprot.readMessageEnd()
3431 rajveer 1211 
    if result.success is not None:
94 ashish 1212 
      return result.success
3431 rajveer 1213 
    if result.ucx is not None:
94 ashish 1214 
      raise result.ucx
1215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1216 
 
504 rajveer 1217 
  def setDefaultAddress(self, userid, addressId):
1218 
    """
1219 
    Parameters:
1220 
     - userid
1221 
     - addressId
1222 
    """
1223 
    self.send_setDefaultAddress(userid, addressId)
1224 
    return self.recv_setDefaultAddress()
1225 
 
1226 
  def send_setDefaultAddress(self, userid, addressId):
1227 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1228 
    args = setDefaultAddress_args()
1229 
    args.userid = userid
1230 
    args.addressId = addressId
1231 
    args.write(self._oprot)
1232 
    self._oprot.writeMessageEnd()
1233 
    self._oprot.trans.flush()
1234 
 
1235 
  def recv_setDefaultAddress(self, ):
1236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1237 
    if mtype == TMessageType.EXCEPTION:
1238 
      x = TApplicationException()
1239 
      x.read(self._iprot)
1240 
      self._iprot.readMessageEnd()
1241 
      raise x
1242 
    result = setDefaultAddress_result()
1243 
    result.read(self._iprot)
1244 
    self._iprot.readMessageEnd()
3431 rajveer 1245 
    if result.success is not None:
504 rajveer 1246 
      return result.success
3431 rajveer 1247 
    if result.ucx is not None:
504 rajveer 1248 
      raise result.ucx
1249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1250 
 
594 rajveer 1251 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1252 
    """
1253 
    Parameters:
1254 
     - userid
594 rajveer 1255 
     - oldPassword
1256 
     - newPassword
94 ashish 1257 
    """
594 rajveer 1258 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1259 
    return self.recv_updatePassword()
1260 
 
594 rajveer 1261 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1262 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1263 
    args = updatePassword_args()
1264 
    args.userid = userid
594 rajveer 1265 
    args.oldPassword = oldPassword
1266 
    args.newPassword = newPassword
94 ashish 1267 
    args.write(self._oprot)
1268 
    self._oprot.writeMessageEnd()
1269 
    self._oprot.trans.flush()
1270 
 
1271 
  def recv_updatePassword(self, ):
1272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1273 
    if mtype == TMessageType.EXCEPTION:
1274 
      x = TApplicationException()
1275 
      x.read(self._iprot)
1276 
      self._iprot.readMessageEnd()
1277 
      raise x
1278 
    result = updatePassword_result()
1279 
    result.read(self._iprot)
1280 
    self._iprot.readMessageEnd()
3431 rajveer 1281 
    if result.success is not None:
94 ashish 1282 
      return result.success
3431 rajveer 1283 
    if result.ucx is not None:
94 ashish 1284 
      raise result.ucx
1285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1286 
 
884 rajveer 1287 
  def forgotPassword(self, email, newPassword):
581 rajveer 1288 
    """
1289 
    Parameters:
1290 
     - email
884 rajveer 1291 
     - newPassword
581 rajveer 1292 
    """
884 rajveer 1293 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1294 
    return self.recv_forgotPassword()
1295 
 
884 rajveer 1296 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1297 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1298 
    args = forgotPassword_args()
1299 
    args.email = email
884 rajveer 1300 
    args.newPassword = newPassword
581 rajveer 1301 
    args.write(self._oprot)
1302 
    self._oprot.writeMessageEnd()
1303 
    self._oprot.trans.flush()
1304 
 
1305 
  def recv_forgotPassword(self, ):
1306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1307 
    if mtype == TMessageType.EXCEPTION:
1308 
      x = TApplicationException()
1309 
      x.read(self._iprot)
1310 
      self._iprot.readMessageEnd()
1311 
      raise x
1312 
    result = forgotPassword_result()
1313 
    result.read(self._iprot)
1314 
    self._iprot.readMessageEnd()
3431 rajveer 1315 
    if result.success is not None:
581 rajveer 1316 
      return result.success
3431 rajveer 1317 
    if result.ucx is not None:
581 rajveer 1318 
      raise result.ucx
1319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1320 
 
594 rajveer 1321 
  def getAllAddressesForUser(self, userId):
1322 
    """
1323 
    Parameters:
1324 
     - userId
1325 
    """
1326 
    self.send_getAllAddressesForUser(userId)
1327 
    return self.recv_getAllAddressesForUser()
1328 
 
1329 
  def send_getAllAddressesForUser(self, userId):
1330 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1331 
    args = getAllAddressesForUser_args()
1332 
    args.userId = userId
1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
1337 
  def recv_getAllAddressesForUser(self, ):
1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
1344 
    result = getAllAddressesForUser_result()
1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
3431 rajveer 1347 
    if result.success is not None:
594 rajveer 1348 
      return result.success
3431 rajveer 1349 
    if result.ucx is not None:
594 rajveer 1350 
      raise result.ucx
1351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1352 
 
1894 vikas 1353 
  def getAddressById(self, addressId):
1354 
    """
1355 
    Parameters:
1356 
     - addressId
1357 
    """
1358 
    self.send_getAddressById(addressId)
1359 
    return self.recv_getAddressById()
1360 
 
1361 
  def send_getAddressById(self, addressId):
1362 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1363 
    args = getAddressById_args()
1364 
    args.addressId = addressId
1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1369 
  def recv_getAddressById(self, ):
1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1376 
    result = getAddressById_result()
1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
3431 rajveer 1379 
    if result.success is not None:
1894 vikas 1380 
      return result.success
3431 rajveer 1381 
    if result.ucx is not None:
1894 vikas 1382 
      raise result.ucx
1383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1384 
 
594 rajveer 1385 
  def getDefaultAddressId(self, userId):
1386 
    """
1387 
    Parameters:
1388 
     - userId
1389 
    """
1390 
    self.send_getDefaultAddressId(userId)
1391 
    return self.recv_getDefaultAddressId()
1392 
 
1393 
  def send_getDefaultAddressId(self, userId):
1394 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1395 
    args = getDefaultAddressId_args()
1396 
    args.userId = userId
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_getDefaultAddressId(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = getDefaultAddressId_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
3431 rajveer 1411 
    if result.success is not None:
594 rajveer 1412 
      return result.success
3431 rajveer 1413 
    if result.ucx is not None:
594 rajveer 1414 
      raise result.ucx
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1416 
 
785 rajveer 1417 
  def getDefaultPincode(self, userId):
1418 
    """
1419 
    Parameters:
1420 
     - userId
1421 
    """
1422 
    self.send_getDefaultPincode(userId)
1423 
    return self.recv_getDefaultPincode()
1424 
 
1425 
  def send_getDefaultPincode(self, userId):
1426 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1427 
    args = getDefaultPincode_args()
1428 
    args.userId = userId
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getDefaultPincode(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getDefaultPincode_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
3431 rajveer 1443 
    if result.success is not None:
785 rajveer 1444 
      return result.success
3431 rajveer 1445 
    if result.ucx is not None:
785 rajveer 1446 
      raise result.ucx
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1448 
 
1274 varun.gupt 1449 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1450 
    """
1451 
    Parameters:
1452 
     - userId
1453 
     - replyTo
1454 
     - communicationType
1455 
     - orderId
1456 
     - airwaybillNo
1457 
     - productName
1458 
     - subject
1459 
     - message
1460 
    """
1461 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1462 
    return self.recv_saveUserCommunication()
1463 
 
1464 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1465 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1466 
    args = saveUserCommunication_args()
1467 
    args.userId = userId
1468 
    args.replyTo = replyTo
1469 
    args.communicationType = communicationType
1470 
    args.orderId = orderId
1471 
    args.airwaybillNo = airwaybillNo
1472 
    args.productName = productName
1473 
    args.subject = subject
1474 
    args.message = message
1475 
    args.write(self._oprot)
1476 
    self._oprot.writeMessageEnd()
1477 
    self._oprot.trans.flush()
1478 
 
1479 
  def recv_saveUserCommunication(self, ):
1480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1481 
    if mtype == TMessageType.EXCEPTION:
1482 
      x = TApplicationException()
1483 
      x.read(self._iprot)
1484 
      self._iprot.readMessageEnd()
1485 
      raise x
1486 
    result = saveUserCommunication_result()
1487 
    result.read(self._iprot)
1488 
    self._iprot.readMessageEnd()
3431 rajveer 1489 
    if result.success is not None:
1274 varun.gupt 1490 
      return result.success
3431 rajveer 1491 
    if result.ucx is not None:
1274 varun.gupt 1492 
      raise result.ucx
1493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1494 
 
1590 varun.gupt 1495 
  def getUserCommunicationById(self, id):
1496 
    """
1497 
    Parameters:
1498 
     - id
1499 
    """
1500 
    self.send_getUserCommunicationById(id)
1501 
    return self.recv_getUserCommunicationById()
1502 
 
1503 
  def send_getUserCommunicationById(self, id):
1504 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1505 
    args = getUserCommunicationById_args()
1506 
    args.id = id
1507 
    args.write(self._oprot)
1508 
    self._oprot.writeMessageEnd()
1509 
    self._oprot.trans.flush()
1510 
 
1511 
  def recv_getUserCommunicationById(self, ):
1512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1513 
    if mtype == TMessageType.EXCEPTION:
1514 
      x = TApplicationException()
1515 
      x.read(self._iprot)
1516 
      self._iprot.readMessageEnd()
1517 
      raise x
1518 
    result = getUserCommunicationById_result()
1519 
    result.read(self._iprot)
1520 
    self._iprot.readMessageEnd()
3431 rajveer 1521 
    if result.success is not None:
1590 varun.gupt 1522 
      return result.success
3431 rajveer 1523 
    if result.ucx is not None:
1590 varun.gupt 1524 
      raise result.ucx
1525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1526 
 
1527 
  def getUserCommunicationByUser(self, userId):
1528 
    """
1529 
    Parameters:
1530 
     - userId
1531 
    """
1532 
    self.send_getUserCommunicationByUser(userId)
1533 
    return self.recv_getUserCommunicationByUser()
1534 
 
1535 
  def send_getUserCommunicationByUser(self, userId):
1536 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1537 
    args = getUserCommunicationByUser_args()
1538 
    args.userId = userId
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_getUserCommunicationByUser(self, ):
1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
1550 
    result = getUserCommunicationByUser_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
3431 rajveer 1553 
    if result.success is not None:
1590 varun.gupt 1554 
      return result.success
3431 rajveer 1555 
    if result.ucx is not None:
1590 varun.gupt 1556 
      raise result.ucx
1557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1558 
 
1559 
  def getAllUserCommunications(self, ):
1560 
    self.send_getAllUserCommunications()
1561 
    return self.recv_getAllUserCommunications()
1562 
 
1563 
  def send_getAllUserCommunications(self, ):
1564 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1565 
    args = getAllUserCommunications_args()
1566 
    args.write(self._oprot)
1567 
    self._oprot.writeMessageEnd()
1568 
    self._oprot.trans.flush()
1569 
 
1570 
  def recv_getAllUserCommunications(self, ):
1571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1572 
    if mtype == TMessageType.EXCEPTION:
1573 
      x = TApplicationException()
1574 
      x.read(self._iprot)
1575 
      self._iprot.readMessageEnd()
1576 
      raise x
1577 
    result = getAllUserCommunications_result()
1578 
    result.read(self._iprot)
1579 
    self._iprot.readMessageEnd()
3431 rajveer 1580 
    if result.success is not None:
1590 varun.gupt 1581 
      return result.success
3431 rajveer 1582 
    if result.ucx is not None:
1590 varun.gupt 1583 
      raise result.ucx
1584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1585 
 
5407 amar.kumar 1586 
  def removeUserCommunication(self, id):
1587 
    """
1588 
    Parameters:
1589 
     - id
1590 
    """
1591 
    self.send_removeUserCommunication(id)
1592 
    self.recv_removeUserCommunication()
1593 
 
1594 
  def send_removeUserCommunication(self, id):
1595 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1596 
    args = removeUserCommunication_args()
1597 
    args.id = id
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_removeUserCommunication(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = removeUserCommunication_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
1612 
    if result.ucx is not None:
1613 
      raise result.ucx
1614 
    return
1615 
 
1859 vikas 1616 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1617 
    """
1618 
    Parameters:
1619 
     - name
1859 vikas 1620 
     - addedOn
1845 vikas 1621 
    """
1859 vikas 1622 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1623 
    return self.recv_createMasterAffiliate()
1624 
 
1859 vikas 1625 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1626 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1627 
    args = createMasterAffiliate_args()
1628 
    args.name = name
1859 vikas 1629 
    args.addedOn = addedOn
1845 vikas 1630 
    args.write(self._oprot)
1631 
    self._oprot.writeMessageEnd()
1632 
    self._oprot.trans.flush()
1633 
 
1634 
  def recv_createMasterAffiliate(self, ):
1635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1636 
    if mtype == TMessageType.EXCEPTION:
1637 
      x = TApplicationException()
1638 
      x.read(self._iprot)
1639 
      self._iprot.readMessageEnd()
1640 
      raise x
1641 
    result = createMasterAffiliate_result()
1642 
    result.read(self._iprot)
1643 
    self._iprot.readMessageEnd()
3431 rajveer 1644 
    if result.success is not None:
1845 vikas 1645 
      return result.success
3431 rajveer 1646 
    if result.utx is not None:
1845 vikas 1647 
      raise result.utx
1648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1649 
 
1899 vikas 1650 
  def getAllMasterAffiliates(self, ):
1651 
    self.send_getAllMasterAffiliates()
1652 
    return self.recv_getAllMasterAffiliates()
1653 
 
1654 
  def send_getAllMasterAffiliates(self, ):
1655 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1656 
    args = getAllMasterAffiliates_args()
1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
1661 
  def recv_getAllMasterAffiliates(self, ):
1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
1668 
    result = getAllMasterAffiliates_result()
1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
3431 rajveer 1671 
    if result.success is not None:
1899 vikas 1672 
      return result.success
3431 rajveer 1673 
    if result.utx is not None:
1899 vikas 1674 
      raise result.utx
1675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1676 
 
1845 vikas 1677 
  def getMasterAffiliateById(self, id):
1678 
    """
1679 
    Parameters:
1680 
     - id
1681 
    """
1682 
    self.send_getMasterAffiliateById(id)
1683 
    return self.recv_getMasterAffiliateById()
1684 
 
1685 
  def send_getMasterAffiliateById(self, id):
1686 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1687 
    args = getMasterAffiliateById_args()
1688 
    args.id = id
1689 
    args.write(self._oprot)
1690 
    self._oprot.writeMessageEnd()
1691 
    self._oprot.trans.flush()
1692 
 
1693 
  def recv_getMasterAffiliateById(self, ):
1694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1695 
    if mtype == TMessageType.EXCEPTION:
1696 
      x = TApplicationException()
1697 
      x.read(self._iprot)
1698 
      self._iprot.readMessageEnd()
1699 
      raise x
1700 
    result = getMasterAffiliateById_result()
1701 
    result.read(self._iprot)
1702 
    self._iprot.readMessageEnd()
3431 rajveer 1703 
    if result.success is not None:
1845 vikas 1704 
      return result.success
3431 rajveer 1705 
    if result.utx is not None:
1845 vikas 1706 
      raise result.utx
1707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1708 
 
1709 
  def getMasterAffiliateByName(self, name):
1710 
    """
1711 
    Parameters:
1712 
     - name
1713 
    """
1714 
    self.send_getMasterAffiliateByName(name)
1715 
    return self.recv_getMasterAffiliateByName()
1716 
 
1717 
  def send_getMasterAffiliateByName(self, name):
1718 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1719 
    args = getMasterAffiliateByName_args()
1720 
    args.name = name
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_getMasterAffiliateByName(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = getMasterAffiliateByName_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
3431 rajveer 1735 
    if result.success is not None:
1845 vikas 1736 
      return result.success
3431 rajveer 1737 
    if result.utx is not None:
1845 vikas 1738 
      raise result.utx
1739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1740 
 
1859 vikas 1741 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1742 
    """
1743 
    Parameters:
1744 
     - name
1745 
     - url
1746 
     - masterAffiliateId
1859 vikas 1747 
     - addedOn
1845 vikas 1748 
    """
1859 vikas 1749 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1750 
    return self.recv_createAffiliate()
1751 
 
1859 vikas 1752 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1753 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1754 
    args = createAffiliate_args()
1755 
    args.name = name
1756 
    args.url = url
1757 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1758 
    args.addedOn = addedOn
1845 vikas 1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_createAffiliate(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = createAffiliate_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
3431 rajveer 1773 
    if result.success is not None:
1845 vikas 1774 
      return result.success
3431 rajveer 1775 
    if result.utx is not None:
1845 vikas 1776 
      raise result.utx
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1778 
 
1779 
  def getAffiliateById(self, id):
1780 
    """
1781 
    Parameters:
1782 
     - id
1783 
    """
1784 
    self.send_getAffiliateById(id)
1785 
    return self.recv_getAffiliateById()
1786 
 
1787 
  def send_getAffiliateById(self, id):
1788 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1789 
    args = getAffiliateById_args()
1790 
    args.id = id
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getAffiliateById(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getAffiliateById_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
3431 rajveer 1805 
    if result.success is not None:
1845 vikas 1806 
      return result.success
3431 rajveer 1807 
    if result.utx is not None:
1845 vikas 1808 
      raise result.utx
1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1810 
 
1811 
  def getAffiliateByName(self, name):
1812 
    """
1813 
    Parameters:
1814 
     - name
1815 
    """
1816 
    self.send_getAffiliateByName(name)
1817 
    return self.recv_getAffiliateByName()
1818 
 
1819 
  def send_getAffiliateByName(self, name):
1820 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1821 
    args = getAffiliateByName_args()
1822 
    args.name = name
1823 
    args.write(self._oprot)
1824 
    self._oprot.writeMessageEnd()
1825 
    self._oprot.trans.flush()
1826 
 
1827 
  def recv_getAffiliateByName(self, ):
1828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1829 
    if mtype == TMessageType.EXCEPTION:
1830 
      x = TApplicationException()
1831 
      x.read(self._iprot)
1832 
      self._iprot.readMessageEnd()
1833 
      raise x
1834 
    result = getAffiliateByName_result()
1835 
    result.read(self._iprot)
1836 
    self._iprot.readMessageEnd()
3431 rajveer 1837 
    if result.success is not None:
1845 vikas 1838 
      return result.success
3431 rajveer 1839 
    if result.utx is not None:
1845 vikas 1840 
      raise result.utx
1841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1842 
 
1996 vikas 1843 
  def getTrackerById(self, id):
1845 vikas 1844 
    """
1845 
    Parameters:
1846 
     - id
1847 
    """
1996 vikas 1848 
    self.send_getTrackerById(id)
1845 vikas 1849 
    return self.recv_getTrackerById()
1850 
 
1996 vikas 1851 
  def send_getTrackerById(self, id):
1845 vikas 1852 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1853 
    args = getTrackerById_args()
1996 vikas 1854 
    args.id = id
1845 vikas 1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_getTrackerById(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = getTrackerById_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
3431 rajveer 1869 
    if result.success is not None:
1845 vikas 1870 
      return result.success
3431 rajveer 1871 
    if result.utx is not None:
1845 vikas 1872 
      raise result.utx
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1874 
 
1996 vikas 1875 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1876 
    """
1877 
    Parameters:
1996 vikas 1878 
     - id
1845 vikas 1879 
    """
1996 vikas 1880 
    self.send_getAffiliatesByMasterAffiliate(id)
1881 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1882 
 
1996 vikas 1883 
  def send_getAffiliatesByMasterAffiliate(self, id):
1884 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1885 
    args = getAffiliatesByMasterAffiliate_args()
1886 
    args.id = id
1845 vikas 1887 
    args.write(self._oprot)
1888 
    self._oprot.writeMessageEnd()
1889 
    self._oprot.trans.flush()
1890 
 
1996 vikas 1891 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1893 
    if mtype == TMessageType.EXCEPTION:
1894 
      x = TApplicationException()
1895 
      x.read(self._iprot)
1896 
      self._iprot.readMessageEnd()
1897 
      raise x
1996 vikas 1898 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1899 
    result.read(self._iprot)
1900 
    self._iprot.readMessageEnd()
3431 rajveer 1901 
    if result.success is not None:
1845 vikas 1902 
      return result.success
3431 rajveer 1903 
    if result.utx is not None:
1845 vikas 1904 
      raise result.utx
1996 vikas 1905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1906 
 
1996 vikas 1907 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1908 
    """
1909 
    Parameters:
1996 vikas 1910 
     - affiliateId
1845 vikas 1911 
     - userId
1912 
     - event
1913 
     - url
1914 
     - data
1859 vikas 1915 
     - addedOn
1845 vikas 1916 
    """
1996 vikas 1917 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1918 
    return self.recv_addTrackLog()
1919 
 
1996 vikas 1920 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1921 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1922 
    args = addTrackLog_args()
1996 vikas 1923 
    args.affiliateId = affiliateId
1845 vikas 1924 
    args.userId = userId
1925 
    args.event = event
1926 
    args.url = url
1927 
    args.data = data
1859 vikas 1928 
    args.addedOn = addedOn
1845 vikas 1929 
    args.write(self._oprot)
1930 
    self._oprot.writeMessageEnd()
1931 
    self._oprot.trans.flush()
1932 
 
1933 
  def recv_addTrackLog(self, ):
1934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1935 
    if mtype == TMessageType.EXCEPTION:
1936 
      x = TApplicationException()
1937 
      x.read(self._iprot)
1938 
      self._iprot.readMessageEnd()
1939 
      raise x
1940 
    result = addTrackLog_result()
1941 
    result.read(self._iprot)
1942 
    self._iprot.readMessageEnd()
3431 rajveer 1943 
    if result.success is not None:
1845 vikas 1944 
      return result.success
3431 rajveer 1945 
    if result.utx is not None:
1845 vikas 1946 
      raise result.utx
1947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1948 
 
1949 
  def getTrackLogById(self, id):
1950 
    """
1951 
    Parameters:
1952 
     - id
1953 
    """
1954 
    self.send_getTrackLogById(id)
1955 
    return self.recv_getTrackLogById()
1956 
 
1957 
  def send_getTrackLogById(self, id):
1958 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1959 
    args = getTrackLogById_args()
1960 
    args.id = id
1961 
    args.write(self._oprot)
1962 
    self._oprot.writeMessageEnd()
1963 
    self._oprot.trans.flush()
1964 
 
1965 
  def recv_getTrackLogById(self, ):
1966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1967 
    if mtype == TMessageType.EXCEPTION:
1968 
      x = TApplicationException()
1969 
      x.read(self._iprot)
1970 
      self._iprot.readMessageEnd()
1971 
      raise x
1972 
    result = getTrackLogById_result()
1973 
    result.read(self._iprot)
1974 
    self._iprot.readMessageEnd()
3431 rajveer 1975 
    if result.success is not None:
1845 vikas 1976 
      return result.success
3431 rajveer 1977 
    if result.utx is not None:
1845 vikas 1978 
      raise result.utx
1979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1980 
 
3293 vikas 1981 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1982 
    """
1983 
    Parameters:
1996 vikas 1984 
     - affiliateId
3293 vikas 1985 
     - startDate
1986 
     - endDate
1845 vikas 1987 
    """
3293 vikas 1988 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1989 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1990 
 
3293 vikas 1991 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1992 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1993 
    args = getTrackLogsByAffiliate_args()
1994 
    args.affiliateId = affiliateId
3293 vikas 1995 
    args.startDate = startDate
1996 
    args.endDate = endDate
1845 vikas 1997 
    args.write(self._oprot)
1998 
    self._oprot.writeMessageEnd()
1999 
    self._oprot.trans.flush()
2000 
 
1996 vikas 2001 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2003 
    if mtype == TMessageType.EXCEPTION:
2004 
      x = TApplicationException()
2005 
      x.read(self._iprot)
2006 
      self._iprot.readMessageEnd()
2007 
      raise x
1996 vikas 2008 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2009 
    result.read(self._iprot)
2010 
    self._iprot.readMessageEnd()
3431 rajveer 2011 
    if result.success is not None:
1845 vikas 2012 
      return result.success
3431 rajveer 2013 
    if result.utx is not None:
1845 vikas 2014 
      raise result.utx
1996 vikas 2015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2016 
 
2017 
  def getTrackLogsByUser(self, userId):
2018 
    """
2019 
    Parameters:
2020 
     - userId
2021 
    """
2022 
    self.send_getTrackLogsByUser(userId)
2023 
    return self.recv_getTrackLogsByUser()
2024 
 
2025 
  def send_getTrackLogsByUser(self, userId):
2026 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2027 
    args = getTrackLogsByUser_args()
2028 
    args.userId = userId
2029 
    args.write(self._oprot)
2030 
    self._oprot.writeMessageEnd()
2031 
    self._oprot.trans.flush()
2032 
 
2033 
  def recv_getTrackLogsByUser(self, ):
2034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2035 
    if mtype == TMessageType.EXCEPTION:
2036 
      x = TApplicationException()
2037 
      x.read(self._iprot)
2038 
      self._iprot.readMessageEnd()
2039 
      raise x
2040 
    result = getTrackLogsByUser_result()
2041 
    result.read(self._iprot)
2042 
    self._iprot.readMessageEnd()
3431 rajveer 2043 
    if result.success is not None:
1845 vikas 2044 
      return result.success
3431 rajveer 2045 
    if result.utx is not None:
1845 vikas 2046 
      raise result.utx
2047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2048 
 
1996 vikas 2049 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2050 
    """
2051 
    Parameters:
2052 
     - userId
2053 
     - event
2054 
     - url
2055 
    """
1996 vikas 2056 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2057 
    return self.recv_getTrackLogs()
2058 
 
1996 vikas 2059 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2060 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2061 
    args = getTrackLogs_args()
2062 
    args.userId = userId
2063 
    args.event = event
2064 
    args.url = url
2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
2069 
  def recv_getTrackLogs(self, ):
2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
2076 
    result = getTrackLogs_result()
2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
3431 rajveer 2079 
    if result.success is not None:
1845 vikas 2080 
      return result.success
3431 rajveer 2081 
    if result.utx is not None:
1845 vikas 2082 
      raise result.utx
2083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2084 
 
559 chandransh 2085 
  def getCurrentCart(self, userId):
94 ashish 2086 
    """
2087 
    Parameters:
559 chandransh 2088 
     - userId
94 ashish 2089 
    """
559 chandransh 2090 
    self.send_getCurrentCart(userId)
2091 
    return self.recv_getCurrentCart()
94 ashish 2092 
 
559 chandransh 2093 
  def send_getCurrentCart(self, userId):
2094 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2095 
    args = getCurrentCart_args()
2096 
    args.userId = userId
94 ashish 2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
559 chandransh 2101 
  def recv_getCurrentCart(self, ):
94 ashish 2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
559 chandransh 2108 
    result = getCurrentCart_result()
94 ashish 2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
3431 rajveer 2111 
    if result.success is not None:
94 ashish 2112 
      return result.success
3431 rajveer 2113 
    if result.scx is not None:
559 chandransh 2114 
      raise result.scx
2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2116 
 
559 chandransh 2117 
  def getCart(self, cartId):
94 ashish 2118 
    """
2119 
    Parameters:
559 chandransh 2120 
     - cartId
94 ashish 2121 
    """
559 chandransh 2122 
    self.send_getCart(cartId)
2123 
    return self.recv_getCart()
94 ashish 2124 
 
559 chandransh 2125 
  def send_getCart(self, cartId):
2126 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2127 
    args = getCart_args()
2128 
    args.cartId = cartId
94 ashish 2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
559 chandransh 2133 
  def recv_getCart(self, ):
94 ashish 2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
559 chandransh 2140 
    result = getCart_result()
94 ashish 2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
3431 rajveer 2143 
    if result.success is not None:
94 ashish 2144 
      return result.success
3431 rajveer 2145 
    if result.scx is not None:
559 chandransh 2146 
      raise result.scx
2147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2148 
 
559 chandransh 2149 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2150 
    """
2151 
    Parameters:
559 chandransh 2152 
     - from_time
2153 
     - to_time
2154 
     - status
94 ashish 2155 
    """
559 chandransh 2156 
    self.send_getCartsByTime(from_time, to_time, status)
2157 
    return self.recv_getCartsByTime()
94 ashish 2158 
 
559 chandransh 2159 
  def send_getCartsByTime(self, from_time, to_time, status):
2160 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2161 
    args = getCartsByTime_args()
2162 
    args.from_time = from_time
2163 
    args.to_time = to_time
2164 
    args.status = status
94 ashish 2165 
    args.write(self._oprot)
2166 
    self._oprot.writeMessageEnd()
2167 
    self._oprot.trans.flush()
2168 
 
559 chandransh 2169 
  def recv_getCartsByTime(self, ):
94 ashish 2170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2171 
    if mtype == TMessageType.EXCEPTION:
2172 
      x = TApplicationException()
2173 
      x.read(self._iprot)
2174 
      self._iprot.readMessageEnd()
2175 
      raise x
559 chandransh 2176 
    result = getCartsByTime_result()
94 ashish 2177 
    result.read(self._iprot)
2178 
    self._iprot.readMessageEnd()
3431 rajveer 2179 
    if result.success is not None:
94 ashish 2180 
      return result.success
3431 rajveer 2181 
    if result.scx is not None:
559 chandransh 2182 
      raise result.scx
2183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2184 
 
3557 rajveer 2185 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2186 
    """
2187 
    Parameters:
2188 
     - cartId
2189 
     - itemId
2190 
     - quantity
3557 rajveer 2191 
     - sourceId
559 chandransh 2192 
    """
3557 rajveer 2193 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2194 
    return self.recv_addItemToCart()
559 chandransh 2195 
 
3557 rajveer 2196 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2197 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2198 
    args = addItemToCart_args()
2199 
    args.cartId = cartId
2200 
    args.itemId = itemId
2201 
    args.quantity = quantity
3557 rajveer 2202 
    args.sourceId = sourceId
559 chandransh 2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
2207 
  def recv_addItemToCart(self, ):
2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
2214 
    result = addItemToCart_result()
2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
3431 rajveer 2217 
    if result.success is not None:
2035 rajveer 2218 
      return result.success
3431 rajveer 2219 
    if result.scx is not None:
559 chandransh 2220 
      raise result.scx
2035 rajveer 2221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2222 
 
2223 
  def deleteItemFromCart(self, cartId, itemId):
2224 
    """
2225 
    Parameters:
2226 
     - cartId
2227 
     - itemId
2228 
    """
2229 
    self.send_deleteItemFromCart(cartId, itemId)
2230 
    self.recv_deleteItemFromCart()
2231 
 
2232 
  def send_deleteItemFromCart(self, cartId, itemId):
2233 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2234 
    args = deleteItemFromCart_args()
2235 
    args.cartId = cartId
2236 
    args.itemId = itemId
2237 
    args.write(self._oprot)
2238 
    self._oprot.writeMessageEnd()
2239 
    self._oprot.trans.flush()
2240 
 
2241 
  def recv_deleteItemFromCart(self, ):
2242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2243 
    if mtype == TMessageType.EXCEPTION:
2244 
      x = TApplicationException()
2245 
      x.read(self._iprot)
2246 
      self._iprot.readMessageEnd()
2247 
      raise x
2248 
    result = deleteItemFromCart_result()
2249 
    result.read(self._iprot)
2250 
    self._iprot.readMessageEnd()
3431 rajveer 2251 
    if result.scx is not None:
559 chandransh 2252 
      raise result.scx
2253 
    return
2254 
 
2255 
  def addAddressToCart(self, cartId, addressId):
2256 
    """
2257 
    Parameters:
2258 
     - cartId
2259 
     - addressId
2260 
    """
2261 
    self.send_addAddressToCart(cartId, addressId)
2262 
    self.recv_addAddressToCart()
2263 
 
2264 
  def send_addAddressToCart(self, cartId, addressId):
2265 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2266 
    args = addAddressToCart_args()
2267 
    args.cartId = cartId
2268 
    args.addressId = addressId
2269 
    args.write(self._oprot)
2270 
    self._oprot.writeMessageEnd()
2271 
    self._oprot.trans.flush()
2272 
 
2273 
  def recv_addAddressToCart(self, ):
2274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2275 
    if mtype == TMessageType.EXCEPTION:
2276 
      x = TApplicationException()
2277 
      x.read(self._iprot)
2278 
      self._iprot.readMessageEnd()
2279 
      raise x
2280 
    result = addAddressToCart_result()
2281 
    result.read(self._iprot)
2282 
    self._iprot.readMessageEnd()
3431 rajveer 2283 
    if result.scx is not None:
575 chandransh 2284 
      raise result.scx
559 chandransh 2285 
    return
2286 
 
5553 rajveer 2287 
  def addStoreToCart(self, cartId, storeId):
2288 
    """
2289 
    Parameters:
2290 
     - cartId
2291 
     - storeId
2292 
    """
2293 
    self.send_addStoreToCart(cartId, storeId)
2294 
    self.recv_addStoreToCart()
2295 
 
2296 
  def send_addStoreToCart(self, cartId, storeId):
2297 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2298 
    args = addStoreToCart_args()
2299 
    args.cartId = cartId
2300 
    args.storeId = storeId
2301 
    args.write(self._oprot)
2302 
    self._oprot.writeMessageEnd()
2303 
    self._oprot.trans.flush()
2304 
 
2305 
  def recv_addStoreToCart(self, ):
2306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2307 
    if mtype == TMessageType.EXCEPTION:
2308 
      x = TApplicationException()
2309 
      x.read(self._iprot)
2310 
      self._iprot.readMessageEnd()
2311 
      raise x
2312 
    result = addStoreToCart_result()
2313 
    result.read(self._iprot)
2314 
    self._iprot.readMessageEnd()
2315 
    if result.scx is not None:
2316 
      raise result.scx
2317 
    return
2318 
 
6922 anupam.sin 2319 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2320 
    """
2321 
    Parameters:
6922 anupam.sin 2322 
     - cart
1976 varun.gupt 2323 
     - couponCode
2324 
    """
6922 anupam.sin 2325 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2326 
    self.recv_applyCouponToCart()
2327 
 
6922 anupam.sin 2328 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2329 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2330 
    args = applyCouponToCart_args()
6922 anupam.sin 2331 
    args.cart = cart
1976 varun.gupt 2332 
    args.couponCode = couponCode
2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_applyCouponToCart(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = applyCouponToCart_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
3431 rajveer 2347 
    if result.scx is not None:
1976 varun.gupt 2348 
      raise result.scx
2349 
    return
2350 
 
2351 
  def removeCoupon(self, cartId):
2352 
    """
2353 
    Parameters:
2354 
     - cartId
2355 
    """
2356 
    self.send_removeCoupon(cartId)
2357 
    self.recv_removeCoupon()
2358 
 
2359 
  def send_removeCoupon(self, cartId):
2360 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2361 
    args = removeCoupon_args()
2362 
    args.cartId = cartId
2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
2367 
  def recv_removeCoupon(self, ):
2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
2374 
    result = removeCoupon_result()
2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
3431 rajveer 2377 
    if result.scx is not None:
1976 varun.gupt 2378 
      raise result.scx
2379 
    return
2380 
 
3554 varun.gupt 2381 
  def deleteDiscountsFromCart(self, cartId):
2382 
    """
2383 
    Deletes all the discounts associated with the cart
2384 
 
2385 
    Parameters:
2386 
     - cartId
2387 
    """
2388 
    self.send_deleteDiscountsFromCart(cartId)
2389 
    self.recv_deleteDiscountsFromCart()
2390 
 
2391 
  def send_deleteDiscountsFromCart(self, cartId):
2392 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2393 
    args = deleteDiscountsFromCart_args()
2394 
    args.cartId = cartId
2395 
    args.write(self._oprot)
2396 
    self._oprot.writeMessageEnd()
2397 
    self._oprot.trans.flush()
2398 
 
2399 
  def recv_deleteDiscountsFromCart(self, ):
2400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2401 
    if mtype == TMessageType.EXCEPTION:
2402 
      x = TApplicationException()
2403 
      x.read(self._iprot)
2404 
      self._iprot.readMessageEnd()
2405 
      raise x
2406 
    result = deleteDiscountsFromCart_result()
2407 
    result.read(self._iprot)
2408 
    self._iprot.readMessageEnd()
2409 
    if result.scx is not None:
2410 
      raise result.scx
2411 
    return
2412 
 
2413 
  def saveDiscounts(self, discounts):
2414 
    """
2415 
    Accepts a list of thrift objects of Discount type and saves them
2416 
 
2417 
    Parameters:
2418 
     - discounts
2419 
    """
2420 
    self.send_saveDiscounts(discounts)
2421 
    self.recv_saveDiscounts()
2422 
 
2423 
  def send_saveDiscounts(self, discounts):
2424 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2425 
    args = saveDiscounts_args()
2426 
    args.discounts = discounts
2427 
    args.write(self._oprot)
2428 
    self._oprot.writeMessageEnd()
2429 
    self._oprot.trans.flush()
2430 
 
2431 
  def recv_saveDiscounts(self, ):
2432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2433 
    if mtype == TMessageType.EXCEPTION:
2434 
      x = TApplicationException()
2435 
      x.read(self._iprot)
2436 
      self._iprot.readMessageEnd()
2437 
      raise x
2438 
    result = saveDiscounts_result()
2439 
    result.read(self._iprot)
2440 
    self._iprot.readMessageEnd()
2441 
    if result.scx is not None:
2442 
      raise result.scx
2443 
    return
2444 
 
11526 amit.gupta 2445 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2446 
    """
690 chandransh 2447 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2448 
 
559 chandransh 2449 
    Parameters:
2450 
     - cartId
2815 vikas 2451 
     - sessionSource
2452 
     - sessionStartTime
3858 vikas 2453 
     - firstSource
2454 
     - firstSourceTime
5326 rajveer 2455 
     - userId
6389 rajveer 2456 
     - schemeId
11526 amit.gupta 2457 
     - orderSource
559 chandransh 2458 
    """
11526 amit.gupta 2459 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2460 
    return self.recv_createOrders()
559 chandransh 2461 
 
11526 amit.gupta 2462 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2463 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2464 
    args = createOrders_args()
559 chandransh 2465 
    args.cartId = cartId
2815 vikas 2466 
    args.sessionSource = sessionSource
2467 
    args.sessionStartTime = sessionStartTime
3858 vikas 2468 
    args.firstSource = firstSource
2469 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2470 
    args.userId = userId
6389 rajveer 2471 
    args.schemeId = schemeId
11526 amit.gupta 2472 
    args.orderSource = orderSource
559 chandransh 2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
690 chandransh 2477 
  def recv_createOrders(self, ):
559 chandransh 2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
690 chandransh 2484 
    result = createOrders_result()
559 chandransh 2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
3431 rajveer 2487 
    if result.success is not None:
130 ashish 2488 
      return result.success
3431 rajveer 2489 
    if result.scx is not None:
559 chandransh 2490 
      raise result.scx
690 chandransh 2491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2492 
 
3557 rajveer 2493 
  def validateCart(self, cartId, sourceId):
130 ashish 2494 
    """
690 chandransh 2495 
    Validates that:
2496 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2497 
    2. All of the lines in the cart are active items.
690 chandransh 2498 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2499 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2500 
 
130 ashish 2501 
    Parameters:
559 chandransh 2502 
     - cartId
3557 rajveer 2503 
     - sourceId
130 ashish 2504 
    """
3557 rajveer 2505 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2506 
    return self.recv_validateCart()
130 ashish 2507 
 
3557 rajveer 2508 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2509 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2510 
    args = validateCart_args()
2511 
    args.cartId = cartId
3557 rajveer 2512 
    args.sourceId = sourceId
130 ashish 2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
559 chandransh 2517 
  def recv_validateCart(self, ):
130 ashish 2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
559 chandransh 2524 
    result = validateCart_result()
130 ashish 2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
3431 rajveer 2527 
    if result.success is not None:
130 ashish 2528 
      return result.success
3431 rajveer 2529 
    if result.scex is not None:
575 chandransh 2530 
      raise result.scex
559 chandransh 2531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2532 
 
11980 amit.gupta 2533 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2534 
    """
2535 
    Validates that:
2536 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2537 
    2. All of the lines in the cart are active items.
2538 
    3. The estimate for any of the lines in cart doesn't change.
2539 
    If all three are true, returns empty string; else returns appropriate message.
2540 
 
2541 
    Parameters:
2542 
     - cartId
2543 
     - sourceId
2544 
     - dealCoupon
2545 
    """
2546 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2547 
    return self.recv_validateCartWithDealerCoupon()
2548 
 
2549 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2550 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2551 
    args = validateCartWithDealerCoupon_args()
2552 
    args.cartId = cartId
2553 
    args.sourceId = sourceId
2554 
    args.dealCoupon = dealCoupon
2555 
    args.write(self._oprot)
2556 
    self._oprot.writeMessageEnd()
2557 
    self._oprot.trans.flush()
2558 
 
2559 
  def recv_validateCartWithDealerCoupon(self, ):
2560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2561 
    if mtype == TMessageType.EXCEPTION:
2562 
      x = TApplicationException()
2563 
      x.read(self._iprot)
2564 
      self._iprot.readMessageEnd()
2565 
      raise x
2566 
    result = validateCartWithDealerCoupon_result()
2567 
    result.read(self._iprot)
2568 
    self._iprot.readMessageEnd()
2569 
    if result.success is not None:
2570 
      return result.success
2571 
    if result.scex is not None:
2572 
      raise result.scex
2573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2574 
 
690 chandransh 2575 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2576 
    """
690 chandransh 2577 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2578 
 
575 chandransh 2579 
    Parameters:
690 chandransh 2580 
     - fromCartId
2581 
     - toCartId
2582 
    """
2583 
    self.send_mergeCart(fromCartId, toCartId)
2584 
    self.recv_mergeCart()
2585 
 
2586 
  def send_mergeCart(self, fromCartId, toCartId):
2587 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2588 
    args = mergeCart_args()
2589 
    args.fromCartId = fromCartId
2590 
    args.toCartId = toCartId
2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
2595 
  def recv_mergeCart(self, ):
2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
2602 
    result = mergeCart_result()
2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
2605 
    return
2606 
 
2607 
  def checkOut(self, cartId):
2608 
    """
2609 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2610 
 
690 chandransh 2611 
    Parameters:
575 chandransh 2612 
     - cartId
2613 
    """
690 chandransh 2614 
    self.send_checkOut(cartId)
2615 
    return self.recv_checkOut()
575 chandransh 2616 
 
690 chandransh 2617 
  def send_checkOut(self, cartId):
2618 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2619 
    args = checkOut_args()
575 chandransh 2620 
    args.cartId = cartId
2621 
    args.write(self._oprot)
2622 
    self._oprot.writeMessageEnd()
2623 
    self._oprot.trans.flush()
2624 
 
690 chandransh 2625 
  def recv_checkOut(self, ):
575 chandransh 2626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2627 
    if mtype == TMessageType.EXCEPTION:
2628 
      x = TApplicationException()
2629 
      x.read(self._iprot)
2630 
      self._iprot.readMessageEnd()
2631 
      raise x
690 chandransh 2632 
    result = checkOut_result()
575 chandransh 2633 
    result.read(self._iprot)
2634 
    self._iprot.readMessageEnd()
3431 rajveer 2635 
    if result.success is not None:
575 chandransh 2636 
      return result.success
3431 rajveer 2637 
    if result.scex is not None:
575 chandransh 2638 
      raise result.scex
690 chandransh 2639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2640 
 
690 chandransh 2641 
  def resetCart(self, cartId, items):
559 chandransh 2642 
    """
690 chandransh 2643 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2644 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2645 
 
559 chandransh 2646 
    Parameters:
690 chandransh 2647 
     - cartId
2648 
     - items
559 chandransh 2649 
    """
690 chandransh 2650 
    self.send_resetCart(cartId, items)
2651 
    return self.recv_resetCart()
130 ashish 2652 
 
690 chandransh 2653 
  def send_resetCart(self, cartId, items):
2654 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2655 
    args = resetCart_args()
2656 
    args.cartId = cartId
2657 
    args.items = items
559 chandransh 2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
690 chandransh 2662 
  def recv_resetCart(self, ):
559 chandransh 2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
690 chandransh 2669 
    result = resetCart_result()
559 chandransh 2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
3431 rajveer 2672 
    if result.success is not None:
690 chandransh 2673 
      return result.success
3431 rajveer 2674 
    if result.scex is not None:
690 chandransh 2675 
      raise result.scex
2676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2677 
 
2981 rajveer 2678 
  def getUserCount(self, userType):
559 chandransh 2679 
    """
2981 rajveer 2680 
    Returns number of registered users.
2681 
    If userType = null, then it returns count of all users, including anonymous
2682 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2683 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2684 
 
559 chandransh 2685 
    Parameters:
2981 rajveer 2686 
     - userType
559 chandransh 2687 
    """
2981 rajveer 2688 
    self.send_getUserCount(userType)
2689 
    return self.recv_getUserCount()
559 chandransh 2690 
 
2981 rajveer 2691 
  def send_getUserCount(self, userType):
2692 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2693 
    args = getUserCount_args()
2694 
    args.userType = userType
559 chandransh 2695 
    args.write(self._oprot)
2696 
    self._oprot.writeMessageEnd()
2697 
    self._oprot.trans.flush()
2698 
 
2981 rajveer 2699 
  def recv_getUserCount(self, ):
559 chandransh 2700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2701 
    if mtype == TMessageType.EXCEPTION:
2702 
      x = TApplicationException()
2703 
      x.read(self._iprot)
2704 
      self._iprot.readMessageEnd()
2705 
      raise x
2981 rajveer 2706 
    result = getUserCount_result()
559 chandransh 2707 
    result.read(self._iprot)
2708 
    self._iprot.readMessageEnd()
3431 rajveer 2709 
    if result.success is not None:
559 chandransh 2710 
      return result.success
2981 rajveer 2711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2712 
 
2981 rajveer 2713 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2714 
    """
2981 rajveer 2715 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2716 
    If any of startDate or endDate is -1, then that filter is ignored.
2717 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2718 
 
2719 
 
559 chandransh 2720 
    Parameters:
2981 rajveer 2721 
     - userType
2722 
     - startDate
2723 
     - endDate
559 chandransh 2724 
    """
2981 rajveer 2725 
    self.send_getAllUsers(userType, startDate, endDate)
2726 
    return self.recv_getAllUsers()
559 chandransh 2727 
 
2981 rajveer 2728 
  def send_getAllUsers(self, userType, startDate, endDate):
2729 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2730 
    args = getAllUsers_args()
2731 
    args.userType = userType
2732 
    args.startDate = startDate
2733 
    args.endDate = endDate
559 chandransh 2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
2981 rajveer 2738 
  def recv_getAllUsers(self, ):
559 chandransh 2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
2981 rajveer 2745 
    result = getAllUsers_result()
559 chandransh 2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
3431 rajveer 2748 
    if result.success is not None:
559 chandransh 2749 
      return result.success
2981 rajveer 2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2751 
 
2981 rajveer 2752 
  def getMyResearchItems(self, userId):
559 chandransh 2753 
    """
2981 rajveer 2754 
    Returns list of item ids in myresearch for the user
3431 rajveer 2755 
 
559 chandransh 2756 
    Parameters:
772 rajveer 2757 
     - userId
559 chandransh 2758 
    """
2981 rajveer 2759 
    self.send_getMyResearchItems(userId)
2760 
    return self.recv_getMyResearchItems()
559 chandransh 2761 
 
2981 rajveer 2762 
  def send_getMyResearchItems(self, userId):
2763 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2764 
    args = getMyResearchItems_args()
772 rajveer 2765 
    args.userId = userId
559 chandransh 2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
2981 rajveer 2770 
  def recv_getMyResearchItems(self, ):
559 chandransh 2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
2981 rajveer 2777 
    result = getMyResearchItems_result()
559 chandransh 2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
3431 rajveer 2780 
    if result.success is not None:
559 chandransh 2781 
      return result.success
3431 rajveer 2782 
    if result.scx is not None:
559 chandransh 2783 
      raise result.scx
2981 rajveer 2784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2785 
 
2981 rajveer 2786 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2787 
    """
2981 rajveer 2788 
    add item to my research for a user
3431 rajveer 2789 
 
559 chandransh 2790 
    Parameters:
2981 rajveer 2791 
     - userId
2792 
     - itemId
559 chandransh 2793 
    """
2981 rajveer 2794 
    self.send_updateMyResearch(userId, itemId)
2795 
    return self.recv_updateMyResearch()
559 chandransh 2796 
 
2981 rajveer 2797 
  def send_updateMyResearch(self, userId, itemId):
2798 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2799 
    args = updateMyResearch_args()
2800 
    args.userId = userId
2801 
    args.itemId = itemId
559 chandransh 2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2981 rajveer 2806 
  def recv_updateMyResearch(self, ):
559 chandransh 2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2981 rajveer 2813 
    result = updateMyResearch_result()
559 chandransh 2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
3431 rajveer 2816 
    if result.success is not None:
2981 rajveer 2817 
      return result.success
3431 rajveer 2818 
    if result.scx is not None:
2981 rajveer 2819 
      raise result.scx
2820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2821 
 
2981 rajveer 2822 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2823 
    """
2981 rajveer 2824 
    delete item from my research for a user
3431 rajveer 2825 
 
1596 ankur.sing 2826 
    Parameters:
2981 rajveer 2827 
     - userId
2828 
     - itemId
1596 ankur.sing 2829 
    """
2981 rajveer 2830 
    self.send_deleteItemFromMyResearch(userId, itemId)
2831 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2832 
 
2981 rajveer 2833 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2834 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2835 
    args = deleteItemFromMyResearch_args()
2836 
    args.userId = userId
2837 
    args.itemId = itemId
1596 ankur.sing 2838 
    args.write(self._oprot)
2839 
    self._oprot.writeMessageEnd()
2840 
    self._oprot.trans.flush()
2841 
 
2981 rajveer 2842 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2844 
    if mtype == TMessageType.EXCEPTION:
2845 
      x = TApplicationException()
2846 
      x.read(self._iprot)
2847 
      self._iprot.readMessageEnd()
2848 
      raise x
2981 rajveer 2849 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2850 
    result.read(self._iprot)
2851 
    self._iprot.readMessageEnd()
3431 rajveer 2852 
    if result.scx is not None:
2981 rajveer 2853 
      raise result.scx
2854 
    return
1596 ankur.sing 2855 
 
2981 rajveer 2856 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2857 
    """
2981 rajveer 2858 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2859 
 
1673 ankur.sing 2860 
    Parameters:
2981 rajveer 2861 
     - userId
1673 ankur.sing 2862 
    """
2981 rajveer 2863 
    self.send_getBrowseHistoryItems(userId)
2864 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2865 
 
2981 rajveer 2866 
  def send_getBrowseHistoryItems(self, userId):
2867 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2868 
    args = getBrowseHistoryItems_args()
2869 
    args.userId = userId
1673 ankur.sing 2870 
    args.write(self._oprot)
2871 
    self._oprot.writeMessageEnd()
2872 
    self._oprot.trans.flush()
2873 
 
2981 rajveer 2874 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2876 
    if mtype == TMessageType.EXCEPTION:
2877 
      x = TApplicationException()
2878 
      x.read(self._iprot)
2879 
      self._iprot.readMessageEnd()
2880 
      raise x
2981 rajveer 2881 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2882 
    result.read(self._iprot)
2883 
    self._iprot.readMessageEnd()
3431 rajveer 2884 
    if result.success is not None:
1673 ankur.sing 2885 
      return result.success
3431 rajveer 2886 
    if result.scx is not None:
2981 rajveer 2887 
      raise result.scx
2888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2889 
 
2981 rajveer 2890 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2891 
    """
2981 rajveer 2892 
    add item to browse history for a user
3431 rajveer 2893 
 
2642 varun.gupt 2894 
    Parameters:
2981 rajveer 2895 
     - userId
2896 
     - itemId
2642 varun.gupt 2897 
    """
2981 rajveer 2898 
    self.send_updateBrowseHistory(userId, itemId)
2899 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2900 
 
2981 rajveer 2901 
  def send_updateBrowseHistory(self, userId, itemId):
2902 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2903 
    args = updateBrowseHistory_args()
2904 
    args.userId = userId
2905 
    args.itemId = itemId
2642 varun.gupt 2906 
    args.write(self._oprot)
2907 
    self._oprot.writeMessageEnd()
2908 
    self._oprot.trans.flush()
2909 
 
2981 rajveer 2910 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2912 
    if mtype == TMessageType.EXCEPTION:
2913 
      x = TApplicationException()
2914 
      x.read(self._iprot)
2915 
      self._iprot.readMessageEnd()
2916 
      raise x
2981 rajveer 2917 
    result = updateBrowseHistory_result()
2642 varun.gupt 2918 
    result.read(self._iprot)
2919 
    self._iprot.readMessageEnd()
2920 
    return
2921 
 
3385 varun.gupt 2922 
  def getCartsWithCouponCount(self, couponCode):
2923 
    """
2924 
    Returns count of Carts with given coupon applied
3431 rajveer 2925 
 
3385 varun.gupt 2926 
    Parameters:
2927 
     - couponCode
2928 
    """
2929 
    self.send_getCartsWithCouponCount(couponCode)
2930 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2931 
 
3385 varun.gupt 2932 
  def send_getCartsWithCouponCount(self, couponCode):
2933 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2934 
    args = getCartsWithCouponCount_args()
2935 
    args.couponCode = couponCode
2936 
    args.write(self._oprot)
2937 
    self._oprot.writeMessageEnd()
2938 
    self._oprot.trans.flush()
2939 
 
2940 
  def recv_getCartsWithCouponCount(self, ):
2941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2942 
    if mtype == TMessageType.EXCEPTION:
2943 
      x = TApplicationException()
2944 
      x.read(self._iprot)
2945 
      self._iprot.readMessageEnd()
2946 
      raise x
2947 
    result = getCartsWithCouponCount_result()
2948 
    result.read(self._iprot)
2949 
    self._iprot.readMessageEnd()
3431 rajveer 2950 
    if result.success is not None:
3385 varun.gupt 2951 
      return result.success
2952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2953 
 
3499 mandeep.dh 2954 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2955 
    """
2956 
    Updates COD trust level of a user
3385 varun.gupt 2957 
 
3499 mandeep.dh 2958 
    Parameters:
2959 
     - userId
2960 
     - trustLevelDelta
2961 
    """
2962 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2963 
 
2964 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2965 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2966 
    args = increaseTrustLevel_args()
2967 
    args.userId = userId
2968 
    args.trustLevelDelta = trustLevelDelta
2969 
    args.write(self._oprot)
2970 
    self._oprot.writeMessageEnd()
2971 
    self._oprot.trans.flush()
5407 amar.kumar 2972 
  def getTrustLevel(self, userId):
2973 
    """
2974 
    Get trust level of a user
2975 
 
2976 
    Parameters:
2977 
     - userId
2978 
    """
2979 
    self.send_getTrustLevel(userId)
2980 
    return self.recv_getTrustLevel()
2981 
 
2982 
  def send_getTrustLevel(self, userId):
2983 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2984 
    args = getTrustLevel_args()
2985 
    args.userId = userId
2986 
    args.write(self._oprot)
2987 
    self._oprot.writeMessageEnd()
2988 
    self._oprot.trans.flush()
2989 
 
2990 
  def recv_getTrustLevel(self, ):
2991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2992 
    if mtype == TMessageType.EXCEPTION:
2993 
      x = TApplicationException()
2994 
      x.read(self._iprot)
2995 
      self._iprot.readMessageEnd()
2996 
      raise x
2997 
    result = getTrustLevel_result()
2998 
    result.read(self._iprot)
2999 
    self._iprot.readMessageEnd()
3000 
    if result.success is not None:
3001 
      return result.success
3002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3003 
 
4668 varun.gupt 3004 
  def showCODOption(self, cartId, sourceId, pincode):
3005 
    """
3006 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3007 
 
4668 varun.gupt 3008 
    Parameters:
3009 
     - cartId
3010 
     - sourceId
3011 
     - pincode
3012 
    """
3013 
    self.send_showCODOption(cartId, sourceId, pincode)
3014 
    return self.recv_showCODOption()
3015 
 
3016 
  def send_showCODOption(self, cartId, sourceId, pincode):
3017 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3018 
    args = showCODOption_args()
3019 
    args.cartId = cartId
3020 
    args.sourceId = sourceId
3021 
    args.pincode = pincode
3022 
    args.write(self._oprot)
3023 
    self._oprot.writeMessageEnd()
3024 
    self._oprot.trans.flush()
3025 
 
3026 
  def recv_showCODOption(self, ):
3027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3028 
    if mtype == TMessageType.EXCEPTION:
3029 
      x = TApplicationException()
3030 
      x.read(self._iprot)
3031 
      self._iprot.readMessageEnd()
3032 
      raise x
3033 
    result = showCODOption_result()
3034 
    result.read(self._iprot)
3035 
    self._iprot.readMessageEnd()
3036 
    if result.success is not None:
3037 
      return result.success
3038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3039 
 
5623 anupam.sin 3040 
  def getUserEmails(self, startDate, endDate):
3041 
    """
3042 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3043 
 
5623 anupam.sin 3044 
    Parameters:
3045 
     - startDate
3046 
     - endDate
3047 
    """
3048 
    self.send_getUserEmails(startDate, endDate)
3049 
    return self.recv_getUserEmails()
3050 
 
3051 
  def send_getUserEmails(self, startDate, endDate):
3052 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3053 
    args = getUserEmails_args()
3054 
    args.startDate = startDate
3055 
    args.endDate = endDate
3056 
    args.write(self._oprot)
3057 
    self._oprot.writeMessageEnd()
3058 
    self._oprot.trans.flush()
3059 
 
3060 
  def recv_getUserEmails(self, ):
3061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3062 
    if mtype == TMessageType.EXCEPTION:
3063 
      x = TApplicationException()
3064 
      x.read(self._iprot)
3065 
      self._iprot.readMessageEnd()
3066 
      raise x
3067 
    result = getUserEmails_result()
3068 
    result.read(self._iprot)
3069 
    self._iprot.readMessageEnd()
3070 
    if result.success is not None:
3071 
      return result.success
3072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3073 
 
9299 kshitij.so 3074 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3075 
    """
3076 
    Mark a cart lineitem as insured. Returns true/false.
3077 
 
3078 
    Parameters:
3079 
     - itemId
3080 
     - cartId
3081 
     - toInsure
9299 kshitij.so 3082 
     - insurerType
6903 anupam.sin 3083 
    """
9299 kshitij.so 3084 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3085 
    return self.recv_insureItem()
3086 
 
9299 kshitij.so 3087 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3088 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3089 
    args = insureItem_args()
3090 
    args.itemId = itemId
3091 
    args.cartId = cartId
3092 
    args.toInsure = toInsure
9299 kshitij.so 3093 
    args.insurerType = insurerType
6903 anupam.sin 3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
3097 
 
3098 
  def recv_insureItem(self, ):
3099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3100 
    if mtype == TMessageType.EXCEPTION:
3101 
      x = TApplicationException()
3102 
      x.read(self._iprot)
3103 
      self._iprot.readMessageEnd()
3104 
      raise x
3105 
    result = insureItem_result()
3106 
    result.read(self._iprot)
3107 
    self._iprot.readMessageEnd()
3108 
    if result.success is not None:
3109 
      return result.success
3110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3111 
 
3112 
  def cancelInsurance(self, cartId):
3113 
    """
3114 
    Cancel insurance for all items in the cart
3115 
 
3116 
    Parameters:
3117 
     - cartId
3118 
    """
3119 
    self.send_cancelInsurance(cartId)
3120 
    return self.recv_cancelInsurance()
3121 
 
3122 
  def send_cancelInsurance(self, cartId):
3123 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3124 
    args = cancelInsurance_args()
3125 
    args.cartId = cartId
3126 
    args.write(self._oprot)
3127 
    self._oprot.writeMessageEnd()
3128 
    self._oprot.trans.flush()
3129 
 
3130 
  def recv_cancelInsurance(self, ):
3131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3132 
    if mtype == TMessageType.EXCEPTION:
3133 
      x = TApplicationException()
3134 
      x.read(self._iprot)
3135 
      self._iprot.readMessageEnd()
3136 
      raise x
3137 
    result = cancelInsurance_result()
3138 
    result.read(self._iprot)
3139 
    self._iprot.readMessageEnd()
3140 
    if result.success is not None:
3141 
      return result.success
3142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3143 
 
3144 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3145 
    """
3146 
    Stores insurance specific details like date of birth and guardianName
3147 
 
3148 
    Parameters:
3149 
     - addressId
3150 
     - dob
3151 
     - guardianName
3152 
    """
3153 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3154 
    return self.recv_storeInsuranceSpecificDetails()
3155 
 
3156 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3157 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3158 
    args = storeInsuranceSpecificDetails_args()
3159 
    args.addressId = addressId
3160 
    args.dob = dob
3161 
    args.guardianName = guardianName
3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_storeInsuranceSpecificDetails(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = storeInsuranceSpecificDetails_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3176 
    if result.success is not None:
3177 
      return result.success
3178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3179 
 
3180 
  def isInsuranceDetailPresent(self, addressId):
3181 
    """
3182 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3183 
 
3184 
    Parameters:
3185 
     - addressId
3186 
    """
3187 
    self.send_isInsuranceDetailPresent(addressId)
3188 
    return self.recv_isInsuranceDetailPresent()
3189 
 
3190 
  def send_isInsuranceDetailPresent(self, addressId):
3191 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3192 
    args = isInsuranceDetailPresent_args()
3193 
    args.addressId = addressId
3194 
    args.write(self._oprot)
3195 
    self._oprot.writeMessageEnd()
3196 
    self._oprot.trans.flush()
3197 
 
3198 
  def recv_isInsuranceDetailPresent(self, ):
3199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3200 
    if mtype == TMessageType.EXCEPTION:
3201 
      x = TApplicationException()
3202 
      x.read(self._iprot)
3203 
      self._iprot.readMessageEnd()
3204 
      raise x
3205 
    result = isInsuranceDetailPresent_result()
3206 
    result.read(self._iprot)
3207 
    self._iprot.readMessageEnd()
3208 
    if result.success is not None:
3209 
      return result.success
3210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3211 
 
9791 rajveer 3212 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3213 
    """
9791 rajveer 3214 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3215 
 
6821 amar.kumar 3216 
    Parameters:
3217 
     - startDate
3218 
     - endDate
3219 
    """
9791 rajveer 3220 
    self.send_getProductsAddedToCart(startDate, endDate)
3221 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3222 
 
9791 rajveer 3223 
  def send_getProductsAddedToCart(self, startDate, endDate):
3224 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3225 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3226 
    args.startDate = startDate
3227 
    args.endDate = endDate
3228 
    args.write(self._oprot)
3229 
    self._oprot.writeMessageEnd()
3230 
    self._oprot.trans.flush()
3231 
 
9791 rajveer 3232 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3234 
    if mtype == TMessageType.EXCEPTION:
3235 
      x = TApplicationException()
3236 
      x.read(self._iprot)
3237 
      self._iprot.readMessageEnd()
3238 
      raise x
9791 rajveer 3239 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3240 
    result.read(self._iprot)
3241 
    self._iprot.readMessageEnd()
3242 
    if result.success is not None:
3243 
      return result.success
9791 rajveer 3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3245 
 
11980 amit.gupta 3246 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3247 
    """
3248 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3249 
 
11592 amit.gupta 3250 
    Parameters:
3251 
     - cartId
3252 
     - sourceId
11980 amit.gupta 3253 
     - dealerCoupon
11592 amit.gupta 3254 
    """
11980 amit.gupta 3255 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3256 
    return self.recv_validateCartPlus()
3257 
 
11980 amit.gupta 3258 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3259 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3260 
    args = validateCartPlus_args()
3261 
    args.cartId = cartId
3262 
    args.sourceId = sourceId
11980 amit.gupta 3263 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3264 
    args.write(self._oprot)
3265 
    self._oprot.writeMessageEnd()
3266 
    self._oprot.trans.flush()
3267 
 
3268 
  def recv_validateCartPlus(self, ):
3269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3270 
    if mtype == TMessageType.EXCEPTION:
3271 
      x = TApplicationException()
3272 
      x.read(self._iprot)
3273 
      self._iprot.readMessageEnd()
3274 
      raise x
3275 
    result = validateCartPlus_result()
3276 
    result.read(self._iprot)
3277 
    self._iprot.readMessageEnd()
3278 
    if result.success is not None:
3279 
      return result.success
3280 
    if result.scex is not None:
3281 
      raise result.scex
3282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3283 
 
11679 vikram.rag 3284 
  def isPrivateDealUser(self, userId):
3285 
    """
3286 
    Parameters:
3287 
     - userId
3288 
    """
3289 
    self.send_isPrivateDealUser(userId)
3290 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3291 
 
11679 vikram.rag 3292 
  def send_isPrivateDealUser(self, userId):
3293 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3294 
    args = isPrivateDealUser_args()
3295 
    args.userId = userId
3296 
    args.write(self._oprot)
3297 
    self._oprot.writeMessageEnd()
3298 
    self._oprot.trans.flush()
3299 
 
3300 
  def recv_isPrivateDealUser(self, ):
3301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3302 
    if mtype == TMessageType.EXCEPTION:
3303 
      x = TApplicationException()
3304 
      x.read(self._iprot)
3305 
      self._iprot.readMessageEnd()
3306 
      raise x
3307 
    result = isPrivateDealUser_result()
3308 
    result.read(self._iprot)
3309 
    self._iprot.readMessageEnd()
3310 
    if result.success is not None:
3311 
      return result.success
3312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3313 
 
11890 kshitij.so 3314 
  def addPrivateDealUser(self, userId):
3315 
    """
3316 
    Parameters:
3317 
     - userId
3318 
    """
3319 
    self.send_addPrivateDealUser(userId)
3320 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3321 
 
11890 kshitij.so 3322 
  def send_addPrivateDealUser(self, userId):
3323 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3324 
    args = addPrivateDealUser_args()
3325 
    args.userId = userId
3326 
    args.write(self._oprot)
3327 
    self._oprot.writeMessageEnd()
3328 
    self._oprot.trans.flush()
3329 
 
3330 
  def recv_addPrivateDealUser(self, ):
3331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3332 
    if mtype == TMessageType.EXCEPTION:
3333 
      x = TApplicationException()
3334 
      x.read(self._iprot)
3335 
      self._iprot.readMessageEnd()
3336 
      raise x
3337 
    result = addPrivateDealUser_result()
3338 
    result.read(self._iprot)
3339 
    self._iprot.readMessageEnd()
3340 
    if result.success is not None:
3341 
      return result.success
3342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3343 
 
3344 
  def changePrivateDealUserStatus(self, userId, isActive):
3345 
    """
3346 
    Parameters:
3347 
     - userId
3348 
     - isActive
3349 
    """
3350 
    self.send_changePrivateDealUserStatus(userId, isActive)
3351 
    return self.recv_changePrivateDealUserStatus()
3352 
 
3353 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3354 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3355 
    args = changePrivateDealUserStatus_args()
3356 
    args.userId = userId
3357 
    args.isActive = isActive
3358 
    args.write(self._oprot)
3359 
    self._oprot.writeMessageEnd()
3360 
    self._oprot.trans.flush()
3361 
 
3362 
  def recv_changePrivateDealUserStatus(self, ):
3363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3364 
    if mtype == TMessageType.EXCEPTION:
3365 
      x = TApplicationException()
3366 
      x.read(self._iprot)
3367 
      self._iprot.readMessageEnd()
3368 
      raise x
3369 
    result = changePrivateDealUserStatus_result()
3370 
    result.read(self._iprot)
3371 
    self._iprot.readMessageEnd()
3372 
    if result.success is not None:
3373 
      return result.success
3374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3375 
 
3376 
  def getPrivateDealUser(self, userId):
3377 
    """
3378 
    Parameters:
3379 
     - userId
3380 
    """
3381 
    self.send_getPrivateDealUser(userId)
3382 
    return self.recv_getPrivateDealUser()
3383 
 
3384 
  def send_getPrivateDealUser(self, userId):
3385 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3386 
    args = getPrivateDealUser_args()
3387 
    args.userId = userId
3388 
    args.write(self._oprot)
3389 
    self._oprot.writeMessageEnd()
3390 
    self._oprot.trans.flush()
3391 
 
3392 
  def recv_getPrivateDealUser(self, ):
3393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3394 
    if mtype == TMessageType.EXCEPTION:
3395 
      x = TApplicationException()
3396 
      x.read(self._iprot)
3397 
      self._iprot.readMessageEnd()
3398 
      raise x
3399 
    result = getPrivateDealUser_result()
3400 
    result.read(self._iprot)
3401 
    self._iprot.readMessageEnd()
3402 
    if result.success is not None:
3403 
      return result.success
3404 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3405 
 
12696 amit.gupta 3406 
  def registerCounter(self, counter, userId):
3407 
    """
3408 
    Parameters:
3409 
     - counter
3410 
     - userId
3411 
    """
3412 
    self.send_registerCounter(counter, userId)
3413 
    return self.recv_registerCounter()
11890 kshitij.so 3414 
 
12696 amit.gupta 3415 
  def send_registerCounter(self, counter, userId):
3416 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3417 
    args = registerCounter_args()
3418 
    args.counter = counter
3419 
    args.userId = userId
3420 
    args.write(self._oprot)
3421 
    self._oprot.writeMessageEnd()
3422 
    self._oprot.trans.flush()
3423 
 
3424 
  def recv_registerCounter(self, ):
3425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3426 
    if mtype == TMessageType.EXCEPTION:
3427 
      x = TApplicationException()
3428 
      x.read(self._iprot)
3429 
      self._iprot.readMessageEnd()
3430 
      raise x
3431 
    result = registerCounter_result()
3432 
    result.read(self._iprot)
3433 
    self._iprot.readMessageEnd()
3434 
    if result.success is not None:
3435 
      return result.success
3436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3437 
 
12722 amit.gupta 3438 
  def searchCounter(self, type1, searchString):
3439 
    """
3440 
    Parameters:
3441 
     - type1
3442 
     - searchString
3443 
    """
3444 
    self.send_searchCounter(type1, searchString)
3445 
    return self.recv_searchCounter()
12696 amit.gupta 3446 
 
12722 amit.gupta 3447 
  def send_searchCounter(self, type1, searchString):
3448 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3449 
    args = searchCounter_args()
3450 
    args.type1 = type1
3451 
    args.searchString = searchString
3452 
    args.write(self._oprot)
3453 
    self._oprot.writeMessageEnd()
3454 
    self._oprot.trans.flush()
3455 
 
3456 
  def recv_searchCounter(self, ):
3457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3458 
    if mtype == TMessageType.EXCEPTION:
3459 
      x = TApplicationException()
3460 
      x.read(self._iprot)
3461 
      self._iprot.readMessageEnd()
3462 
      raise x
3463 
    result = searchCounter_result()
3464 
    result.read(self._iprot)
3465 
    self._iprot.readMessageEnd()
3466 
    if result.success is not None:
3467 
      return result.success
3468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3469 
 
3470 
  def getAllUsersByCounter(self, counterId):
3471 
    """
3472 
    Parameters:
3473 
     - counterId
3474 
    """
3475 
    self.send_getAllUsersByCounter(counterId)
3476 
    return self.recv_getAllUsersByCounter()
3477 
 
3478 
  def send_getAllUsersByCounter(self, counterId):
3479 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3480 
    args = getAllUsersByCounter_args()
3481 
    args.counterId = counterId
3482 
    args.write(self._oprot)
3483 
    self._oprot.writeMessageEnd()
3484 
    self._oprot.trans.flush()
3485 
 
3486 
  def recv_getAllUsersByCounter(self, ):
3487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3488 
    if mtype == TMessageType.EXCEPTION:
3489 
      x = TApplicationException()
3490 
      x.read(self._iprot)
3491 
      self._iprot.readMessageEnd()
3492 
      raise x
3493 
    result = getAllUsersByCounter_result()
3494 
    result.read(self._iprot)
3495 
    self._iprot.readMessageEnd()
3496 
    if result.success is not None:
3497 
      return result.success
3498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3499 
 
15251 manish.sha 3500 
  def getActiveAccessTokenForUser(self, userId, source):
3501 
    """
3502 
    Parameters:
3503 
     - userId
3504 
     - source
3505 
    """
3506 
    self.send_getActiveAccessTokenForUser(userId, source)
3507 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3508 
 
15251 manish.sha 3509 
  def send_getActiveAccessTokenForUser(self, userId, source):
3510 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3511 
    args = getActiveAccessTokenForUser_args()
3512 
    args.userId = userId
3513 
    args.source = source
3514 
    args.write(self._oprot)
3515 
    self._oprot.writeMessageEnd()
3516 
    self._oprot.trans.flush()
3517 
 
3518 
  def recv_getActiveAccessTokenForUser(self, ):
3519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3520 
    if mtype == TMessageType.EXCEPTION:
3521 
      x = TApplicationException()
3522 
      x.read(self._iprot)
3523 
      self._iprot.readMessageEnd()
3524 
      raise x
3525 
    result = getActiveAccessTokenForUser_result()
3526 
    result.read(self._iprot)
3527 
    self._iprot.readMessageEnd()
3528 
    if result.success is not None:
3529 
      return result.success
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3531 
 
3532 
  def validateAccessToken(self, accessToken):
3533 
    """
3534 
    Parameters:
3535 
     - accessToken
3536 
    """
3537 
    self.send_validateAccessToken(accessToken)
3538 
    return self.recv_validateAccessToken()
3539 
 
3540 
  def send_validateAccessToken(self, accessToken):
3541 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3542 
    args = validateAccessToken_args()
3543 
    args.accessToken = accessToken
3544 
    args.write(self._oprot)
3545 
    self._oprot.writeMessageEnd()
3546 
    self._oprot.trans.flush()
3547 
 
3548 
  def recv_validateAccessToken(self, ):
3549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3550 
    if mtype == TMessageType.EXCEPTION:
3551 
      x = TApplicationException()
3552 
      x.read(self._iprot)
3553 
      self._iprot.readMessageEnd()
3554 
      raise x
3555 
    result = validateAccessToken_result()
3556 
    result.read(self._iprot)
3557 
    self._iprot.readMessageEnd()
3558 
    if result.success is not None:
3559 
      return result.success
3560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3561 
 
17782 amit.gupta 3562 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3563 
    """
3564 
    Parameters:
3565 
     - cartId
3566 
     - itemQty
3567 
     - couponCode
3568 
    """
3569 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3570 
    return self.recv_addItemsToCart()
15251 manish.sha 3571 
 
17782 amit.gupta 3572 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3573 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3574 
    args = addItemsToCart_args()
3575 
    args.cartId = cartId
3576 
    args.itemQty = itemQty
3577 
    args.couponCode = couponCode
3578 
    args.write(self._oprot)
3579 
    self._oprot.writeMessageEnd()
3580 
    self._oprot.trans.flush()
3581 
 
3582 
  def recv_addItemsToCart(self, ):
3583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3584 
    if mtype == TMessageType.EXCEPTION:
3585 
      x = TApplicationException()
3586 
      x.read(self._iprot)
3587 
      self._iprot.readMessageEnd()
3588 
      raise x
3589 
    result = addItemsToCart_result()
3590 
    result.read(self._iprot)
3591 
    self._iprot.readMessageEnd()
3592 
    if result.success is not None:
3593 
      return result.success
3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3595 
 
3596 
  def validateCartNew(self, cartId, pinCode, sourceId):
3597 
    """
3598 
    Parameters:
3599 
     - cartId
3600 
     - pinCode
3601 
     - sourceId
3602 
    """
3603 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3604 
    return self.recv_validateCartNew()
3605 
 
3606 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3607 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3608 
    args = validateCartNew_args()
3609 
    args.cartId = cartId
3610 
    args.pinCode = pinCode
3611 
    args.sourceId = sourceId
3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_validateCartNew(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = validateCartNew_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
3626 
    if result.success is not None:
3627 
      return result.success
3628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3629 
 
18644 manish.sha 3630 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3631 
    """
3632 
    Parameters:
3633 
     - userId
3634 
    """
18644 manish.sha 3635 
    self.send_isAddressEditableForCounter(userId)
3636 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3637 
 
18644 manish.sha 3638 
  def send_isAddressEditableForCounter(self, userId):
3639 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3640 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3641 
    args.userId = userId
3642 
    args.write(self._oprot)
3643 
    self._oprot.writeMessageEnd()
3644 
    self._oprot.trans.flush()
3645 
 
18644 manish.sha 3646 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3648 
    if mtype == TMessageType.EXCEPTION:
3649 
      x = TApplicationException()
3650 
      x.read(self._iprot)
3651 
      self._iprot.readMessageEnd()
3652 
      raise x
18644 manish.sha 3653 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3654 
    result.read(self._iprot)
3655 
    self._iprot.readMessageEnd()
3656 
    if result.success is not None:
3657 
      return result.success
18644 manish.sha 3658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3659 
 
3660 
  def getBillingAddressForUser(self, userId):
3661 
    """
3662 
    Parameters:
3663 
     - userId
3664 
    """
3665 
    self.send_getBillingAddressForUser(userId)
3666 
    return self.recv_getBillingAddressForUser()
3667 
 
3668 
  def send_getBillingAddressForUser(self, userId):
3669 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3670 
    args = getBillingAddressForUser_args()
3671 
    args.userId = userId
3672 
    args.write(self._oprot)
3673 
    self._oprot.writeMessageEnd()
3674 
    self._oprot.trans.flush()
3675 
 
3676 
  def recv_getBillingAddressForUser(self, ):
3677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3678 
    if mtype == TMessageType.EXCEPTION:
3679 
      x = TApplicationException()
3680 
      x.read(self._iprot)
3681 
      self._iprot.readMessageEnd()
3682 
      raise x
3683 
    result = getBillingAddressForUser_result()
3684 
    result.read(self._iprot)
3685 
    self._iprot.readMessageEnd()
3686 
    if result.success is not None:
3687 
      return result.success
3688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3689 
 
18590 manish.sha 3690 
  def isCreditorAssigned(self, userId):
3691 
    """
3692 
    Parameters:
3693 
     - userId
3694 
    """
3695 
    self.send_isCreditorAssigned(userId)
3696 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3697 
 
18590 manish.sha 3698 
  def send_isCreditorAssigned(self, userId):
3699 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3700 
    args = isCreditorAssigned_args()
3701 
    args.userId = userId
3702 
    args.write(self._oprot)
3703 
    self._oprot.writeMessageEnd()
3704 
    self._oprot.trans.flush()
3705 
 
3706 
  def recv_isCreditorAssigned(self, ):
3707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3708 
    if mtype == TMessageType.EXCEPTION:
3709 
      x = TApplicationException()
3710 
      x.read(self._iprot)
3711 
      self._iprot.readMessageEnd()
3712 
      raise x
3713 
    result = isCreditorAssigned_result()
3714 
    result.read(self._iprot)
3715 
    self._iprot.readMessageEnd()
3716 
    if result.success is not None:
3717 
      return result.success
3718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3719 
 
18735 manish.sha 3720 
  def isTaxInvoiceEnabledUser(self, userId):
3721 
    """
3722 
    Parameters:
3723 
     - userId
3724 
    """
3725 
    self.send_isTaxInvoiceEnabledUser(userId)
3726 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3727 
 
18735 manish.sha 3728 
  def send_isTaxInvoiceEnabledUser(self, userId):
3729 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3730 
    args = isTaxInvoiceEnabledUser_args()
3731 
    args.userId = userId
3732 
    args.write(self._oprot)
3733 
    self._oprot.writeMessageEnd()
3734 
    self._oprot.trans.flush()
3735 
 
3736 
  def recv_isTaxInvoiceEnabledUser(self, ):
3737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3738 
    if mtype == TMessageType.EXCEPTION:
3739 
      x = TApplicationException()
3740 
      x.read(self._iprot)
3741 
      self._iprot.readMessageEnd()
3742 
      raise x
3743 
    result = isTaxInvoiceEnabledUser_result()
3744 
    result.read(self._iprot)
3745 
    self._iprot.readMessageEnd()
3746 
    if result.success is not None:
3747 
      return result.success
3748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3749 
 
3750 
 
3376 rajveer 3751 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3752 
  def __init__(self, handler):
3376 rajveer 3753 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3754 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3755 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3756 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3757 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3758 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3759 
    self._processMap["createUser"] = Processor.process_createUser
3760 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3761 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3762 
    self._processMap["userExists"] = Processor.process_userExists
3763 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3764 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3765 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3766 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3767 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3768 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3769 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3770 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3771 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3772 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3773 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3774 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3775 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3776 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3777 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3778 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3779 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3780 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3781 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3782 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3783 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3784 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3785 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3786 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3787 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3788 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3789 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3790 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3791 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3792 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3793 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3794 
    self._processMap["getCart"] = Processor.process_getCart
3795 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3796 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3797 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3798 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3799 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3800 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3801 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3802 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3803 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3804 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3805 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3806 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3807 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3808 
    self._processMap["checkOut"] = Processor.process_checkOut
3809 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3810 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3811 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3812 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3813 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3814 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3815 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3816 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3817 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3818 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3819 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3820 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3821 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3822 
    self._processMap["insureItem"] = Processor.process_insureItem
3823 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3824 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3825 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3826 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3827 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3828 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3829 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3830 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3831 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3832 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3833 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3834 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3835 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3836 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3837 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3838 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 3839 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 3840 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 3841 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 3842 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
94 ashish 3843 
 
3844 
  def process(self, iprot, oprot):
3845 
    (name, type, seqid) = iprot.readMessageBegin()
3846 
    if name not in self._processMap:
3847 
      iprot.skip(TType.STRUCT)
3848 
      iprot.readMessageEnd()
3849 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3850 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3851 
      x.write(oprot)
3852 
      oprot.writeMessageEnd()
3853 
      oprot.trans.flush()
3854 
      return
3855 
    else:
3856 
      self._processMap[name](self, seqid, iprot, oprot)
3857 
    return True
3858 
 
559 chandransh 3859 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3860 
    args = createAnonymousUser_args()
94 ashish 3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
559 chandransh 3863 
    result = createAnonymousUser_result()
94 ashish 3864 
    try:
559 chandransh 3865 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3866 
    except UserContextException, ucex:
3867 
      result.ucex = ucex
3868 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3869 
    result.write(oprot)
3870 
    oprot.writeMessageEnd()
3871 
    oprot.trans.flush()
3872 
 
559 chandransh 3873 
  def process_getUserById(self, seqid, iprot, oprot):
3874 
    args = getUserById_args()
94 ashish 3875 
    args.read(iprot)
3876 
    iprot.readMessageEnd()
559 chandransh 3877 
    result = getUserById_result()
94 ashish 3878 
    try:
559 chandransh 3879 
      result.success = self._handler.getUserById(args.userId)
3880 
    except UserContextException, ucex:
3881 
      result.ucex = ucex
3882 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3883 
    result.write(oprot)
3884 
    oprot.writeMessageEnd()
3885 
    oprot.trans.flush()
3886 
 
5326 rajveer 3887 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3888 
    args = getUserByCartId_args()
3889 
    args.read(iprot)
3890 
    iprot.readMessageEnd()
3891 
    result = getUserByCartId_result()
3892 
    try:
3893 
      result.success = self._handler.getUserByCartId(args.cartId)
3894 
    except UserContextException, ucex:
3895 
      result.ucex = ucex
3896 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3897 
    result.write(oprot)
3898 
    oprot.writeMessageEnd()
3899 
    oprot.trans.flush()
3900 
 
1491 vikas 3901 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3902 
    args = getUserByEmail_args()
3903 
    args.read(iprot)
3904 
    iprot.readMessageEnd()
3905 
    result = getUserByEmail_result()
3906 
    try:
3907 
      result.success = self._handler.getUserByEmail(args.email)
3908 
    except UserContextException, ucex:
3909 
      result.ucex = ucex
3910 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3911 
    result.write(oprot)
3912 
    oprot.writeMessageEnd()
3913 
    oprot.trans.flush()
3914 
 
3032 mandeep.dh 3915 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3916 
    args = getUserByMobileNumber_args()
3917 
    args.read(iprot)
3918 
    iprot.readMessageEnd()
3919 
    result = getUserByMobileNumber_result()
3920 
    try:
3921 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3922 
    except UserContextException, ucex:
3923 
      result.ucex = ucex
3924 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3925 
    result.write(oprot)
3926 
    oprot.writeMessageEnd()
3927 
    oprot.trans.flush()
3928 
 
559 chandransh 3929 
  def process_createUser(self, seqid, iprot, oprot):
3930 
    args = createUser_args()
94 ashish 3931 
    args.read(iprot)
3932 
    iprot.readMessageEnd()
559 chandransh 3933 
    result = createUser_result()
94 ashish 3934 
    try:
559 chandransh 3935 
      result.success = self._handler.createUser(args.user)
3936 
    except UserContextException, ucex:
3937 
      result.ucex = ucex
3938 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3939 
    result.write(oprot)
3940 
    oprot.writeMessageEnd()
3941 
    oprot.trans.flush()
3942 
 
559 chandransh 3943 
  def process_updateUser(self, seqid, iprot, oprot):
3944 
    args = updateUser_args()
94 ashish 3945 
    args.read(iprot)
3946 
    iprot.readMessageEnd()
559 chandransh 3947 
    result = updateUser_result()
94 ashish 3948 
    try:
559 chandransh 3949 
      result.success = self._handler.updateUser(args.user)
3950 
    except UserContextException, ucex:
3951 
      result.ucex = ucex
3952 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3953 
    result.write(oprot)
3954 
    oprot.writeMessageEnd()
3955 
    oprot.trans.flush()
3956 
 
122 ashish 3957 
  def process_authenticateUser(self, seqid, iprot, oprot):
3958 
    args = authenticateUser_args()
3959 
    args.read(iprot)
3960 
    iprot.readMessageEnd()
3961 
    result = authenticateUser_result()
3962 
    try:
559 chandransh 3963 
      result.success = self._handler.authenticateUser(args.email, args.password)
3964 
    except AuthenticationException, auex:
3965 
      result.auex = auex
122 ashish 3966 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3967 
    result.write(oprot)
3968 
    oprot.writeMessageEnd()
3969 
    oprot.trans.flush()
3970 
 
94 ashish 3971 
  def process_userExists(self, seqid, iprot, oprot):
3972 
    args = userExists_args()
3973 
    args.read(iprot)
3974 
    iprot.readMessageEnd()
3975 
    result = userExists_result()
3976 
    try:
3977 
      result.success = self._handler.userExists(args.email)
3978 
    except UserContextException, ucx:
3979 
      result.ucx = ucx
3980 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3981 
    result.write(oprot)
3982 
    oprot.writeMessageEnd()
3983 
    oprot.trans.flush()
3984 
 
3985 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3986 
    args = addAddressForUser_args()
3987 
    args.read(iprot)
3988 
    iprot.readMessageEnd()
3989 
    result = addAddressForUser_result()
3990 
    try:
567 rajveer 3991 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3992 
    except UserContextException, ucx:
3993 
      result.ucx = ucx
3994 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
3998 
 
3999 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4000 
    args = removeAddressForUser_args()
4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
4003 
    result = removeAddressForUser_result()
4004 
    try:
4005 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4006 
    except UserContextException, ucx:
4007 
      result.ucx = ucx
4008 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4009 
    result.write(oprot)
4010 
    oprot.writeMessageEnd()
4011 
    oprot.trans.flush()
4012 
 
4013 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4014 
    args = setUserAsLoggedIn_args()
4015 
    args.read(iprot)
4016 
    iprot.readMessageEnd()
4017 
    result = setUserAsLoggedIn_result()
4018 
    try:
4019 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4020 
    except UserContextException, ucx:
4021 
      result.ucx = ucx
4022 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4023 
    result.write(oprot)
4024 
    oprot.writeMessageEnd()
4025 
    oprot.trans.flush()
4026 
 
4027 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4028 
    args = setUserAsLoggedOut_args()
4029 
    args.read(iprot)
4030 
    iprot.readMessageEnd()
4031 
    result = setUserAsLoggedOut_result()
4032 
    try:
4033 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4034 
    except UserContextException, ucx:
4035 
      result.ucx = ucx
4036 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4037 
    result.write(oprot)
4038 
    oprot.writeMessageEnd()
4039 
    oprot.trans.flush()
4040 
 
504 rajveer 4041 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4042 
    args = setDefaultAddress_args()
4043 
    args.read(iprot)
4044 
    iprot.readMessageEnd()
4045 
    result = setDefaultAddress_result()
4046 
    try:
4047 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4048 
    except UserContextException, ucx:
4049 
      result.ucx = ucx
4050 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4051 
    result.write(oprot)
4052 
    oprot.writeMessageEnd()
4053 
    oprot.trans.flush()
4054 
 
94 ashish 4055 
  def process_updatePassword(self, seqid, iprot, oprot):
4056 
    args = updatePassword_args()
4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
4059 
    result = updatePassword_result()
4060 
    try:
594 rajveer 4061 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4062 
    except UserContextException, ucx:
4063 
      result.ucx = ucx
4064 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
581 rajveer 4069 
  def process_forgotPassword(self, seqid, iprot, oprot):
4070 
    args = forgotPassword_args()
4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
4073 
    result = forgotPassword_result()
4074 
    try:
884 rajveer 4075 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4076 
    except UserContextException, ucx:
4077 
      result.ucx = ucx
4078 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
594 rajveer 4083 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4084 
    args = getAllAddressesForUser_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = getAllAddressesForUser_result()
4088 
    try:
4089 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4090 
    except UserContextException, ucx:
4091 
      result.ucx = ucx
4092 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
4096 
 
1894 vikas 4097 
  def process_getAddressById(self, seqid, iprot, oprot):
4098 
    args = getAddressById_args()
4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
4101 
    result = getAddressById_result()
4102 
    try:
4103 
      result.success = self._handler.getAddressById(args.addressId)
4104 
    except UserContextException, ucx:
4105 
      result.ucx = ucx
4106 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
594 rajveer 4111 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4112 
    args = getDefaultAddressId_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getDefaultAddressId_result()
4116 
    try:
4117 
      result.success = self._handler.getDefaultAddressId(args.userId)
4118 
    except UserContextException, ucx:
4119 
      result.ucx = ucx
4120 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4121 
    result.write(oprot)
4122 
    oprot.writeMessageEnd()
4123 
    oprot.trans.flush()
4124 
 
785 rajveer 4125 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4126 
    args = getDefaultPincode_args()
4127 
    args.read(iprot)
4128 
    iprot.readMessageEnd()
4129 
    result = getDefaultPincode_result()
4130 
    try:
4131 
      result.success = self._handler.getDefaultPincode(args.userId)
4132 
    except UserContextException, ucx:
4133 
      result.ucx = ucx
4134 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4135 
    result.write(oprot)
4136 
    oprot.writeMessageEnd()
4137 
    oprot.trans.flush()
4138 
 
1274 varun.gupt 4139 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4140 
    args = saveUserCommunication_args()
4141 
    args.read(iprot)
4142 
    iprot.readMessageEnd()
4143 
    result = saveUserCommunication_result()
4144 
    try:
4145 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4146 
    except UserCommunicationException, ucx:
4147 
      result.ucx = ucx
4148 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4149 
    result.write(oprot)
4150 
    oprot.writeMessageEnd()
4151 
    oprot.trans.flush()
4152 
 
1590 varun.gupt 4153 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4154 
    args = getUserCommunicationById_args()
4155 
    args.read(iprot)
4156 
    iprot.readMessageEnd()
4157 
    result = getUserCommunicationById_result()
4158 
    try:
4159 
      result.success = self._handler.getUserCommunicationById(args.id)
4160 
    except UserCommunicationException, ucx:
4161 
      result.ucx = ucx
4162 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4163 
    result.write(oprot)
4164 
    oprot.writeMessageEnd()
4165 
    oprot.trans.flush()
4166 
 
4167 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4168 
    args = getUserCommunicationByUser_args()
4169 
    args.read(iprot)
4170 
    iprot.readMessageEnd()
4171 
    result = getUserCommunicationByUser_result()
4172 
    try:
4173 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4174 
    except UserCommunicationException, ucx:
4175 
      result.ucx = ucx
4176 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4177 
    result.write(oprot)
4178 
    oprot.writeMessageEnd()
4179 
    oprot.trans.flush()
4180 
 
4181 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4182 
    args = getAllUserCommunications_args()
4183 
    args.read(iprot)
4184 
    iprot.readMessageEnd()
4185 
    result = getAllUserCommunications_result()
4186 
    try:
4187 
      result.success = self._handler.getAllUserCommunications()
4188 
    except UserCommunicationException, ucx:
4189 
      result.ucx = ucx
4190 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4191 
    result.write(oprot)
4192 
    oprot.writeMessageEnd()
4193 
    oprot.trans.flush()
4194 
 
5407 amar.kumar 4195 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4196 
    args = removeUserCommunication_args()
4197 
    args.read(iprot)
4198 
    iprot.readMessageEnd()
4199 
    result = removeUserCommunication_result()
4200 
    try:
4201 
      self._handler.removeUserCommunication(args.id)
4202 
    except UserCommunicationException, ucx:
4203 
      result.ucx = ucx
4204 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4205 
    result.write(oprot)
4206 
    oprot.writeMessageEnd()
4207 
    oprot.trans.flush()
4208 
 
1845 vikas 4209 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4210 
    args = createMasterAffiliate_args()
4211 
    args.read(iprot)
4212 
    iprot.readMessageEnd()
4213 
    result = createMasterAffiliate_result()
4214 
    try:
1859 vikas 4215 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4216 
    except UserAffiliateException, utx:
1845 vikas 4217 
      result.utx = utx
4218 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
1899 vikas 4223 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4224 
    args = getAllMasterAffiliates_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = getAllMasterAffiliates_result()
4228 
    try:
4229 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4230 
    except UserAffiliateException, utx:
1899 vikas 4231 
      result.utx = utx
4232 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
4236 
 
1845 vikas 4237 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4238 
    args = getMasterAffiliateById_args()
4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
4241 
    result = getMasterAffiliateById_result()
4242 
    try:
4243 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4244 
    except UserAffiliateException, utx:
1845 vikas 4245 
      result.utx = utx
4246 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4247 
    result.write(oprot)
4248 
    oprot.writeMessageEnd()
4249 
    oprot.trans.flush()
4250 
 
4251 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4252 
    args = getMasterAffiliateByName_args()
4253 
    args.read(iprot)
4254 
    iprot.readMessageEnd()
4255 
    result = getMasterAffiliateByName_result()
4256 
    try:
4257 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4258 
    except UserAffiliateException, utx:
1845 vikas 4259 
      result.utx = utx
4260 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4261 
    result.write(oprot)
4262 
    oprot.writeMessageEnd()
4263 
    oprot.trans.flush()
4264 
 
4265 
  def process_createAffiliate(self, seqid, iprot, oprot):
4266 
    args = createAffiliate_args()
4267 
    args.read(iprot)
4268 
    iprot.readMessageEnd()
4269 
    result = createAffiliate_result()
4270 
    try:
1859 vikas 4271 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4272 
    except UserAffiliateException, utx:
1845 vikas 4273 
      result.utx = utx
4274 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4275 
    result.write(oprot)
4276 
    oprot.writeMessageEnd()
4277 
    oprot.trans.flush()
4278 
 
4279 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4280 
    args = getAffiliateById_args()
4281 
    args.read(iprot)
4282 
    iprot.readMessageEnd()
4283 
    result = getAffiliateById_result()
4284 
    try:
4285 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4286 
    except UserAffiliateException, utx:
1845 vikas 4287 
      result.utx = utx
4288 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4289 
    result.write(oprot)
4290 
    oprot.writeMessageEnd()
4291 
    oprot.trans.flush()
4292 
 
4293 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4294 
    args = getAffiliateByName_args()
4295 
    args.read(iprot)
4296 
    iprot.readMessageEnd()
4297 
    result = getAffiliateByName_result()
4298 
    try:
4299 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4300 
    except UserAffiliateException, utx:
1845 vikas 4301 
      result.utx = utx
4302 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4303 
    result.write(oprot)
4304 
    oprot.writeMessageEnd()
4305 
    oprot.trans.flush()
4306 
 
4307 
  def process_getTrackerById(self, seqid, iprot, oprot):
4308 
    args = getTrackerById_args()
4309 
    args.read(iprot)
4310 
    iprot.readMessageEnd()
4311 
    result = getTrackerById_result()
4312 
    try:
1996 vikas 4313 
      result.success = self._handler.getTrackerById(args.id)
4314 
    except UserAffiliateException, utx:
1845 vikas 4315 
      result.utx = utx
4316 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4317 
    result.write(oprot)
4318 
    oprot.writeMessageEnd()
4319 
    oprot.trans.flush()
4320 
 
1996 vikas 4321 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4322 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4323 
    args.read(iprot)
4324 
    iprot.readMessageEnd()
1996 vikas 4325 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4326 
    try:
1996 vikas 4327 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4328 
    except UserAffiliateException, utx:
1845 vikas 4329 
      result.utx = utx
1996 vikas 4330 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4331 
    result.write(oprot)
4332 
    oprot.writeMessageEnd()
4333 
    oprot.trans.flush()
4334 
 
4335 
  def process_addTrackLog(self, seqid, iprot, oprot):
4336 
    args = addTrackLog_args()
4337 
    args.read(iprot)
4338 
    iprot.readMessageEnd()
4339 
    result = addTrackLog_result()
4340 
    try:
1996 vikas 4341 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4342 
    except UserAffiliateException, utx:
1845 vikas 4343 
      result.utx = utx
4344 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4345 
    result.write(oprot)
4346 
    oprot.writeMessageEnd()
4347 
    oprot.trans.flush()
4348 
 
4349 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4350 
    args = getTrackLogById_args()
4351 
    args.read(iprot)
4352 
    iprot.readMessageEnd()
4353 
    result = getTrackLogById_result()
4354 
    try:
4355 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4356 
    except UserAffiliateException, utx:
1845 vikas 4357 
      result.utx = utx
4358 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4359 
    result.write(oprot)
4360 
    oprot.writeMessageEnd()
4361 
    oprot.trans.flush()
4362 
 
1996 vikas 4363 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4364 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4365 
    args.read(iprot)
4366 
    iprot.readMessageEnd()
1996 vikas 4367 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4368 
    try:
3293 vikas 4369 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4370 
    except UserAffiliateException, utx:
1845 vikas 4371 
      result.utx = utx
1996 vikas 4372 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4373 
    result.write(oprot)
4374 
    oprot.writeMessageEnd()
4375 
    oprot.trans.flush()
4376 
 
4377 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4378 
    args = getTrackLogsByUser_args()
4379 
    args.read(iprot)
4380 
    iprot.readMessageEnd()
4381 
    result = getTrackLogsByUser_result()
4382 
    try:
4383 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4384 
    except UserAffiliateException, utx:
1845 vikas 4385 
      result.utx = utx
4386 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4387 
    result.write(oprot)
4388 
    oprot.writeMessageEnd()
4389 
    oprot.trans.flush()
4390 
 
4391 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4392 
    args = getTrackLogs_args()
4393 
    args.read(iprot)
4394 
    iprot.readMessageEnd()
4395 
    result = getTrackLogs_result()
4396 
    try:
1996 vikas 4397 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4398 
    except UserAffiliateException, utx:
1845 vikas 4399 
      result.utx = utx
4400 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4401 
    result.write(oprot)
4402 
    oprot.writeMessageEnd()
4403 
    oprot.trans.flush()
4404 
 
559 chandransh 4405 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4406 
    args = getCurrentCart_args()
94 ashish 4407 
    args.read(iprot)
4408 
    iprot.readMessageEnd()
559 chandransh 4409 
    result = getCurrentCart_result()
94 ashish 4410 
    try:
559 chandransh 4411 
      result.success = self._handler.getCurrentCart(args.userId)
4412 
    except ShoppingCartException, scx:
4413 
      result.scx = scx
4414 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4415 
    result.write(oprot)
4416 
    oprot.writeMessageEnd()
4417 
    oprot.trans.flush()
4418 
 
559 chandransh 4419 
  def process_getCart(self, seqid, iprot, oprot):
4420 
    args = getCart_args()
94 ashish 4421 
    args.read(iprot)
4422 
    iprot.readMessageEnd()
559 chandransh 4423 
    result = getCart_result()
94 ashish 4424 
    try:
559 chandransh 4425 
      result.success = self._handler.getCart(args.cartId)
4426 
    except ShoppingCartException, scx:
4427 
      result.scx = scx
4428 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
559 chandransh 4433 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4434 
    args = getCartsByTime_args()
94 ashish 4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
559 chandransh 4437 
    result = getCartsByTime_result()
94 ashish 4438 
    try:
559 chandransh 4439 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4440 
    except ShoppingCartException, scx:
4441 
      result.scx = scx
4442 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4443 
    result.write(oprot)
4444 
    oprot.writeMessageEnd()
4445 
    oprot.trans.flush()
4446 
 
559 chandransh 4447 
  def process_addItemToCart(self, seqid, iprot, oprot):
4448 
    args = addItemToCart_args()
130 ashish 4449 
    args.read(iprot)
4450 
    iprot.readMessageEnd()
559 chandransh 4451 
    result = addItemToCart_result()
130 ashish 4452 
    try:
3557 rajveer 4453 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4454 
    except ShoppingCartException, scx:
4455 
      result.scx = scx
4456 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4460 
 
559 chandransh 4461 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4462 
    args = deleteItemFromCart_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = deleteItemFromCart_result()
4466 
    try:
4467 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4468 
    except ShoppingCartException, scx:
4469 
      result.scx = scx
4470 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4471 
    result.write(oprot)
4472 
    oprot.writeMessageEnd()
4473 
    oprot.trans.flush()
130 ashish 4474 
 
559 chandransh 4475 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4476 
    args = addAddressToCart_args()
4477 
    args.read(iprot)
4478 
    iprot.readMessageEnd()
4479 
    result = addAddressToCart_result()
575 chandransh 4480 
    try:
4481 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4482 
    except ShoppingCartException, scx:
4483 
      result.scx = scx
559 chandransh 4484 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4485 
    result.write(oprot)
4486 
    oprot.writeMessageEnd()
4487 
    oprot.trans.flush()
4488 
 
5553 rajveer 4489 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4490 
    args = addStoreToCart_args()
4491 
    args.read(iprot)
4492 
    iprot.readMessageEnd()
4493 
    result = addStoreToCart_result()
4494 
    try:
4495 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4496 
    except ShoppingCartException, scx:
4497 
      result.scx = scx
4498 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4499 
    result.write(oprot)
4500 
    oprot.writeMessageEnd()
4501 
    oprot.trans.flush()
4502 
 
1976 varun.gupt 4503 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4504 
    args = applyCouponToCart_args()
4505 
    args.read(iprot)
4506 
    iprot.readMessageEnd()
4507 
    result = applyCouponToCart_result()
4508 
    try:
6922 anupam.sin 4509 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4510 
    except ShoppingCartException, scx:
4511 
      result.scx = scx
4512 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4513 
    result.write(oprot)
4514 
    oprot.writeMessageEnd()
4515 
    oprot.trans.flush()
4516 
 
4517 
  def process_removeCoupon(self, seqid, iprot, oprot):
4518 
    args = removeCoupon_args()
4519 
    args.read(iprot)
4520 
    iprot.readMessageEnd()
4521 
    result = removeCoupon_result()
4522 
    try:
4523 
      self._handler.removeCoupon(args.cartId)
4524 
    except ShoppingCartException, scx:
4525 
      result.scx = scx
4526 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
3554 varun.gupt 4531 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4532 
    args = deleteDiscountsFromCart_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = deleteDiscountsFromCart_result()
4536 
    try:
4537 
      self._handler.deleteDiscountsFromCart(args.cartId)
4538 
    except ShoppingCartException, scx:
4539 
      result.scx = scx
4540 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4541 
    result.write(oprot)
4542 
    oprot.writeMessageEnd()
4543 
    oprot.trans.flush()
4544 
 
4545 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4546 
    args = saveDiscounts_args()
4547 
    args.read(iprot)
4548 
    iprot.readMessageEnd()
4549 
    result = saveDiscounts_result()
4550 
    try:
4551 
      self._handler.saveDiscounts(args.discounts)
4552 
    except ShoppingCartException, scx:
4553 
      result.scx = scx
4554 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4555 
    result.write(oprot)
4556 
    oprot.writeMessageEnd()
4557 
    oprot.trans.flush()
4558 
 
690 chandransh 4559 
  def process_createOrders(self, seqid, iprot, oprot):
4560 
    args = createOrders_args()
559 chandransh 4561 
    args.read(iprot)
4562 
    iprot.readMessageEnd()
690 chandransh 4563 
    result = createOrders_result()
559 chandransh 4564 
    try:
11526 amit.gupta 4565 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4566 
    except ShoppingCartException, scx:
4567 
      result.scx = scx
690 chandransh 4568 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4569 
    result.write(oprot)
4570 
    oprot.writeMessageEnd()
4571 
    oprot.trans.flush()
4572 
 
4573 
  def process_validateCart(self, seqid, iprot, oprot):
4574 
    args = validateCart_args()
4575 
    args.read(iprot)
4576 
    iprot.readMessageEnd()
4577 
    result = validateCart_result()
575 chandransh 4578 
    try:
3557 rajveer 4579 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4580 
    except ShoppingCartException, scex:
4581 
      result.scex = scex
559 chandransh 4582 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4583 
    result.write(oprot)
4584 
    oprot.writeMessageEnd()
4585 
    oprot.trans.flush()
4586 
 
11980 amit.gupta 4587 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4588 
    args = validateCartWithDealerCoupon_args()
4589 
    args.read(iprot)
4590 
    iprot.readMessageEnd()
4591 
    result = validateCartWithDealerCoupon_result()
4592 
    try:
4593 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4594 
    except ShoppingCartException, scex:
4595 
      result.scex = scex
4596 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4597 
    result.write(oprot)
4598 
    oprot.writeMessageEnd()
4599 
    oprot.trans.flush()
4600 
 
690 chandransh 4601 
  def process_mergeCart(self, seqid, iprot, oprot):
4602 
    args = mergeCart_args()
575 chandransh 4603 
    args.read(iprot)
4604 
    iprot.readMessageEnd()
690 chandransh 4605 
    result = mergeCart_result()
4606 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4607 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4608 
    result.write(oprot)
4609 
    oprot.writeMessageEnd()
4610 
    oprot.trans.flush()
4611 
 
4612 
  def process_checkOut(self, seqid, iprot, oprot):
4613 
    args = checkOut_args()
4614 
    args.read(iprot)
4615 
    iprot.readMessageEnd()
4616 
    result = checkOut_result()
575 chandransh 4617 
    try:
690 chandransh 4618 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4619 
    except ShoppingCartException, scex:
4620 
      result.scex = scex
690 chandransh 4621 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4622 
    result.write(oprot)
4623 
    oprot.writeMessageEnd()
4624 
    oprot.trans.flush()
4625 
 
690 chandransh 4626 
  def process_resetCart(self, seqid, iprot, oprot):
4627 
    args = resetCart_args()
559 chandransh 4628 
    args.read(iprot)
4629 
    iprot.readMessageEnd()
690 chandransh 4630 
    result = resetCart_result()
4631 
    try:
4632 
      result.success = self._handler.resetCart(args.cartId, args.items)
4633 
    except ShoppingCartException, scex:
4634 
      result.scex = scex
4635 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4636 
    result.write(oprot)
4637 
    oprot.writeMessageEnd()
4638 
    oprot.trans.flush()
4639 
 
2981 rajveer 4640 
  def process_getUserCount(self, seqid, iprot, oprot):
4641 
    args = getUserCount_args()
559 chandransh 4642 
    args.read(iprot)
4643 
    iprot.readMessageEnd()
2981 rajveer 4644 
    result = getUserCount_result()
4645 
    result.success = self._handler.getUserCount(args.userType)
4646 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4647 
    result.write(oprot)
4648 
    oprot.writeMessageEnd()
4649 
    oprot.trans.flush()
4650 
 
2981 rajveer 4651 
  def process_getAllUsers(self, seqid, iprot, oprot):
4652 
    args = getAllUsers_args()
559 chandransh 4653 
    args.read(iprot)
4654 
    iprot.readMessageEnd()
2981 rajveer 4655 
    result = getAllUsers_result()
4656 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4657 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4658 
    result.write(oprot)
4659 
    oprot.writeMessageEnd()
4660 
    oprot.trans.flush()
4661 
 
2981 rajveer 4662 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4663 
    args = getMyResearchItems_args()
559 chandransh 4664 
    args.read(iprot)
4665 
    iprot.readMessageEnd()
2981 rajveer 4666 
    result = getMyResearchItems_result()
559 chandransh 4667 
    try:
2981 rajveer 4668 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4669 
    except WidgetException, scx:
4670 
      result.scx = scx
2981 rajveer 4671 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
2981 rajveer 4676 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4677 
    args = updateMyResearch_args()
772 rajveer 4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
2981 rajveer 4680 
    result = updateMyResearch_result()
4681 
    try:
4682 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4683 
    except WidgetException, scx:
4684 
      result.scx = scx
4685 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4686 
    result.write(oprot)
4687 
    oprot.writeMessageEnd()
4688 
    oprot.trans.flush()
559 chandransh 4689 
 
2981 rajveer 4690 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4691 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4692 
    args.read(iprot)
4693 
    iprot.readMessageEnd()
2981 rajveer 4694 
    result = deleteItemFromMyResearch_result()
4695 
    try:
4696 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4697 
    except WidgetException, scx:
4698 
      result.scx = scx
4699 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4700 
    result.write(oprot)
4701 
    oprot.writeMessageEnd()
4702 
    oprot.trans.flush()
772 rajveer 4703 
 
2981 rajveer 4704 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4705 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4706 
    args.read(iprot)
4707 
    iprot.readMessageEnd()
2981 rajveer 4708 
    result = getBrowseHistoryItems_result()
4709 
    try:
4710 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4711 
    except WidgetException, scx:
4712 
      result.scx = scx
4713 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4714 
    result.write(oprot)
4715 
    oprot.writeMessageEnd()
4716 
    oprot.trans.flush()
1596 ankur.sing 4717 
 
2981 rajveer 4718 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4719 
    args = updateBrowseHistory_args()
2642 varun.gupt 4720 
    args.read(iprot)
4721 
    iprot.readMessageEnd()
2981 rajveer 4722 
    result = updateBrowseHistory_result()
4723 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4724 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4725 
    result.write(oprot)
4726 
    oprot.writeMessageEnd()
4727 
    oprot.trans.flush()
1673 ankur.sing 4728 
 
3385 varun.gupt 4729 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4730 
    args = getCartsWithCouponCount_args()
4731 
    args.read(iprot)
4732 
    iprot.readMessageEnd()
4733 
    result = getCartsWithCouponCount_result()
4734 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4735 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4736 
    result.write(oprot)
4737 
    oprot.writeMessageEnd()
4738 
    oprot.trans.flush()
2642 varun.gupt 4739 
 
3499 mandeep.dh 4740 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4741 
    args = increaseTrustLevel_args()
4742 
    args.read(iprot)
4743 
    iprot.readMessageEnd()
4744 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4745 
    return
3385 varun.gupt 4746 
 
5407 amar.kumar 4747 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4748 
    args = getTrustLevel_args()
4749 
    args.read(iprot)
4750 
    iprot.readMessageEnd()
4751 
    result = getTrustLevel_result()
4752 
    result.success = self._handler.getTrustLevel(args.userId)
4753 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4754 
    result.write(oprot)
4755 
    oprot.writeMessageEnd()
4756 
    oprot.trans.flush()
4757 
 
4668 varun.gupt 4758 
  def process_showCODOption(self, seqid, iprot, oprot):
4759 
    args = showCODOption_args()
4760 
    args.read(iprot)
4761 
    iprot.readMessageEnd()
4762 
    result = showCODOption_result()
4763 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4764 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4765 
    result.write(oprot)
4766 
    oprot.writeMessageEnd()
4767 
    oprot.trans.flush()
3499 mandeep.dh 4768 
 
5623 anupam.sin 4769 
  def process_getUserEmails(self, seqid, iprot, oprot):
4770 
    args = getUserEmails_args()
4771 
    args.read(iprot)
4772 
    iprot.readMessageEnd()
4773 
    result = getUserEmails_result()
4774 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4775 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4776 
    result.write(oprot)
4777 
    oprot.writeMessageEnd()
4778 
    oprot.trans.flush()
4668 varun.gupt 4779 
 
6903 anupam.sin 4780 
  def process_insureItem(self, seqid, iprot, oprot):
4781 
    args = insureItem_args()
4782 
    args.read(iprot)
4783 
    iprot.readMessageEnd()
4784 
    result = insureItem_result()
9299 kshitij.so 4785 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4786 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4787 
    result.write(oprot)
4788 
    oprot.writeMessageEnd()
4789 
    oprot.trans.flush()
4790 
 
4791 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4792 
    args = cancelInsurance_args()
4793 
    args.read(iprot)
4794 
    iprot.readMessageEnd()
4795 
    result = cancelInsurance_result()
4796 
    result.success = self._handler.cancelInsurance(args.cartId)
4797 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4798 
    result.write(oprot)
4799 
    oprot.writeMessageEnd()
4800 
    oprot.trans.flush()
4801 
 
4802 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4803 
    args = storeInsuranceSpecificDetails_args()
4804 
    args.read(iprot)
4805 
    iprot.readMessageEnd()
4806 
    result = storeInsuranceSpecificDetails_result()
4807 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4808 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4809 
    result.write(oprot)
4810 
    oprot.writeMessageEnd()
4811 
    oprot.trans.flush()
4812 
 
4813 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4814 
    args = isInsuranceDetailPresent_args()
4815 
    args.read(iprot)
4816 
    iprot.readMessageEnd()
4817 
    result = isInsuranceDetailPresent_result()
4818 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4819 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4820 
    result.write(oprot)
4821 
    oprot.writeMessageEnd()
4822 
    oprot.trans.flush()
4823 
 
9791 rajveer 4824 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4825 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4826 
    args.read(iprot)
4827 
    iprot.readMessageEnd()
9791 rajveer 4828 
    result = getProductsAddedToCart_result()
4829 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4830 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4831 
    result.write(oprot)
4832 
    oprot.writeMessageEnd()
4833 
    oprot.trans.flush()
5623 anupam.sin 4834 
 
11592 amit.gupta 4835 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4836 
    args = validateCartPlus_args()
4837 
    args.read(iprot)
4838 
    iprot.readMessageEnd()
4839 
    result = validateCartPlus_result()
4840 
    try:
11980 amit.gupta 4841 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4842 
    except ShoppingCartException, scex:
4843 
      result.scex = scex
4844 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4845 
    result.write(oprot)
4846 
    oprot.writeMessageEnd()
4847 
    oprot.trans.flush()
6821 amar.kumar 4848 
 
11679 vikram.rag 4849 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4850 
    args = isPrivateDealUser_args()
4851 
    args.read(iprot)
4852 
    iprot.readMessageEnd()
4853 
    result = isPrivateDealUser_result()
4854 
    result.success = self._handler.isPrivateDealUser(args.userId)
4855 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4856 
    result.write(oprot)
4857 
    oprot.writeMessageEnd()
4858 
    oprot.trans.flush()
11592 amit.gupta 4859 
 
11890 kshitij.so 4860 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4861 
    args = addPrivateDealUser_args()
4862 
    args.read(iprot)
4863 
    iprot.readMessageEnd()
4864 
    result = addPrivateDealUser_result()
4865 
    result.success = self._handler.addPrivateDealUser(args.userId)
4866 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4867 
    result.write(oprot)
4868 
    oprot.writeMessageEnd()
4869 
    oprot.trans.flush()
11679 vikram.rag 4870 
 
11890 kshitij.so 4871 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4872 
    args = changePrivateDealUserStatus_args()
4873 
    args.read(iprot)
4874 
    iprot.readMessageEnd()
4875 
    result = changePrivateDealUserStatus_result()
4876 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4877 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4878 
    result.write(oprot)
4879 
    oprot.writeMessageEnd()
4880 
    oprot.trans.flush()
4881 
 
4882 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4883 
    args = getPrivateDealUser_args()
4884 
    args.read(iprot)
4885 
    iprot.readMessageEnd()
4886 
    result = getPrivateDealUser_result()
4887 
    result.success = self._handler.getPrivateDealUser(args.userId)
4888 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4889 
    result.write(oprot)
4890 
    oprot.writeMessageEnd()
4891 
    oprot.trans.flush()
4892 
 
12696 amit.gupta 4893 
  def process_registerCounter(self, seqid, iprot, oprot):
4894 
    args = registerCounter_args()
4895 
    args.read(iprot)
4896 
    iprot.readMessageEnd()
4897 
    result = registerCounter_result()
4898 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4899 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4900 
    result.write(oprot)
4901 
    oprot.writeMessageEnd()
4902 
    oprot.trans.flush()
11890 kshitij.so 4903 
 
12722 amit.gupta 4904 
  def process_searchCounter(self, seqid, iprot, oprot):
4905 
    args = searchCounter_args()
4906 
    args.read(iprot)
4907 
    iprot.readMessageEnd()
4908 
    result = searchCounter_result()
4909 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4910 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4911 
    result.write(oprot)
4912 
    oprot.writeMessageEnd()
4913 
    oprot.trans.flush()
12696 amit.gupta 4914 
 
12722 amit.gupta 4915 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4916 
    args = getAllUsersByCounter_args()
4917 
    args.read(iprot)
4918 
    iprot.readMessageEnd()
4919 
    result = getAllUsersByCounter_result()
4920 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4921 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4922 
    result.write(oprot)
4923 
    oprot.writeMessageEnd()
4924 
    oprot.trans.flush()
4925 
 
15251 manish.sha 4926 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
4927 
    args = getActiveAccessTokenForUser_args()
4928 
    args.read(iprot)
4929 
    iprot.readMessageEnd()
4930 
    result = getActiveAccessTokenForUser_result()
4931 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
4932 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
4933 
    result.write(oprot)
4934 
    oprot.writeMessageEnd()
4935 
    oprot.trans.flush()
12722 amit.gupta 4936 
 
15251 manish.sha 4937 
  def process_validateAccessToken(self, seqid, iprot, oprot):
4938 
    args = validateAccessToken_args()
4939 
    args.read(iprot)
4940 
    iprot.readMessageEnd()
4941 
    result = validateAccessToken_result()
4942 
    result.success = self._handler.validateAccessToken(args.accessToken)
4943 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
4944 
    result.write(oprot)
4945 
    oprot.writeMessageEnd()
4946 
    oprot.trans.flush()
4947 
 
17782 amit.gupta 4948 
  def process_addItemsToCart(self, seqid, iprot, oprot):
4949 
    args = addItemsToCart_args()
4950 
    args.read(iprot)
4951 
    iprot.readMessageEnd()
4952 
    result = addItemsToCart_result()
4953 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
4954 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
4955 
    result.write(oprot)
4956 
    oprot.writeMessageEnd()
4957 
    oprot.trans.flush()
15251 manish.sha 4958 
 
17782 amit.gupta 4959 
  def process_validateCartNew(self, seqid, iprot, oprot):
4960 
    args = validateCartNew_args()
4961 
    args.read(iprot)
4962 
    iprot.readMessageEnd()
4963 
    result = validateCartNew_result()
4964 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
4965 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
4966 
    result.write(oprot)
4967 
    oprot.writeMessageEnd()
4968 
    oprot.trans.flush()
4969 
 
18644 manish.sha 4970 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
4971 
    args = isAddressEditableForCounter_args()
18530 manish.sha 4972 
    args.read(iprot)
4973 
    iprot.readMessageEnd()
18644 manish.sha 4974 
    result = isAddressEditableForCounter_result()
4975 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
4976 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 4977 
    result.write(oprot)
4978 
    oprot.writeMessageEnd()
4979 
    oprot.trans.flush()
17782 amit.gupta 4980 
 
18530 manish.sha 4981 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
4982 
    args = getBillingAddressForUser_args()
4983 
    args.read(iprot)
4984 
    iprot.readMessageEnd()
4985 
    result = getBillingAddressForUser_result()
4986 
    result.success = self._handler.getBillingAddressForUser(args.userId)
4987 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
4988 
    result.write(oprot)
4989 
    oprot.writeMessageEnd()
4990 
    oprot.trans.flush()
4991 
 
18590 manish.sha 4992 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
4993 
    args = isCreditorAssigned_args()
4994 
    args.read(iprot)
4995 
    iprot.readMessageEnd()
4996 
    result = isCreditorAssigned_result()
4997 
    result.success = self._handler.isCreditorAssigned(args.userId)
4998 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
4999 
    result.write(oprot)
5000 
    oprot.writeMessageEnd()
5001 
    oprot.trans.flush()
18530 manish.sha 5002 
 
18735 manish.sha 5003 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5004 
    args = isTaxInvoiceEnabledUser_args()
5005 
    args.read(iprot)
5006 
    iprot.readMessageEnd()
5007 
    result = isTaxInvoiceEnabledUser_result()
5008 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5009 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5010 
    result.write(oprot)
5011 
    oprot.writeMessageEnd()
5012 
    oprot.trans.flush()
18590 manish.sha 5013 
 
18735 manish.sha 5014 
 
94 ashish 5015 
# HELPER FUNCTIONS AND STRUCTURES
5016 
 
559 chandransh 5017 
class createAnonymousUser_args:
94 ashish 5018 
  """
5019 
  Attributes:
559 chandransh 5020 
   - jsessionId
94 ashish 5021 
  """
5022 
 
5023 
  thrift_spec = (
5024 
    None, # 0
559 chandransh 5025 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5026 
  )
5027 
 
559 chandransh 5028 
  def __init__(self, jsessionId=None,):
5029 
    self.jsessionId = jsessionId
94 ashish 5030 
 
5031 
  def read(self, iprot):
5032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5034 
      return
5035 
    iprot.readStructBegin()
5036 
    while True:
5037 
      (fname, ftype, fid) = iprot.readFieldBegin()
5038 
      if ftype == TType.STOP:
5039 
        break
5040 
      if fid == 1:
559 chandransh 5041 
        if ftype == TType.STRING:
5042 
          self.jsessionId = iprot.readString();
94 ashish 5043 
        else:
5044 
          iprot.skip(ftype)
5045 
      else:
5046 
        iprot.skip(ftype)
5047 
      iprot.readFieldEnd()
5048 
    iprot.readStructEnd()
5049 
 
5050 
  def write(self, oprot):
5051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5053 
      return
559 chandransh 5054 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5055 
    if self.jsessionId is not None:
559 chandransh 5056 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5057 
      oprot.writeString(self.jsessionId)
94 ashish 5058 
      oprot.writeFieldEnd()
5059 
    oprot.writeFieldStop()
5060 
    oprot.writeStructEnd()
5061 
 
3431 rajveer 5062 
  def validate(self):
5063 
    return
5064 
 
5065 
 
94 ashish 5066 
  def __repr__(self):
5067 
    L = ['%s=%r' % (key, value)
5068 
      for key, value in self.__dict__.iteritems()]
5069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5070 
 
5071 
  def __eq__(self, other):
5072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5073 
 
5074 
  def __ne__(self, other):
5075 
    return not (self == other)
5076 
 
559 chandransh 5077 
class createAnonymousUser_result:
94 ashish 5078 
  """
5079 
  Attributes:
5080 
   - success
559 chandransh 5081 
   - ucex
94 ashish 5082 
  """
5083 
 
5084 
  thrift_spec = (
559 chandransh 5085 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5086 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5087 
  )
5088 
 
559 chandransh 5089 
  def __init__(self, success=None, ucex=None,):
94 ashish 5090 
    self.success = success
559 chandransh 5091 
    self.ucex = ucex
94 ashish 5092 
 
5093 
  def read(self, iprot):
5094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5096 
      return
5097 
    iprot.readStructBegin()
5098 
    while True:
5099 
      (fname, ftype, fid) = iprot.readFieldBegin()
5100 
      if ftype == TType.STOP:
5101 
        break
5102 
      if fid == 0:
5103 
        if ftype == TType.STRUCT:
559 chandransh 5104 
          self.success = User()
94 ashish 5105 
          self.success.read(iprot)
5106 
        else:
5107 
          iprot.skip(ftype)
5108 
      elif fid == 1:
5109 
        if ftype == TType.STRUCT:
559 chandransh 5110 
          self.ucex = UserContextException()
5111 
          self.ucex.read(iprot)
94 ashish 5112 
        else:
5113 
          iprot.skip(ftype)
5114 
      else:
5115 
        iprot.skip(ftype)
5116 
      iprot.readFieldEnd()
5117 
    iprot.readStructEnd()
5118 
 
5119 
  def write(self, oprot):
5120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5122 
      return
559 chandransh 5123 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5124 
    if self.success is not None:
94 ashish 5125 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5126 
      self.success.write(oprot)
5127 
      oprot.writeFieldEnd()
3431 rajveer 5128 
    if self.ucex is not None:
559 chandransh 5129 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5130 
      self.ucex.write(oprot)
94 ashish 5131 
      oprot.writeFieldEnd()
5132 
    oprot.writeFieldStop()
5133 
    oprot.writeStructEnd()
5134 
 
3431 rajveer 5135 
  def validate(self):
5136 
    return
5137 
 
5138 
 
94 ashish 5139 
  def __repr__(self):
5140 
    L = ['%s=%r' % (key, value)
5141 
      for key, value in self.__dict__.iteritems()]
5142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5143 
 
5144 
  def __eq__(self, other):
5145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5146 
 
5147 
  def __ne__(self, other):
5148 
    return not (self == other)
5149 
 
559 chandransh 5150 
class getUserById_args:
94 ashish 5151 
  """
5152 
  Attributes:
5153 
   - userId
5154 
  """
5155 
 
5156 
  thrift_spec = (
5157 
    None, # 0
5158 
    (1, TType.I64, 'userId', None, None, ), # 1
5159 
  )
5160 
 
559 chandransh 5161 
  def __init__(self, userId=None,):
94 ashish 5162 
    self.userId = userId
5163 
 
5164 
  def read(self, iprot):
5165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5167 
      return
5168 
    iprot.readStructBegin()
5169 
    while True:
5170 
      (fname, ftype, fid) = iprot.readFieldBegin()
5171 
      if ftype == TType.STOP:
5172 
        break
5173 
      if fid == 1:
5174 
        if ftype == TType.I64:
5175 
          self.userId = iprot.readI64();
5176 
        else:
5177 
          iprot.skip(ftype)
5178 
      else:
5179 
        iprot.skip(ftype)
5180 
      iprot.readFieldEnd()
5181 
    iprot.readStructEnd()
5182 
 
5183 
  def write(self, oprot):
5184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5186 
      return
559 chandransh 5187 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5188 
    if self.userId is not None:
94 ashish 5189 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5190 
      oprot.writeI64(self.userId)
5191 
      oprot.writeFieldEnd()
5192 
    oprot.writeFieldStop()
5193 
    oprot.writeStructEnd()
5194 
 
3431 rajveer 5195 
  def validate(self):
5196 
    return
5197 
 
5198 
 
94 ashish 5199 
  def __repr__(self):
5200 
    L = ['%s=%r' % (key, value)
5201 
      for key, value in self.__dict__.iteritems()]
5202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5203 
 
5204 
  def __eq__(self, other):
5205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5206 
 
5207 
  def __ne__(self, other):
5208 
    return not (self == other)
5209 
 
559 chandransh 5210 
class getUserById_result:
94 ashish 5211 
  """
5212 
  Attributes:
5213 
   - success
559 chandransh 5214 
   - ucex
94 ashish 5215 
  """
5216 
 
5217 
  thrift_spec = (
559 chandransh 5218 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5219 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5220 
  )
5221 
 
559 chandransh 5222 
  def __init__(self, success=None, ucex=None,):
94 ashish 5223 
    self.success = success
559 chandransh 5224 
    self.ucex = ucex
94 ashish 5225 
 
5226 
  def read(self, iprot):
5227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5229 
      return
5230 
    iprot.readStructBegin()
5231 
    while True:
5232 
      (fname, ftype, fid) = iprot.readFieldBegin()
5233 
      if ftype == TType.STOP:
5234 
        break
5235 
      if fid == 0:
5236 
        if ftype == TType.STRUCT:
559 chandransh 5237 
          self.success = User()
94 ashish 5238 
          self.success.read(iprot)
5239 
        else:
5240 
          iprot.skip(ftype)
5241 
      elif fid == 1:
5242 
        if ftype == TType.STRUCT:
559 chandransh 5243 
          self.ucex = UserContextException()
5244 
          self.ucex.read(iprot)
94 ashish 5245 
        else:
5246 
          iprot.skip(ftype)
5247 
      else:
5248 
        iprot.skip(ftype)
5249 
      iprot.readFieldEnd()
5250 
    iprot.readStructEnd()
5251 
 
5252 
  def write(self, oprot):
5253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5255 
      return
559 chandransh 5256 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5257 
    if self.success is not None:
94 ashish 5258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5259 
      self.success.write(oprot)
5260 
      oprot.writeFieldEnd()
3431 rajveer 5261 
    if self.ucex is not None:
559 chandransh 5262 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5263 
      self.ucex.write(oprot)
94 ashish 5264 
      oprot.writeFieldEnd()
5265 
    oprot.writeFieldStop()
5266 
    oprot.writeStructEnd()
5267 
 
3431 rajveer 5268 
  def validate(self):
5269 
    return
5270 
 
5271 
 
94 ashish 5272 
  def __repr__(self):
5273 
    L = ['%s=%r' % (key, value)
5274 
      for key, value in self.__dict__.iteritems()]
5275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5276 
 
5277 
  def __eq__(self, other):
5278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5279 
 
5280 
  def __ne__(self, other):
5281 
    return not (self == other)
5282 
 
5326 rajveer 5283 
class getUserByCartId_args:
1491 vikas 5284 
  """
5285 
  Attributes:
5326 rajveer 5286 
   - cartId
1491 vikas 5287 
  """
5288 
 
5289 
  thrift_spec = (
5290 
    None, # 0
5326 rajveer 5291 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5292 
  )
5293 
 
5326 rajveer 5294 
  def __init__(self, cartId=None,):
5295 
    self.cartId = cartId
1491 vikas 5296 
 
5297 
  def read(self, iprot):
5298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5300 
      return
5301 
    iprot.readStructBegin()
5302 
    while True:
5303 
      (fname, ftype, fid) = iprot.readFieldBegin()
5304 
      if ftype == TType.STOP:
5305 
        break
5306 
      if fid == 1:
5326 rajveer 5307 
        if ftype == TType.I64:
5308 
          self.cartId = iprot.readI64();
1491 vikas 5309 
        else:
5310 
          iprot.skip(ftype)
5311 
      else:
5312 
        iprot.skip(ftype)
5313 
      iprot.readFieldEnd()
5314 
    iprot.readStructEnd()
5315 
 
5316 
  def write(self, oprot):
5317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5319 
      return
5326 rajveer 5320 
    oprot.writeStructBegin('getUserByCartId_args')
5321 
    if self.cartId is not None:
5322 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5323 
      oprot.writeI64(self.cartId)
1491 vikas 5324 
      oprot.writeFieldEnd()
5325 
    oprot.writeFieldStop()
5326 
    oprot.writeStructEnd()
5327 
 
3431 rajveer 5328 
  def validate(self):
5329 
    return
5330 
 
5331 
 
1491 vikas 5332 
  def __repr__(self):
5333 
    L = ['%s=%r' % (key, value)
5334 
      for key, value in self.__dict__.iteritems()]
5335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5336 
 
5337 
  def __eq__(self, other):
5338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5339 
 
5340 
  def __ne__(self, other):
5341 
    return not (self == other)
5342 
 
5326 rajveer 5343 
class getUserByCartId_result:
1491 vikas 5344 
  """
5345 
  Attributes:
5346 
   - success
5347 
   - ucex
5348 
  """
5349 
 
5350 
  thrift_spec = (
5351 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5352 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5353 
  )
5354 
 
5355 
  def __init__(self, success=None, ucex=None,):
5356 
    self.success = success
5357 
    self.ucex = ucex
5358 
 
5359 
  def read(self, iprot):
5360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5362 
      return
5363 
    iprot.readStructBegin()
5364 
    while True:
5365 
      (fname, ftype, fid) = iprot.readFieldBegin()
5366 
      if ftype == TType.STOP:
5367 
        break
5368 
      if fid == 0:
5369 
        if ftype == TType.STRUCT:
5370 
          self.success = User()
5371 
          self.success.read(iprot)
5372 
        else:
5373 
          iprot.skip(ftype)
5374 
      elif fid == 1:
5375 
        if ftype == TType.STRUCT:
5376 
          self.ucex = UserContextException()
5377 
          self.ucex.read(iprot)
5378 
        else:
5379 
          iprot.skip(ftype)
5380 
      else:
5381 
        iprot.skip(ftype)
5382 
      iprot.readFieldEnd()
5383 
    iprot.readStructEnd()
5384 
 
5385 
  def write(self, oprot):
5386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5388 
      return
5326 rajveer 5389 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5390 
    if self.success is not None:
1491 vikas 5391 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5392 
      self.success.write(oprot)
5393 
      oprot.writeFieldEnd()
3431 rajveer 5394 
    if self.ucex is not None:
1491 vikas 5395 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5396 
      self.ucex.write(oprot)
5397 
      oprot.writeFieldEnd()
5398 
    oprot.writeFieldStop()
5399 
    oprot.writeStructEnd()
5400 
 
3431 rajveer 5401 
  def validate(self):
5402 
    return
5403 
 
5404 
 
1491 vikas 5405 
  def __repr__(self):
5406 
    L = ['%s=%r' % (key, value)
5407 
      for key, value in self.__dict__.iteritems()]
5408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5409 
 
5410 
  def __eq__(self, other):
5411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5412 
 
5413 
  def __ne__(self, other):
5414 
    return not (self == other)
5415 
 
5326 rajveer 5416 
class getUserByEmail_args:
3032 mandeep.dh 5417 
  """
5418 
  Attributes:
5326 rajveer 5419 
   - email
3032 mandeep.dh 5420 
  """
5421 
 
5422 
  thrift_spec = (
5423 
    None, # 0
5326 rajveer 5424 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5425 
  )
5426 
 
5326 rajveer 5427 
  def __init__(self, email=None,):
5428 
    self.email = email
3032 mandeep.dh 5429 
 
5430 
  def read(self, iprot):
5431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5433 
      return
5434 
    iprot.readStructBegin()
5435 
    while True:
5436 
      (fname, ftype, fid) = iprot.readFieldBegin()
5437 
      if ftype == TType.STOP:
5438 
        break
5439 
      if fid == 1:
5326 rajveer 5440 
        if ftype == TType.STRING:
5441 
          self.email = iprot.readString();
3032 mandeep.dh 5442 
        else:
5443 
          iprot.skip(ftype)
5444 
      else:
5445 
        iprot.skip(ftype)
5446 
      iprot.readFieldEnd()
5447 
    iprot.readStructEnd()
5448 
 
5449 
  def write(self, oprot):
5450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5452 
      return
5326 rajveer 5453 
    oprot.writeStructBegin('getUserByEmail_args')
5454 
    if self.email is not None:
5455 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5456 
      oprot.writeString(self.email)
3032 mandeep.dh 5457 
      oprot.writeFieldEnd()
5458 
    oprot.writeFieldStop()
5459 
    oprot.writeStructEnd()
5460 
 
3431 rajveer 5461 
  def validate(self):
5462 
    return
5463 
 
5464 
 
3032 mandeep.dh 5465 
  def __repr__(self):
5466 
    L = ['%s=%r' % (key, value)
5467 
      for key, value in self.__dict__.iteritems()]
5468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5469 
 
5470 
  def __eq__(self, other):
5471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5472 
 
5473 
  def __ne__(self, other):
5474 
    return not (self == other)
5475 
 
5326 rajveer 5476 
class getUserByEmail_result:
3032 mandeep.dh 5477 
  """
5478 
  Attributes:
5479 
   - success
5480 
   - ucex
5481 
  """
5482 
 
5483 
  thrift_spec = (
5484 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5485 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5486 
  )
5487 
 
5488 
  def __init__(self, success=None, ucex=None,):
5489 
    self.success = success
5490 
    self.ucex = ucex
5491 
 
5492 
  def read(self, iprot):
5493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5495 
      return
5496 
    iprot.readStructBegin()
5497 
    while True:
5498 
      (fname, ftype, fid) = iprot.readFieldBegin()
5499 
      if ftype == TType.STOP:
5500 
        break
5501 
      if fid == 0:
5502 
        if ftype == TType.STRUCT:
5503 
          self.success = User()
5504 
          self.success.read(iprot)
5505 
        else:
5506 
          iprot.skip(ftype)
5507 
      elif fid == 1:
5508 
        if ftype == TType.STRUCT:
5509 
          self.ucex = UserContextException()
5510 
          self.ucex.read(iprot)
5511 
        else:
5512 
          iprot.skip(ftype)
5513 
      else:
5514 
        iprot.skip(ftype)
5515 
      iprot.readFieldEnd()
5516 
    iprot.readStructEnd()
5517 
 
5518 
  def write(self, oprot):
5519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5521 
      return
5326 rajveer 5522 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5523 
    if self.success is not None:
3032 mandeep.dh 5524 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5525 
      self.success.write(oprot)
5526 
      oprot.writeFieldEnd()
3431 rajveer 5527 
    if self.ucex is not None:
3032 mandeep.dh 5528 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5529 
      self.ucex.write(oprot)
5530 
      oprot.writeFieldEnd()
5531 
    oprot.writeFieldStop()
5532 
    oprot.writeStructEnd()
5533 
 
3431 rajveer 5534 
  def validate(self):
5535 
    return
5536 
 
5537 
 
3032 mandeep.dh 5538 
  def __repr__(self):
5539 
    L = ['%s=%r' % (key, value)
5540 
      for key, value in self.__dict__.iteritems()]
5541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5542 
 
5543 
  def __eq__(self, other):
5544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5545 
 
5546 
  def __ne__(self, other):
5547 
    return not (self == other)
5548 
 
5326 rajveer 5549 
class getUserByMobileNumber_args:
94 ashish 5550 
  """
5551 
  Attributes:
5326 rajveer 5552 
   - mobileNumber
94 ashish 5553 
  """
5554 
 
5555 
  thrift_spec = (
5556 
    None, # 0
5326 rajveer 5557 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5558 
  )
5559 
 
5326 rajveer 5560 
  def __init__(self, mobileNumber=None,):
5561 
    self.mobileNumber = mobileNumber
94 ashish 5562 
 
5563 
  def read(self, iprot):
5564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5566 
      return
5567 
    iprot.readStructBegin()
5568 
    while True:
5569 
      (fname, ftype, fid) = iprot.readFieldBegin()
5570 
      if ftype == TType.STOP:
5571 
        break
5572 
      if fid == 1:
5326 rajveer 5573 
        if ftype == TType.I64:
5574 
          self.mobileNumber = iprot.readI64();
94 ashish 5575 
        else:
5576 
          iprot.skip(ftype)
5577 
      else:
5578 
        iprot.skip(ftype)
5579 
      iprot.readFieldEnd()
5580 
    iprot.readStructEnd()
5581 
 
5582 
  def write(self, oprot):
5583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5585 
      return
5326 rajveer 5586 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5587 
    if self.mobileNumber is not None:
5588 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5589 
      oprot.writeI64(self.mobileNumber)
94 ashish 5590 
      oprot.writeFieldEnd()
5591 
    oprot.writeFieldStop()
5592 
    oprot.writeStructEnd()
5593 
 
3431 rajveer 5594 
  def validate(self):
5595 
    return
5596 
 
5597 
 
94 ashish 5598 
  def __repr__(self):
5599 
    L = ['%s=%r' % (key, value)
5600 
      for key, value in self.__dict__.iteritems()]
5601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5602 
 
5603 
  def __eq__(self, other):
5604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5605 
 
5606 
  def __ne__(self, other):
5607 
    return not (self == other)
5608 
 
5326 rajveer 5609 
class getUserByMobileNumber_result:
94 ashish 5610 
  """
5611 
  Attributes:
5612 
   - success
559 chandransh 5613 
   - ucex
94 ashish 5614 
  """
5615 
 
5616 
  thrift_spec = (
559 chandransh 5617 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5618 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5619 
  )
5620 
 
559 chandransh 5621 
  def __init__(self, success=None, ucex=None,):
94 ashish 5622 
    self.success = success
559 chandransh 5623 
    self.ucex = ucex
94 ashish 5624 
 
5625 
  def read(self, iprot):
5626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5628 
      return
5629 
    iprot.readStructBegin()
5630 
    while True:
5631 
      (fname, ftype, fid) = iprot.readFieldBegin()
5632 
      if ftype == TType.STOP:
5633 
        break
5634 
      if fid == 0:
5635 
        if ftype == TType.STRUCT:
559 chandransh 5636 
          self.success = User()
94 ashish 5637 
          self.success.read(iprot)
5638 
        else:
5639 
          iprot.skip(ftype)
5640 
      elif fid == 1:
5641 
        if ftype == TType.STRUCT:
559 chandransh 5642 
          self.ucex = UserContextException()
5643 
          self.ucex.read(iprot)
94 ashish 5644 
        else:
5645 
          iprot.skip(ftype)
5646 
      else:
5647 
        iprot.skip(ftype)
5648 
      iprot.readFieldEnd()
5649 
    iprot.readStructEnd()
5650 
 
5651 
  def write(self, oprot):
5652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5654 
      return
5326 rajveer 5655 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5656 
    if self.success is not None:
94 ashish 5657 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5658 
      self.success.write(oprot)
5659 
      oprot.writeFieldEnd()
3431 rajveer 5660 
    if self.ucex is not None:
559 chandransh 5661 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5662 
      self.ucex.write(oprot)
94 ashish 5663 
      oprot.writeFieldEnd()
5664 
    oprot.writeFieldStop()
5665 
    oprot.writeStructEnd()
5666 
 
3431 rajveer 5667 
  def validate(self):
5668 
    return
5669 
 
5670 
 
94 ashish 5671 
  def __repr__(self):
5672 
    L = ['%s=%r' % (key, value)
5673 
      for key, value in self.__dict__.iteritems()]
5674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5675 
 
5676 
  def __eq__(self, other):
5677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5678 
 
5679 
  def __ne__(self, other):
5680 
    return not (self == other)
5681 
 
5326 rajveer 5682 
class createUser_args:
94 ashish 5683 
  """
5684 
  Attributes:
559 chandransh 5685 
   - user
94 ashish 5686 
  """
5687 
 
5688 
  thrift_spec = (
5689 
    None, # 0
559 chandransh 5690 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5691 
  )
5692 
 
559 chandransh 5693 
  def __init__(self, user=None,):
5694 
    self.user = user
94 ashish 5695 
 
5696 
  def read(self, iprot):
5697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5699 
      return
5700 
    iprot.readStructBegin()
5701 
    while True:
5702 
      (fname, ftype, fid) = iprot.readFieldBegin()
5703 
      if ftype == TType.STOP:
5704 
        break
5705 
      if fid == 1:
559 chandransh 5706 
        if ftype == TType.STRUCT:
5707 
          self.user = User()
5708 
          self.user.read(iprot)
94 ashish 5709 
        else:
5710 
          iprot.skip(ftype)
5711 
      else:
5712 
        iprot.skip(ftype)
5713 
      iprot.readFieldEnd()
5714 
    iprot.readStructEnd()
5715 
 
5716 
  def write(self, oprot):
5717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5719 
      return
5326 rajveer 5720 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5721 
    if self.user is not None:
559 chandransh 5722 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5723 
      self.user.write(oprot)
94 ashish 5724 
      oprot.writeFieldEnd()
5725 
    oprot.writeFieldStop()
5726 
    oprot.writeStructEnd()
5727 
 
3431 rajveer 5728 
  def validate(self):
5729 
    return
5730 
 
5731 
 
94 ashish 5732 
  def __repr__(self):
5733 
    L = ['%s=%r' % (key, value)
5734 
      for key, value in self.__dict__.iteritems()]
5735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5736 
 
5737 
  def __eq__(self, other):
5738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5739 
 
5740 
  def __ne__(self, other):
5741 
    return not (self == other)
5742 
 
5326 rajveer 5743 
class createUser_result:
94 ashish 5744 
  """
5745 
  Attributes:
5746 
   - success
559 chandransh 5747 
   - ucex
94 ashish 5748 
  """
5749 
 
5750 
  thrift_spec = (
559 chandransh 5751 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5752 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5753 
  )
5754 
 
559 chandransh 5755 
  def __init__(self, success=None, ucex=None,):
94 ashish 5756 
    self.success = success
559 chandransh 5757 
    self.ucex = ucex
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 == 0:
5769 
        if ftype == TType.STRUCT:
559 chandransh 5770 
          self.success = User()
94 ashish 5771 
          self.success.read(iprot)
5772 
        else:
5773 
          iprot.skip(ftype)
5774 
      elif fid == 1:
5775 
        if ftype == TType.STRUCT:
559 chandransh 5776 
          self.ucex = UserContextException()
5777 
          self.ucex.read(iprot)
94 ashish 5778 
        else:
5779 
          iprot.skip(ftype)
5780 
      else:
5781 
        iprot.skip(ftype)
5782 
      iprot.readFieldEnd()
5783 
    iprot.readStructEnd()
5784 
 
5785 
  def write(self, oprot):
5786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5788 
      return
5326 rajveer 5789 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5790 
    if self.success is not None:
94 ashish 5791 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5792 
      self.success.write(oprot)
5793 
      oprot.writeFieldEnd()
3431 rajveer 5794 
    if self.ucex is not None:
559 chandransh 5795 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5796 
      self.ucex.write(oprot)
94 ashish 5797 
      oprot.writeFieldEnd()
5798 
    oprot.writeFieldStop()
5799 
    oprot.writeStructEnd()
5800 
 
3431 rajveer 5801 
  def validate(self):
5802 
    return
5803 
 
5804 
 
94 ashish 5805 
  def __repr__(self):
5806 
    L = ['%s=%r' % (key, value)
5807 
      for key, value in self.__dict__.iteritems()]
5808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5809 
 
5810 
  def __eq__(self, other):
5811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5812 
 
5813 
  def __ne__(self, other):
5814 
    return not (self == other)
5815 
 
5326 rajveer 5816 
class updateUser_args:
94 ashish 5817 
  """
5818 
  Attributes:
5326 rajveer 5819 
   - user
94 ashish 5820 
  """
5821 
 
5822 
  thrift_spec = (
5823 
    None, # 0
5326 rajveer 5824 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5825 
  )
5826 
 
5326 rajveer 5827 
  def __init__(self, user=None,):
5828 
    self.user = user
94 ashish 5829 
 
5830 
  def read(self, iprot):
5831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5833 
      return
5834 
    iprot.readStructBegin()
5835 
    while True:
5836 
      (fname, ftype, fid) = iprot.readFieldBegin()
5837 
      if ftype == TType.STOP:
5838 
        break
5839 
      if fid == 1:
5326 rajveer 5840 
        if ftype == TType.STRUCT:
5841 
          self.user = User()
5842 
          self.user.read(iprot)
94 ashish 5843 
        else:
5844 
          iprot.skip(ftype)
5845 
      else:
5846 
        iprot.skip(ftype)
5847 
      iprot.readFieldEnd()
5848 
    iprot.readStructEnd()
5849 
 
5850 
  def write(self, oprot):
5851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5853 
      return
5326 rajveer 5854 
    oprot.writeStructBegin('updateUser_args')
5855 
    if self.user is not None:
5856 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5857 
      self.user.write(oprot)
94 ashish 5858 
      oprot.writeFieldEnd()
5859 
    oprot.writeFieldStop()
5860 
    oprot.writeStructEnd()
5861 
 
3431 rajveer 5862 
  def validate(self):
5863 
    return
5864 
 
5865 
 
94 ashish 5866 
  def __repr__(self):
5867 
    L = ['%s=%r' % (key, value)
5868 
      for key, value in self.__dict__.iteritems()]
5869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5870 
 
5871 
  def __eq__(self, other):
5872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5873 
 
5874 
  def __ne__(self, other):
5875 
    return not (self == other)
5876 
 
5326 rajveer 5877 
class updateUser_result:
94 ashish 5878 
  """
5879 
  Attributes:
5880 
   - success
559 chandransh 5881 
   - ucex
94 ashish 5882 
  """
5883 
 
5884 
  thrift_spec = (
5326 rajveer 5885 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5886 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5887 
  )
5888 
 
559 chandransh 5889 
  def __init__(self, success=None, ucex=None,):
94 ashish 5890 
    self.success = success
559 chandransh 5891 
    self.ucex = ucex
94 ashish 5892 
 
5893 
  def read(self, iprot):
5894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5896 
      return
5897 
    iprot.readStructBegin()
5898 
    while True:
5899 
      (fname, ftype, fid) = iprot.readFieldBegin()
5900 
      if ftype == TType.STOP:
5901 
        break
5902 
      if fid == 0:
5326 rajveer 5903 
        if ftype == TType.STRUCT:
5904 
          self.success = User()
5905 
          self.success.read(iprot)
94 ashish 5906 
        else:
5907 
          iprot.skip(ftype)
5908 
      elif fid == 1:
5909 
        if ftype == TType.STRUCT:
559 chandransh 5910 
          self.ucex = UserContextException()
5911 
          self.ucex.read(iprot)
94 ashish 5912 
        else:
5913 
          iprot.skip(ftype)
5914 
      else:
5915 
        iprot.skip(ftype)
5916 
      iprot.readFieldEnd()
5917 
    iprot.readStructEnd()
5918 
 
5919 
  def write(self, oprot):
5920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5922 
      return
5326 rajveer 5923 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5924 
    if self.success is not None:
5326 rajveer 5925 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5926 
      self.success.write(oprot)
94 ashish 5927 
      oprot.writeFieldEnd()
3431 rajveer 5928 
    if self.ucex is not None:
559 chandransh 5929 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5930 
      self.ucex.write(oprot)
94 ashish 5931 
      oprot.writeFieldEnd()
5932 
    oprot.writeFieldStop()
5933 
    oprot.writeStructEnd()
5934 
 
3431 rajveer 5935 
  def validate(self):
5936 
    return
5937 
 
5938 
 
94 ashish 5939 
  def __repr__(self):
5940 
    L = ['%s=%r' % (key, value)
5941 
      for key, value in self.__dict__.iteritems()]
5942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5943 
 
5944 
  def __eq__(self, other):
5945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5946 
 
5947 
  def __ne__(self, other):
5948 
    return not (self == other)
5949 
 
559 chandransh 5950 
class authenticateUser_args:
94 ashish 5951 
  """
5952 
  Attributes:
5953 
   - email
5954 
   - password
5955 
  """
5956 
 
5957 
  thrift_spec = (
5958 
    None, # 0
5959 
    (1, TType.STRING, 'email', None, None, ), # 1
5960 
    (2, TType.STRING, 'password', None, None, ), # 2
5961 
  )
5962 
 
5963 
  def __init__(self, email=None, password=None,):
5964 
    self.email = email
5965 
    self.password = password
5966 
 
5967 
  def read(self, iprot):
5968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5970 
      return
5971 
    iprot.readStructBegin()
5972 
    while True:
5973 
      (fname, ftype, fid) = iprot.readFieldBegin()
5974 
      if ftype == TType.STOP:
5975 
        break
5976 
      if fid == 1:
5977 
        if ftype == TType.STRING:
5978 
          self.email = iprot.readString();
5979 
        else:
5980 
          iprot.skip(ftype)
5981 
      elif fid == 2:
5982 
        if ftype == TType.STRING:
5983 
          self.password = iprot.readString();
5984 
        else:
5985 
          iprot.skip(ftype)
5986 
      else:
5987 
        iprot.skip(ftype)
5988 
      iprot.readFieldEnd()
5989 
    iprot.readStructEnd()
5990 
 
5991 
  def write(self, oprot):
5992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5994 
      return
559 chandransh 5995 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5996 
    if self.email is not None:
94 ashish 5997 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5998 
      oprot.writeString(self.email)
5999 
      oprot.writeFieldEnd()
3431 rajveer 6000 
    if self.password is not None:
94 ashish 6001 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6002 
      oprot.writeString(self.password)
6003 
      oprot.writeFieldEnd()
6004 
    oprot.writeFieldStop()
6005 
    oprot.writeStructEnd()
6006 
 
3431 rajveer 6007 
  def validate(self):
6008 
    return
6009 
 
6010 
 
94 ashish 6011 
  def __repr__(self):
6012 
    L = ['%s=%r' % (key, value)
6013 
      for key, value in self.__dict__.iteritems()]
6014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6015 
 
6016 
  def __eq__(self, other):
6017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6018 
 
6019 
  def __ne__(self, other):
6020 
    return not (self == other)
6021 
 
559 chandransh 6022 
class authenticateUser_result:
94 ashish 6023 
  """
6024 
  Attributes:
6025 
   - success
559 chandransh 6026 
   - auex
94 ashish 6027 
  """
6028 
 
6029 
  thrift_spec = (
559 chandransh 6030 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6031 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6032 
  )
6033 
 
559 chandransh 6034 
  def __init__(self, success=None, auex=None,):
94 ashish 6035 
    self.success = success
559 chandransh 6036 
    self.auex = auex
94 ashish 6037 
 
6038 
  def read(self, iprot):
6039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6041 
      return
6042 
    iprot.readStructBegin()
6043 
    while True:
6044 
      (fname, ftype, fid) = iprot.readFieldBegin()
6045 
      if ftype == TType.STOP:
6046 
        break
6047 
      if fid == 0:
6048 
        if ftype == TType.STRUCT:
559 chandransh 6049 
          self.success = User()
94 ashish 6050 
          self.success.read(iprot)
6051 
        else:
6052 
          iprot.skip(ftype)
6053 
      elif fid == 1:
6054 
        if ftype == TType.STRUCT:
559 chandransh 6055 
          self.auex = AuthenticationException()
6056 
          self.auex.read(iprot)
94 ashish 6057 
        else:
6058 
          iprot.skip(ftype)
6059 
      else:
6060 
        iprot.skip(ftype)
6061 
      iprot.readFieldEnd()
6062 
    iprot.readStructEnd()
6063 
 
6064 
  def write(self, oprot):
6065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6067 
      return
559 chandransh 6068 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6069 
    if self.success is not None:
94 ashish 6070 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6071 
      self.success.write(oprot)
6072 
      oprot.writeFieldEnd()
3431 rajveer 6073 
    if self.auex is not None:
559 chandransh 6074 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6075 
      self.auex.write(oprot)
94 ashish 6076 
      oprot.writeFieldEnd()
6077 
    oprot.writeFieldStop()
6078 
    oprot.writeStructEnd()
6079 
 
3431 rajveer 6080 
  def validate(self):
6081 
    return
6082 
 
6083 
 
94 ashish 6084 
  def __repr__(self):
6085 
    L = ['%s=%r' % (key, value)
6086 
      for key, value in self.__dict__.iteritems()]
6087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6088 
 
6089 
  def __eq__(self, other):
6090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6091 
 
6092 
  def __ne__(self, other):
6093 
    return not (self == other)
6094 
 
559 chandransh 6095 
class userExists_args:
122 ashish 6096 
  """
6097 
  Attributes:
559 chandransh 6098 
   - email
122 ashish 6099 
  """
6100 
 
6101 
  thrift_spec = (
6102 
    None, # 0
559 chandransh 6103 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6104 
  )
6105 
 
559 chandransh 6106 
  def __init__(self, email=None,):
6107 
    self.email = email
122 ashish 6108 
 
6109 
  def read(self, iprot):
6110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6112 
      return
6113 
    iprot.readStructBegin()
6114 
    while True:
6115 
      (fname, ftype, fid) = iprot.readFieldBegin()
6116 
      if ftype == TType.STOP:
6117 
        break
6118 
      if fid == 1:
6119 
        if ftype == TType.STRING:
559 chandransh 6120 
          self.email = iprot.readString();
122 ashish 6121 
        else:
6122 
          iprot.skip(ftype)
559 chandransh 6123 
      else:
6124 
        iprot.skip(ftype)
6125 
      iprot.readFieldEnd()
6126 
    iprot.readStructEnd()
6127 
 
6128 
  def write(self, oprot):
6129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6131 
      return
6132 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6133 
    if self.email is not None:
559 chandransh 6134 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6135 
      oprot.writeString(self.email)
6136 
      oprot.writeFieldEnd()
6137 
    oprot.writeFieldStop()
6138 
    oprot.writeStructEnd()
6139 
 
3431 rajveer 6140 
  def validate(self):
6141 
    return
6142 
 
6143 
 
559 chandransh 6144 
  def __repr__(self):
6145 
    L = ['%s=%r' % (key, value)
6146 
      for key, value in self.__dict__.iteritems()]
6147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6148 
 
6149 
  def __eq__(self, other):
6150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6151 
 
6152 
  def __ne__(self, other):
6153 
    return not (self == other)
6154 
 
6155 
class userExists_result:
6156 
  """
6157 
  Attributes:
6158 
   - success
6159 
   - ucx
6160 
  """
6161 
 
6162 
  thrift_spec = (
6163 
    (0, TType.BOOL, 'success', None, None, ), # 0
6164 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6165 
  )
6166 
 
6167 
  def __init__(self, success=None, ucx=None,):
6168 
    self.success = success
6169 
    self.ucx = ucx
6170 
 
6171 
  def read(self, iprot):
6172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6174 
      return
6175 
    iprot.readStructBegin()
6176 
    while True:
6177 
      (fname, ftype, fid) = iprot.readFieldBegin()
6178 
      if ftype == TType.STOP:
6179 
        break
6180 
      if fid == 0:
6181 
        if ftype == TType.BOOL:
6182 
          self.success = iprot.readBool();
6183 
        else:
6184 
          iprot.skip(ftype)
6185 
      elif fid == 1:
6186 
        if ftype == TType.STRUCT:
6187 
          self.ucx = UserContextException()
6188 
          self.ucx.read(iprot)
6189 
        else:
6190 
          iprot.skip(ftype)
6191 
      else:
6192 
        iprot.skip(ftype)
6193 
      iprot.readFieldEnd()
6194 
    iprot.readStructEnd()
6195 
 
6196 
  def write(self, oprot):
6197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6199 
      return
6200 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6201 
    if self.success is not None:
559 chandransh 6202 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6203 
      oprot.writeBool(self.success)
6204 
      oprot.writeFieldEnd()
3431 rajveer 6205 
    if self.ucx is not None:
559 chandransh 6206 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6207 
      self.ucx.write(oprot)
6208 
      oprot.writeFieldEnd()
6209 
    oprot.writeFieldStop()
6210 
    oprot.writeStructEnd()
6211 
 
3431 rajveer 6212 
  def validate(self):
6213 
    return
6214 
 
6215 
 
559 chandransh 6216 
  def __repr__(self):
6217 
    L = ['%s=%r' % (key, value)
6218 
      for key, value in self.__dict__.iteritems()]
6219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6220 
 
6221 
  def __eq__(self, other):
6222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6223 
 
6224 
  def __ne__(self, other):
6225 
    return not (self == other)
6226 
 
6227 
class addAddressForUser_args:
6228 
  """
6229 
  Attributes:
6230 
   - userId
6231 
   - address
6232 
   - setDefault
6233 
  """
6234 
 
6235 
  thrift_spec = (
6236 
    None, # 0
6237 
    (1, TType.I64, 'userId', None, None, ), # 1
6238 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6239 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6240 
  )
6241 
 
567 rajveer 6242 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6243 
    self.userId = userId
6244 
    self.address = address
6245 
    self.setDefault = setDefault
6246 
 
6247 
  def read(self, iprot):
6248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6250 
      return
6251 
    iprot.readStructBegin()
6252 
    while True:
6253 
      (fname, ftype, fid) = iprot.readFieldBegin()
6254 
      if ftype == TType.STOP:
6255 
        break
6256 
      if fid == 1:
6257 
        if ftype == TType.I64:
6258 
          self.userId = iprot.readI64();
6259 
        else:
6260 
          iprot.skip(ftype)
122 ashish 6261 
      elif fid == 2:
559 chandransh 6262 
        if ftype == TType.STRUCT:
6263 
          self.address = Address()
6264 
          self.address.read(iprot)
122 ashish 6265 
        else:
6266 
          iprot.skip(ftype)
6267 
      elif fid == 3:
6268 
        if ftype == TType.BOOL:
559 chandransh 6269 
          self.setDefault = iprot.readBool();
122 ashish 6270 
        else:
6271 
          iprot.skip(ftype)
6272 
      else:
6273 
        iprot.skip(ftype)
6274 
      iprot.readFieldEnd()
6275 
    iprot.readStructEnd()
6276 
 
6277 
  def write(self, oprot):
6278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6280 
      return
559 chandransh 6281 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6282 
    if self.userId is not None:
559 chandransh 6283 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6284 
      oprot.writeI64(self.userId)
122 ashish 6285 
      oprot.writeFieldEnd()
3431 rajveer 6286 
    if self.address is not None:
559 chandransh 6287 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6288 
      self.address.write(oprot)
122 ashish 6289 
      oprot.writeFieldEnd()
3431 rajveer 6290 
    if self.setDefault is not None:
567 rajveer 6291 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6292 
      oprot.writeBool(self.setDefault)
6293 
      oprot.writeFieldEnd()
122 ashish 6294 
    oprot.writeFieldStop()
6295 
    oprot.writeStructEnd()
6296 
 
3431 rajveer 6297 
  def validate(self):
6298 
    return
6299 
 
6300 
 
122 ashish 6301 
  def __repr__(self):
6302 
    L = ['%s=%r' % (key, value)
6303 
      for key, value in self.__dict__.iteritems()]
6304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6305 
 
6306 
  def __eq__(self, other):
6307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6308 
 
6309 
  def __ne__(self, other):
6310 
    return not (self == other)
6311 
 
559 chandransh 6312 
class addAddressForUser_result:
122 ashish 6313 
  """
6314 
  Attributes:
6315 
   - success
559 chandransh 6316 
   - ucx
122 ashish 6317 
  """
6318 
 
6319 
  thrift_spec = (
567 rajveer 6320 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6321 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6322 
  )
6323 
 
559 chandransh 6324 
  def __init__(self, success=None, ucx=None,):
122 ashish 6325 
    self.success = success
559 chandransh 6326 
    self.ucx = ucx
122 ashish 6327 
 
6328 
  def read(self, iprot):
6329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6331 
      return
6332 
    iprot.readStructBegin()
6333 
    while True:
6334 
      (fname, ftype, fid) = iprot.readFieldBegin()
6335 
      if ftype == TType.STOP:
6336 
        break
6337 
      if fid == 0:
567 rajveer 6338 
        if ftype == TType.I64:
6339 
          self.success = iprot.readI64();
122 ashish 6340 
        else:
6341 
          iprot.skip(ftype)
6342 
      elif fid == 1:
6343 
        if ftype == TType.STRUCT:
559 chandransh 6344 
          self.ucx = UserContextException()
6345 
          self.ucx.read(iprot)
122 ashish 6346 
        else:
6347 
          iprot.skip(ftype)
6348 
      else:
6349 
        iprot.skip(ftype)
6350 
      iprot.readFieldEnd()
6351 
    iprot.readStructEnd()
6352 
 
6353 
  def write(self, oprot):
6354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6356 
      return
559 chandransh 6357 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6358 
    if self.success is not None:
567 rajveer 6359 
      oprot.writeFieldBegin('success', TType.I64, 0)
6360 
      oprot.writeI64(self.success)
122 ashish 6361 
      oprot.writeFieldEnd()
3431 rajveer 6362 
    if self.ucx is not None:
559 chandransh 6363 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6364 
      self.ucx.write(oprot)
122 ashish 6365 
      oprot.writeFieldEnd()
6366 
    oprot.writeFieldStop()
6367 
    oprot.writeStructEnd()
6368 
 
3431 rajveer 6369 
  def validate(self):
6370 
    return
6371 
 
6372 
 
122 ashish 6373 
  def __repr__(self):
6374 
    L = ['%s=%r' % (key, value)
6375 
      for key, value in self.__dict__.iteritems()]
6376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6377 
 
6378 
  def __eq__(self, other):
6379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6380 
 
6381 
  def __ne__(self, other):
6382 
    return not (self == other)
6383 
 
559 chandransh 6384 
class removeAddressForUser_args:
94 ashish 6385 
  """
6386 
  Attributes:
559 chandransh 6387 
   - userid
6388 
   - addressId
94 ashish 6389 
  """
6390 
 
6391 
  thrift_spec = (
6392 
    None, # 0
559 chandransh 6393 
    (1, TType.I64, 'userid', None, None, ), # 1
6394 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6395 
  )
6396 
 
559 chandransh 6397 
  def __init__(self, userid=None, addressId=None,):
6398 
    self.userid = userid
6399 
    self.addressId = addressId
94 ashish 6400 
 
6401 
  def read(self, iprot):
6402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6404 
      return
6405 
    iprot.readStructBegin()
6406 
    while True:
6407 
      (fname, ftype, fid) = iprot.readFieldBegin()
6408 
      if ftype == TType.STOP:
6409 
        break
6410 
      if fid == 1:
559 chandransh 6411 
        if ftype == TType.I64:
6412 
          self.userid = iprot.readI64();
94 ashish 6413 
        else:
6414 
          iprot.skip(ftype)
559 chandransh 6415 
      elif fid == 2:
6416 
        if ftype == TType.I64:
6417 
          self.addressId = iprot.readI64();
6418 
        else:
6419 
          iprot.skip(ftype)
94 ashish 6420 
      else:
6421 
        iprot.skip(ftype)
6422 
      iprot.readFieldEnd()
6423 
    iprot.readStructEnd()
6424 
 
6425 
  def write(self, oprot):
6426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6428 
      return
559 chandransh 6429 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6430 
    if self.userid is not None:
559 chandransh 6431 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6432 
      oprot.writeI64(self.userid)
94 ashish 6433 
      oprot.writeFieldEnd()
3431 rajveer 6434 
    if self.addressId is not None:
559 chandransh 6435 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6436 
      oprot.writeI64(self.addressId)
6437 
      oprot.writeFieldEnd()
94 ashish 6438 
    oprot.writeFieldStop()
6439 
    oprot.writeStructEnd()
6440 
 
3431 rajveer 6441 
  def validate(self):
6442 
    return
6443 
 
6444 
 
94 ashish 6445 
  def __repr__(self):
6446 
    L = ['%s=%r' % (key, value)
6447 
      for key, value in self.__dict__.iteritems()]
6448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6449 
 
6450 
  def __eq__(self, other):
6451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6452 
 
6453 
  def __ne__(self, other):
6454 
    return not (self == other)
6455 
 
559 chandransh 6456 
class removeAddressForUser_result:
94 ashish 6457 
  """
6458 
  Attributes:
6459 
   - success
6460 
   - ucx
6461 
  """
6462 
 
6463 
  thrift_spec = (
6464 
    (0, TType.BOOL, 'success', None, None, ), # 0
6465 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6466 
  )
6467 
 
6468 
  def __init__(self, success=None, ucx=None,):
6469 
    self.success = success
6470 
    self.ucx = ucx
6471 
 
6472 
  def read(self, iprot):
6473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6475 
      return
6476 
    iprot.readStructBegin()
6477 
    while True:
6478 
      (fname, ftype, fid) = iprot.readFieldBegin()
6479 
      if ftype == TType.STOP:
6480 
        break
6481 
      if fid == 0:
6482 
        if ftype == TType.BOOL:
6483 
          self.success = iprot.readBool();
6484 
        else:
6485 
          iprot.skip(ftype)
6486 
      elif fid == 1:
6487 
        if ftype == TType.STRUCT:
6488 
          self.ucx = UserContextException()
6489 
          self.ucx.read(iprot)
6490 
        else:
6491 
          iprot.skip(ftype)
6492 
      else:
6493 
        iprot.skip(ftype)
6494 
      iprot.readFieldEnd()
6495 
    iprot.readStructEnd()
6496 
 
6497 
  def write(self, oprot):
6498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6500 
      return
559 chandransh 6501 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6502 
    if self.success is not None:
94 ashish 6503 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6504 
      oprot.writeBool(self.success)
6505 
      oprot.writeFieldEnd()
3431 rajveer 6506 
    if self.ucx is not None:
94 ashish 6507 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6508 
      self.ucx.write(oprot)
6509 
      oprot.writeFieldEnd()
6510 
    oprot.writeFieldStop()
6511 
    oprot.writeStructEnd()
6512 
 
3431 rajveer 6513 
  def validate(self):
6514 
    return
6515 
 
6516 
 
94 ashish 6517 
  def __repr__(self):
6518 
    L = ['%s=%r' % (key, value)
6519 
      for key, value in self.__dict__.iteritems()]
6520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6521 
 
6522 
  def __eq__(self, other):
6523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6524 
 
6525 
  def __ne__(self, other):
6526 
    return not (self == other)
6527 
 
559 chandransh 6528 
class setUserAsLoggedIn_args:
94 ashish 6529 
  """
6530 
  Attributes:
559 chandransh 6531 
   - userId
94 ashish 6532 
   - timestamp
6533 
  """
6534 
 
6535 
  thrift_spec = (
6536 
    None, # 0
559 chandransh 6537 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6538 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6539 
  )
6540 
 
559 chandransh 6541 
  def __init__(self, userId=None, timestamp=None,):
6542 
    self.userId = userId
94 ashish 6543 
    self.timestamp = timestamp
6544 
 
6545 
  def read(self, iprot):
6546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6548 
      return
6549 
    iprot.readStructBegin()
6550 
    while True:
6551 
      (fname, ftype, fid) = iprot.readFieldBegin()
6552 
      if ftype == TType.STOP:
6553 
        break
6554 
      if fid == 1:
559 chandransh 6555 
        if ftype == TType.I64:
6556 
          self.userId = iprot.readI64();
94 ashish 6557 
        else:
6558 
          iprot.skip(ftype)
6559 
      elif fid == 2:
6560 
        if ftype == TType.I64:
6561 
          self.timestamp = iprot.readI64();
6562 
        else:
6563 
          iprot.skip(ftype)
6564 
      else:
6565 
        iprot.skip(ftype)
6566 
      iprot.readFieldEnd()
6567 
    iprot.readStructEnd()
6568 
 
6569 
  def write(self, oprot):
6570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6572 
      return
559 chandransh 6573 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6574 
    if self.userId is not None:
559 chandransh 6575 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6576 
      oprot.writeI64(self.userId)
94 ashish 6577 
      oprot.writeFieldEnd()
3431 rajveer 6578 
    if self.timestamp is not None:
94 ashish 6579 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6580 
      oprot.writeI64(self.timestamp)
6581 
      oprot.writeFieldEnd()
6582 
    oprot.writeFieldStop()
6583 
    oprot.writeStructEnd()
6584 
 
3431 rajveer 6585 
  def validate(self):
6586 
    return
6587 
 
6588 
 
94 ashish 6589 
  def __repr__(self):
6590 
    L = ['%s=%r' % (key, value)
6591 
      for key, value in self.__dict__.iteritems()]
6592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6593 
 
6594 
  def __eq__(self, other):
6595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6596 
 
6597 
  def __ne__(self, other):
6598 
    return not (self == other)
6599 
 
559 chandransh 6600 
class setUserAsLoggedIn_result:
94 ashish 6601 
  """
6602 
  Attributes:
6603 
   - success
6604 
   - ucx
6605 
  """
6606 
 
6607 
  thrift_spec = (
6608 
    (0, TType.BOOL, 'success', None, None, ), # 0
6609 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6610 
  )
6611 
 
6612 
  def __init__(self, success=None, ucx=None,):
6613 
    self.success = success
6614 
    self.ucx = ucx
6615 
 
6616 
  def read(self, iprot):
6617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6619 
      return
6620 
    iprot.readStructBegin()
6621 
    while True:
6622 
      (fname, ftype, fid) = iprot.readFieldBegin()
6623 
      if ftype == TType.STOP:
6624 
        break
6625 
      if fid == 0:
6626 
        if ftype == TType.BOOL:
6627 
          self.success = iprot.readBool();
6628 
        else:
6629 
          iprot.skip(ftype)
6630 
      elif fid == 1:
6631 
        if ftype == TType.STRUCT:
6632 
          self.ucx = UserContextException()
6633 
          self.ucx.read(iprot)
6634 
        else:
6635 
          iprot.skip(ftype)
6636 
      else:
6637 
        iprot.skip(ftype)
6638 
      iprot.readFieldEnd()
6639 
    iprot.readStructEnd()
6640 
 
6641 
  def write(self, oprot):
6642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6644 
      return
559 chandransh 6645 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6646 
    if self.success is not None:
94 ashish 6647 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6648 
      oprot.writeBool(self.success)
6649 
      oprot.writeFieldEnd()
3431 rajveer 6650 
    if self.ucx is not None:
94 ashish 6651 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6652 
      self.ucx.write(oprot)
6653 
      oprot.writeFieldEnd()
6654 
    oprot.writeFieldStop()
6655 
    oprot.writeStructEnd()
6656 
 
3431 rajveer 6657 
  def validate(self):
6658 
    return
6659 
 
6660 
 
94 ashish 6661 
  def __repr__(self):
6662 
    L = ['%s=%r' % (key, value)
6663 
      for key, value in self.__dict__.iteritems()]
6664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6665 
 
6666 
  def __eq__(self, other):
6667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6668 
 
6669 
  def __ne__(self, other):
6670 
    return not (self == other)
6671 
 
559 chandransh 6672 
class setUserAsLoggedOut_args:
94 ashish 6673 
  """
6674 
  Attributes:
6675 
   - userid
6676 
   - timestamp
6677 
  """
6678 
 
6679 
  thrift_spec = (
6680 
    None, # 0
559 chandransh 6681 
    (1, TType.I64, 'userid', None, None, ), # 1
6682 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6683 
  )
6684 
 
559 chandransh 6685 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6686 
    self.userid = userid
6687 
    self.timestamp = timestamp
6688 
 
6689 
  def read(self, iprot):
6690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6692 
      return
6693 
    iprot.readStructBegin()
6694 
    while True:
6695 
      (fname, ftype, fid) = iprot.readFieldBegin()
6696 
      if ftype == TType.STOP:
6697 
        break
6698 
      if fid == 1:
6699 
        if ftype == TType.I64:
6700 
          self.userid = iprot.readI64();
6701 
        else:
6702 
          iprot.skip(ftype)
559 chandransh 6703 
      elif fid == 2:
94 ashish 6704 
        if ftype == TType.I64:
6705 
          self.timestamp = iprot.readI64();
6706 
        else:
6707 
          iprot.skip(ftype)
6708 
      else:
6709 
        iprot.skip(ftype)
6710 
      iprot.readFieldEnd()
6711 
    iprot.readStructEnd()
6712 
 
6713 
  def write(self, oprot):
6714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6716 
      return
559 chandransh 6717 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6718 
    if self.userid is not None:
559 chandransh 6719 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6720 
      oprot.writeI64(self.userid)
6721 
      oprot.writeFieldEnd()
3431 rajveer 6722 
    if self.timestamp is not None:
559 chandransh 6723 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6724 
      oprot.writeI64(self.timestamp)
6725 
      oprot.writeFieldEnd()
6726 
    oprot.writeFieldStop()
6727 
    oprot.writeStructEnd()
6728 
 
3431 rajveer 6729 
  def validate(self):
6730 
    return
6731 
 
6732 
 
94 ashish 6733 
  def __repr__(self):
6734 
    L = ['%s=%r' % (key, value)
6735 
      for key, value in self.__dict__.iteritems()]
6736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6737 
 
6738 
  def __eq__(self, other):
6739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6740 
 
6741 
  def __ne__(self, other):
6742 
    return not (self == other)
6743 
 
559 chandransh 6744 
class setUserAsLoggedOut_result:
94 ashish 6745 
  """
6746 
  Attributes:
6747 
   - success
6748 
   - ucx
6749 
  """
6750 
 
6751 
  thrift_spec = (
6752 
    (0, TType.BOOL, 'success', None, None, ), # 0
6753 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6754 
  )
6755 
 
6756 
  def __init__(self, success=None, ucx=None,):
6757 
    self.success = success
6758 
    self.ucx = ucx
6759 
 
6760 
  def read(self, iprot):
6761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6763 
      return
6764 
    iprot.readStructBegin()
6765 
    while True:
6766 
      (fname, ftype, fid) = iprot.readFieldBegin()
6767 
      if ftype == TType.STOP:
6768 
        break
6769 
      if fid == 0:
6770 
        if ftype == TType.BOOL:
6771 
          self.success = iprot.readBool();
6772 
        else:
6773 
          iprot.skip(ftype)
6774 
      elif fid == 1:
6775 
        if ftype == TType.STRUCT:
6776 
          self.ucx = UserContextException()
6777 
          self.ucx.read(iprot)
6778 
        else:
6779 
          iprot.skip(ftype)
6780 
      else:
6781 
        iprot.skip(ftype)
6782 
      iprot.readFieldEnd()
6783 
    iprot.readStructEnd()
6784 
 
6785 
  def write(self, oprot):
6786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6788 
      return
559 chandransh 6789 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6790 
    if self.success is not None:
94 ashish 6791 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6792 
      oprot.writeBool(self.success)
6793 
      oprot.writeFieldEnd()
3431 rajveer 6794 
    if self.ucx is not None:
94 ashish 6795 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6796 
      self.ucx.write(oprot)
6797 
      oprot.writeFieldEnd()
6798 
    oprot.writeFieldStop()
6799 
    oprot.writeStructEnd()
6800 
 
3431 rajveer 6801 
  def validate(self):
6802 
    return
6803 
 
6804 
 
94 ashish 6805 
  def __repr__(self):
6806 
    L = ['%s=%r' % (key, value)
6807 
      for key, value in self.__dict__.iteritems()]
6808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6809 
 
6810 
  def __eq__(self, other):
6811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6812 
 
6813 
  def __ne__(self, other):
6814 
    return not (self == other)
6815 
 
559 chandransh 6816 
class setDefaultAddress_args:
94 ashish 6817 
  """
6818 
  Attributes:
6819 
   - userid
6820 
   - addressId
6821 
  """
6822 
 
6823 
  thrift_spec = (
6824 
    None, # 0
6825 
    (1, TType.I64, 'userid', None, None, ), # 1
6826 
    (2, TType.I64, 'addressId', None, None, ), # 2
6827 
  )
6828 
 
6829 
  def __init__(self, userid=None, addressId=None,):
6830 
    self.userid = userid
6831 
    self.addressId = addressId
6832 
 
6833 
  def read(self, iprot):
6834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6836 
      return
6837 
    iprot.readStructBegin()
6838 
    while True:
6839 
      (fname, ftype, fid) = iprot.readFieldBegin()
6840 
      if ftype == TType.STOP:
6841 
        break
6842 
      if fid == 1:
6843 
        if ftype == TType.I64:
6844 
          self.userid = iprot.readI64();
6845 
        else:
6846 
          iprot.skip(ftype)
6847 
      elif fid == 2:
6848 
        if ftype == TType.I64:
6849 
          self.addressId = iprot.readI64();
6850 
        else:
6851 
          iprot.skip(ftype)
6852 
      else:
6853 
        iprot.skip(ftype)
6854 
      iprot.readFieldEnd()
6855 
    iprot.readStructEnd()
6856 
 
6857 
  def write(self, oprot):
6858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6860 
      return
559 chandransh 6861 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6862 
    if self.userid is not None:
94 ashish 6863 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6864 
      oprot.writeI64(self.userid)
6865 
      oprot.writeFieldEnd()
3431 rajveer 6866 
    if self.addressId is not None:
94 ashish 6867 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6868 
      oprot.writeI64(self.addressId)
6869 
      oprot.writeFieldEnd()
6870 
    oprot.writeFieldStop()
6871 
    oprot.writeStructEnd()
6872 
 
3431 rajveer 6873 
  def validate(self):
6874 
    return
6875 
 
6876 
 
94 ashish 6877 
  def __repr__(self):
6878 
    L = ['%s=%r' % (key, value)
6879 
      for key, value in self.__dict__.iteritems()]
6880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6881 
 
6882 
  def __eq__(self, other):
6883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6884 
 
6885 
  def __ne__(self, other):
6886 
    return not (self == other)
6887 
 
559 chandransh 6888 
class setDefaultAddress_result:
94 ashish 6889 
  """
6890 
  Attributes:
6891 
   - success
6892 
   - ucx
6893 
  """
6894 
 
6895 
  thrift_spec = (
6896 
    (0, TType.BOOL, 'success', None, None, ), # 0
6897 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6898 
  )
6899 
 
6900 
  def __init__(self, success=None, ucx=None,):
6901 
    self.success = success
6902 
    self.ucx = ucx
6903 
 
6904 
  def read(self, iprot):
6905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6907 
      return
6908 
    iprot.readStructBegin()
6909 
    while True:
6910 
      (fname, ftype, fid) = iprot.readFieldBegin()
6911 
      if ftype == TType.STOP:
6912 
        break
6913 
      if fid == 0:
6914 
        if ftype == TType.BOOL:
6915 
          self.success = iprot.readBool();
6916 
        else:
6917 
          iprot.skip(ftype)
6918 
      elif fid == 1:
6919 
        if ftype == TType.STRUCT:
6920 
          self.ucx = UserContextException()
6921 
          self.ucx.read(iprot)
6922 
        else:
6923 
          iprot.skip(ftype)
6924 
      else:
6925 
        iprot.skip(ftype)
6926 
      iprot.readFieldEnd()
6927 
    iprot.readStructEnd()
6928 
 
6929 
  def write(self, oprot):
6930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6932 
      return
559 chandransh 6933 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6934 
    if self.success is not None:
94 ashish 6935 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6936 
      oprot.writeBool(self.success)
6937 
      oprot.writeFieldEnd()
3431 rajveer 6938 
    if self.ucx is not None:
94 ashish 6939 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6940 
      self.ucx.write(oprot)
6941 
      oprot.writeFieldEnd()
6942 
    oprot.writeFieldStop()
6943 
    oprot.writeStructEnd()
6944 
 
3431 rajveer 6945 
  def validate(self):
6946 
    return
6947 
 
6948 
 
94 ashish 6949 
  def __repr__(self):
6950 
    L = ['%s=%r' % (key, value)
6951 
      for key, value in self.__dict__.iteritems()]
6952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6953 
 
6954 
  def __eq__(self, other):
6955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6956 
 
6957 
  def __ne__(self, other):
6958 
    return not (self == other)
6959 
 
559 chandransh 6960 
class updatePassword_args:
94 ashish 6961 
  """
6962 
  Attributes:
559 chandransh 6963 
   - userid
594 rajveer 6964 
   - oldPassword
6965 
   - newPassword
94 ashish 6966 
  """
6967 
 
6968 
  thrift_spec = (
6969 
    None, # 0
559 chandransh 6970 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6971 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6972 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6973 
  )
6974 
 
594 rajveer 6975 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6976 
    self.userid = userid
594 rajveer 6977 
    self.oldPassword = oldPassword
6978 
    self.newPassword = newPassword
94 ashish 6979 
 
6980 
  def read(self, iprot):
6981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6983 
      return
6984 
    iprot.readStructBegin()
6985 
    while True:
6986 
      (fname, ftype, fid) = iprot.readFieldBegin()
6987 
      if ftype == TType.STOP:
6988 
        break
6989 
      if fid == 1:
6990 
        if ftype == TType.I64:
559 chandransh 6991 
          self.userid = iprot.readI64();
94 ashish 6992 
        else:
6993 
          iprot.skip(ftype)
6994 
      elif fid == 2:
559 chandransh 6995 
        if ftype == TType.STRING:
594 rajveer 6996 
          self.oldPassword = iprot.readString();
94 ashish 6997 
        else:
6998 
          iprot.skip(ftype)
594 rajveer 6999 
      elif fid == 3:
7000 
        if ftype == TType.STRING:
7001 
          self.newPassword = iprot.readString();
7002 
        else:
7003 
          iprot.skip(ftype)
94 ashish 7004 
      else:
7005 
        iprot.skip(ftype)
7006 
      iprot.readFieldEnd()
7007 
    iprot.readStructEnd()
7008 
 
7009 
  def write(self, oprot):
7010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7012 
      return
559 chandransh 7013 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7014 
    if self.userid is not None:
559 chandransh 7015 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7016 
      oprot.writeI64(self.userid)
94 ashish 7017 
      oprot.writeFieldEnd()
3431 rajveer 7018 
    if self.oldPassword is not None:
594 rajveer 7019 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7020 
      oprot.writeString(self.oldPassword)
94 ashish 7021 
      oprot.writeFieldEnd()
3431 rajveer 7022 
    if self.newPassword is not None:
594 rajveer 7023 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7024 
      oprot.writeString(self.newPassword)
7025 
      oprot.writeFieldEnd()
94 ashish 7026 
    oprot.writeFieldStop()
7027 
    oprot.writeStructEnd()
7028 
 
3431 rajveer 7029 
  def validate(self):
7030 
    return
7031 
 
7032 
 
94 ashish 7033 
  def __repr__(self):
7034 
    L = ['%s=%r' % (key, value)
7035 
      for key, value in self.__dict__.iteritems()]
7036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7037 
 
7038 
  def __eq__(self, other):
7039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7040 
 
7041 
  def __ne__(self, other):
7042 
    return not (self == other)
7043 
 
559 chandransh 7044 
class updatePassword_result:
94 ashish 7045 
  """
7046 
  Attributes:
7047 
   - success
7048 
   - ucx
7049 
  """
7050 
 
7051 
  thrift_spec = (
7052 
    (0, TType.BOOL, 'success', None, None, ), # 0
7053 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7054 
  )
7055 
 
7056 
  def __init__(self, success=None, ucx=None,):
7057 
    self.success = success
7058 
    self.ucx = ucx
7059 
 
7060 
  def read(self, iprot):
7061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7063 
      return
7064 
    iprot.readStructBegin()
7065 
    while True:
7066 
      (fname, ftype, fid) = iprot.readFieldBegin()
7067 
      if ftype == TType.STOP:
7068 
        break
7069 
      if fid == 0:
7070 
        if ftype == TType.BOOL:
7071 
          self.success = iprot.readBool();
7072 
        else:
7073 
          iprot.skip(ftype)
7074 
      elif fid == 1:
7075 
        if ftype == TType.STRUCT:
7076 
          self.ucx = UserContextException()
7077 
          self.ucx.read(iprot)
7078 
        else:
7079 
          iprot.skip(ftype)
7080 
      else:
7081 
        iprot.skip(ftype)
7082 
      iprot.readFieldEnd()
7083 
    iprot.readStructEnd()
7084 
 
7085 
  def write(self, oprot):
7086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7088 
      return
559 chandransh 7089 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7090 
    if self.success is not None:
94 ashish 7091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7092 
      oprot.writeBool(self.success)
7093 
      oprot.writeFieldEnd()
3431 rajveer 7094 
    if self.ucx is not None:
94 ashish 7095 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7096 
      self.ucx.write(oprot)
7097 
      oprot.writeFieldEnd()
7098 
    oprot.writeFieldStop()
7099 
    oprot.writeStructEnd()
7100 
 
3431 rajveer 7101 
  def validate(self):
7102 
    return
7103 
 
7104 
 
94 ashish 7105 
  def __repr__(self):
7106 
    L = ['%s=%r' % (key, value)
7107 
      for key, value in self.__dict__.iteritems()]
7108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7109 
 
7110 
  def __eq__(self, other):
7111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7112 
 
7113 
  def __ne__(self, other):
7114 
    return not (self == other)
7115 
 
581 rajveer 7116 
class forgotPassword_args:
7117 
  """
7118 
  Attributes:
7119 
   - email
884 rajveer 7120 
   - newPassword
581 rajveer 7121 
  """
7122 
 
7123 
  thrift_spec = (
7124 
    None, # 0
7125 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7126 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7127 
  )
7128 
 
884 rajveer 7129 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7130 
    self.email = email
884 rajveer 7131 
    self.newPassword = newPassword
581 rajveer 7132 
 
7133 
  def read(self, iprot):
7134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7136 
      return
7137 
    iprot.readStructBegin()
7138 
    while True:
7139 
      (fname, ftype, fid) = iprot.readFieldBegin()
7140 
      if ftype == TType.STOP:
7141 
        break
7142 
      if fid == 1:
7143 
        if ftype == TType.STRING:
7144 
          self.email = iprot.readString();
7145 
        else:
7146 
          iprot.skip(ftype)
884 rajveer 7147 
      elif fid == 2:
7148 
        if ftype == TType.STRING:
7149 
          self.newPassword = iprot.readString();
7150 
        else:
7151 
          iprot.skip(ftype)
581 rajveer 7152 
      else:
7153 
        iprot.skip(ftype)
7154 
      iprot.readFieldEnd()
7155 
    iprot.readStructEnd()
7156 
 
7157 
  def write(self, oprot):
7158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7160 
      return
7161 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7162 
    if self.email is not None:
581 rajveer 7163 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7164 
      oprot.writeString(self.email)
7165 
      oprot.writeFieldEnd()
3431 rajveer 7166 
    if self.newPassword is not None:
884 rajveer 7167 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7168 
      oprot.writeString(self.newPassword)
7169 
      oprot.writeFieldEnd()
581 rajveer 7170 
    oprot.writeFieldStop()
7171 
    oprot.writeStructEnd()
7172 
 
3431 rajveer 7173 
  def validate(self):
7174 
    return
7175 
 
7176 
 
581 rajveer 7177 
  def __repr__(self):
7178 
    L = ['%s=%r' % (key, value)
7179 
      for key, value in self.__dict__.iteritems()]
7180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7181 
 
7182 
  def __eq__(self, other):
7183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7184 
 
7185 
  def __ne__(self, other):
7186 
    return not (self == other)
7187 
 
7188 
class forgotPassword_result:
7189 
  """
7190 
  Attributes:
7191 
   - success
7192 
   - ucx
7193 
  """
7194 
 
7195 
  thrift_spec = (
7196 
    (0, TType.BOOL, 'success', None, None, ), # 0
7197 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7198 
  )
7199 
 
7200 
  def __init__(self, success=None, ucx=None,):
7201 
    self.success = success
7202 
    self.ucx = ucx
7203 
 
7204 
  def read(self, iprot):
7205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7207 
      return
7208 
    iprot.readStructBegin()
7209 
    while True:
7210 
      (fname, ftype, fid) = iprot.readFieldBegin()
7211 
      if ftype == TType.STOP:
7212 
        break
7213 
      if fid == 0:
7214 
        if ftype == TType.BOOL:
7215 
          self.success = iprot.readBool();
7216 
        else:
7217 
          iprot.skip(ftype)
7218 
      elif fid == 1:
7219 
        if ftype == TType.STRUCT:
7220 
          self.ucx = UserContextException()
7221 
          self.ucx.read(iprot)
7222 
        else:
7223 
          iprot.skip(ftype)
7224 
      else:
7225 
        iprot.skip(ftype)
7226 
      iprot.readFieldEnd()
7227 
    iprot.readStructEnd()
7228 
 
7229 
  def write(self, oprot):
7230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7232 
      return
7233 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7234 
    if self.success is not None:
581 rajveer 7235 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7236 
      oprot.writeBool(self.success)
7237 
      oprot.writeFieldEnd()
3431 rajveer 7238 
    if self.ucx is not None:
581 rajveer 7239 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7240 
      self.ucx.write(oprot)
7241 
      oprot.writeFieldEnd()
7242 
    oprot.writeFieldStop()
7243 
    oprot.writeStructEnd()
7244 
 
3431 rajveer 7245 
  def validate(self):
7246 
    return
7247 
 
7248 
 
581 rajveer 7249 
  def __repr__(self):
7250 
    L = ['%s=%r' % (key, value)
7251 
      for key, value in self.__dict__.iteritems()]
7252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7253 
 
7254 
  def __eq__(self, other):
7255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7256 
 
7257 
  def __ne__(self, other):
7258 
    return not (self == other)
7259 
 
594 rajveer 7260 
class getAllAddressesForUser_args:
7261 
  """
7262 
  Attributes:
7263 
   - userId
7264 
  """
7265 
 
7266 
  thrift_spec = (
7267 
    None, # 0
7268 
    (1, TType.I64, 'userId', None, None, ), # 1
7269 
  )
7270 
 
7271 
  def __init__(self, userId=None,):
7272 
    self.userId = userId
7273 
 
7274 
  def read(self, iprot):
7275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7277 
      return
7278 
    iprot.readStructBegin()
7279 
    while True:
7280 
      (fname, ftype, fid) = iprot.readFieldBegin()
7281 
      if ftype == TType.STOP:
7282 
        break
7283 
      if fid == 1:
7284 
        if ftype == TType.I64:
7285 
          self.userId = iprot.readI64();
7286 
        else:
7287 
          iprot.skip(ftype)
7288 
      else:
7289 
        iprot.skip(ftype)
7290 
      iprot.readFieldEnd()
7291 
    iprot.readStructEnd()
7292 
 
7293 
  def write(self, oprot):
7294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7296 
      return
7297 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7298 
    if self.userId is not None:
594 rajveer 7299 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7300 
      oprot.writeI64(self.userId)
7301 
      oprot.writeFieldEnd()
7302 
    oprot.writeFieldStop()
7303 
    oprot.writeStructEnd()
7304 
 
3431 rajveer 7305 
  def validate(self):
7306 
    return
7307 
 
7308 
 
594 rajveer 7309 
  def __repr__(self):
7310 
    L = ['%s=%r' % (key, value)
7311 
      for key, value in self.__dict__.iteritems()]
7312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7313 
 
7314 
  def __eq__(self, other):
7315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7316 
 
7317 
  def __ne__(self, other):
7318 
    return not (self == other)
7319 
 
7320 
class getAllAddressesForUser_result:
7321 
  """
7322 
  Attributes:
7323 
   - success
7324 
   - ucx
7325 
  """
7326 
 
7327 
  thrift_spec = (
7328 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7329 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7330 
  )
7331 
 
7332 
  def __init__(self, success=None, ucx=None,):
7333 
    self.success = success
7334 
    self.ucx = ucx
7335 
 
7336 
  def read(self, iprot):
7337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7339 
      return
7340 
    iprot.readStructBegin()
7341 
    while True:
7342 
      (fname, ftype, fid) = iprot.readFieldBegin()
7343 
      if ftype == TType.STOP:
7344 
        break
7345 
      if fid == 0:
7346 
        if ftype == TType.LIST:
7347 
          self.success = []
11592 amit.gupta 7348 
          (_etype100, _size97) = iprot.readListBegin()
7349 
          for _i101 in xrange(_size97):
7350 
            _elem102 = Address()
7351 
            _elem102.read(iprot)
7352 
            self.success.append(_elem102)
594 rajveer 7353 
          iprot.readListEnd()
7354 
        else:
7355 
          iprot.skip(ftype)
7356 
      elif fid == 1:
7357 
        if ftype == TType.STRUCT:
7358 
          self.ucx = UserContextException()
7359 
          self.ucx.read(iprot)
7360 
        else:
7361 
          iprot.skip(ftype)
7362 
      else:
7363 
        iprot.skip(ftype)
7364 
      iprot.readFieldEnd()
7365 
    iprot.readStructEnd()
7366 
 
7367 
  def write(self, oprot):
7368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7370 
      return
7371 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7372 
    if self.success is not None:
594 rajveer 7373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7374 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7375 
      for iter103 in self.success:
7376 
        iter103.write(oprot)
594 rajveer 7377 
      oprot.writeListEnd()
7378 
      oprot.writeFieldEnd()
3431 rajveer 7379 
    if self.ucx is not None:
594 rajveer 7380 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7381 
      self.ucx.write(oprot)
7382 
      oprot.writeFieldEnd()
7383 
    oprot.writeFieldStop()
7384 
    oprot.writeStructEnd()
7385 
 
3431 rajveer 7386 
  def validate(self):
7387 
    return
7388 
 
7389 
 
594 rajveer 7390 
  def __repr__(self):
7391 
    L = ['%s=%r' % (key, value)
7392 
      for key, value in self.__dict__.iteritems()]
7393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7394 
 
7395 
  def __eq__(self, other):
7396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7397 
 
7398 
  def __ne__(self, other):
7399 
    return not (self == other)
7400 
 
1894 vikas 7401 
class getAddressById_args:
7402 
  """
7403 
  Attributes:
7404 
   - addressId
7405 
  """
7406 
 
7407 
  thrift_spec = (
7408 
    None, # 0
7409 
    (1, TType.I64, 'addressId', None, None, ), # 1
7410 
  )
7411 
 
7412 
  def __init__(self, addressId=None,):
7413 
    self.addressId = addressId
7414 
 
7415 
  def read(self, iprot):
7416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7418 
      return
7419 
    iprot.readStructBegin()
7420 
    while True:
7421 
      (fname, ftype, fid) = iprot.readFieldBegin()
7422 
      if ftype == TType.STOP:
7423 
        break
7424 
      if fid == 1:
7425 
        if ftype == TType.I64:
7426 
          self.addressId = iprot.readI64();
7427 
        else:
7428 
          iprot.skip(ftype)
7429 
      else:
7430 
        iprot.skip(ftype)
7431 
      iprot.readFieldEnd()
7432 
    iprot.readStructEnd()
7433 
 
7434 
  def write(self, oprot):
7435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7437 
      return
7438 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7439 
    if self.addressId is not None:
1894 vikas 7440 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7441 
      oprot.writeI64(self.addressId)
7442 
      oprot.writeFieldEnd()
7443 
    oprot.writeFieldStop()
7444 
    oprot.writeStructEnd()
7445 
 
3431 rajveer 7446 
  def validate(self):
7447 
    return
7448 
 
7449 
 
1894 vikas 7450 
  def __repr__(self):
7451 
    L = ['%s=%r' % (key, value)
7452 
      for key, value in self.__dict__.iteritems()]
7453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7454 
 
7455 
  def __eq__(self, other):
7456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7457 
 
7458 
  def __ne__(self, other):
7459 
    return not (self == other)
7460 
 
7461 
class getAddressById_result:
7462 
  """
7463 
  Attributes:
7464 
   - success
7465 
   - ucx
7466 
  """
7467 
 
7468 
  thrift_spec = (
7469 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7470 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7471 
  )
7472 
 
7473 
  def __init__(self, success=None, ucx=None,):
7474 
    self.success = success
7475 
    self.ucx = ucx
7476 
 
7477 
  def read(self, iprot):
7478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7480 
      return
7481 
    iprot.readStructBegin()
7482 
    while True:
7483 
      (fname, ftype, fid) = iprot.readFieldBegin()
7484 
      if ftype == TType.STOP:
7485 
        break
7486 
      if fid == 0:
7487 
        if ftype == TType.STRUCT:
7488 
          self.success = Address()
7489 
          self.success.read(iprot)
7490 
        else:
7491 
          iprot.skip(ftype)
7492 
      elif fid == 1:
7493 
        if ftype == TType.STRUCT:
7494 
          self.ucx = UserContextException()
7495 
          self.ucx.read(iprot)
7496 
        else:
7497 
          iprot.skip(ftype)
7498 
      else:
7499 
        iprot.skip(ftype)
7500 
      iprot.readFieldEnd()
7501 
    iprot.readStructEnd()
7502 
 
7503 
  def write(self, oprot):
7504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7506 
      return
7507 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7508 
    if self.success is not None:
1894 vikas 7509 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7510 
      self.success.write(oprot)
7511 
      oprot.writeFieldEnd()
3431 rajveer 7512 
    if self.ucx is not None:
1894 vikas 7513 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7514 
      self.ucx.write(oprot)
7515 
      oprot.writeFieldEnd()
7516 
    oprot.writeFieldStop()
7517 
    oprot.writeStructEnd()
7518 
 
3431 rajveer 7519 
  def validate(self):
7520 
    return
7521 
 
7522 
 
1894 vikas 7523 
  def __repr__(self):
7524 
    L = ['%s=%r' % (key, value)
7525 
      for key, value in self.__dict__.iteritems()]
7526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7527 
 
7528 
  def __eq__(self, other):
7529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7530 
 
7531 
  def __ne__(self, other):
7532 
    return not (self == other)
7533 
 
594 rajveer 7534 
class getDefaultAddressId_args:
7535 
  """
7536 
  Attributes:
7537 
   - userId
7538 
  """
7539 
 
7540 
  thrift_spec = (
7541 
    None, # 0
7542 
    (1, TType.I64, 'userId', None, None, ), # 1
7543 
  )
7544 
 
7545 
  def __init__(self, userId=None,):
7546 
    self.userId = userId
7547 
 
7548 
  def read(self, iprot):
7549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7551 
      return
7552 
    iprot.readStructBegin()
7553 
    while True:
7554 
      (fname, ftype, fid) = iprot.readFieldBegin()
7555 
      if ftype == TType.STOP:
7556 
        break
7557 
      if fid == 1:
7558 
        if ftype == TType.I64:
7559 
          self.userId = iprot.readI64();
7560 
        else:
7561 
          iprot.skip(ftype)
7562 
      else:
7563 
        iprot.skip(ftype)
7564 
      iprot.readFieldEnd()
7565 
    iprot.readStructEnd()
7566 
 
7567 
  def write(self, oprot):
7568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7570 
      return
7571 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7572 
    if self.userId is not None:
594 rajveer 7573 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7574 
      oprot.writeI64(self.userId)
7575 
      oprot.writeFieldEnd()
7576 
    oprot.writeFieldStop()
7577 
    oprot.writeStructEnd()
7578 
 
3431 rajveer 7579 
  def validate(self):
7580 
    return
7581 
 
7582 
 
594 rajveer 7583 
  def __repr__(self):
7584 
    L = ['%s=%r' % (key, value)
7585 
      for key, value in self.__dict__.iteritems()]
7586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7587 
 
7588 
  def __eq__(self, other):
7589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7590 
 
7591 
  def __ne__(self, other):
7592 
    return not (self == other)
7593 
 
7594 
class getDefaultAddressId_result:
7595 
  """
7596 
  Attributes:
7597 
   - success
7598 
   - ucx
7599 
  """
7600 
 
7601 
  thrift_spec = (
7602 
    (0, TType.I64, 'success', None, None, ), # 0
7603 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7604 
  )
7605 
 
7606 
  def __init__(self, success=None, ucx=None,):
7607 
    self.success = success
7608 
    self.ucx = ucx
7609 
 
7610 
  def read(self, iprot):
7611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7613 
      return
7614 
    iprot.readStructBegin()
7615 
    while True:
7616 
      (fname, ftype, fid) = iprot.readFieldBegin()
7617 
      if ftype == TType.STOP:
7618 
        break
7619 
      if fid == 0:
7620 
        if ftype == TType.I64:
7621 
          self.success = iprot.readI64();
7622 
        else:
7623 
          iprot.skip(ftype)
7624 
      elif fid == 1:
7625 
        if ftype == TType.STRUCT:
7626 
          self.ucx = UserContextException()
7627 
          self.ucx.read(iprot)
7628 
        else:
7629 
          iprot.skip(ftype)
7630 
      else:
7631 
        iprot.skip(ftype)
7632 
      iprot.readFieldEnd()
7633 
    iprot.readStructEnd()
7634 
 
7635 
  def write(self, oprot):
7636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7638 
      return
7639 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7640 
    if self.success is not None:
594 rajveer 7641 
      oprot.writeFieldBegin('success', TType.I64, 0)
7642 
      oprot.writeI64(self.success)
7643 
      oprot.writeFieldEnd()
3431 rajveer 7644 
    if self.ucx is not None:
594 rajveer 7645 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7646 
      self.ucx.write(oprot)
7647 
      oprot.writeFieldEnd()
7648 
    oprot.writeFieldStop()
7649 
    oprot.writeStructEnd()
7650 
 
3431 rajveer 7651 
  def validate(self):
7652 
    return
7653 
 
7654 
 
594 rajveer 7655 
  def __repr__(self):
7656 
    L = ['%s=%r' % (key, value)
7657 
      for key, value in self.__dict__.iteritems()]
7658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7659 
 
7660 
  def __eq__(self, other):
7661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7662 
 
7663 
  def __ne__(self, other):
7664 
    return not (self == other)
7665 
 
785 rajveer 7666 
class getDefaultPincode_args:
7667 
  """
7668 
  Attributes:
7669 
   - userId
7670 
  """
7671 
 
7672 
  thrift_spec = (
7673 
    None, # 0
7674 
    (1, TType.I64, 'userId', None, None, ), # 1
7675 
  )
7676 
 
7677 
  def __init__(self, userId=None,):
7678 
    self.userId = userId
7679 
 
7680 
  def read(self, iprot):
7681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7683 
      return
7684 
    iprot.readStructBegin()
7685 
    while True:
7686 
      (fname, ftype, fid) = iprot.readFieldBegin()
7687 
      if ftype == TType.STOP:
7688 
        break
7689 
      if fid == 1:
7690 
        if ftype == TType.I64:
7691 
          self.userId = iprot.readI64();
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('getDefaultPincode_args')
3431 rajveer 7704 
    if self.userId is not None:
785 rajveer 7705 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7706 
      oprot.writeI64(self.userId)
7707 
      oprot.writeFieldEnd()
7708 
    oprot.writeFieldStop()
7709 
    oprot.writeStructEnd()
7710 
 
3431 rajveer 7711 
  def validate(self):
7712 
    return
7713 
 
7714 
 
785 rajveer 7715 
  def __repr__(self):
7716 
    L = ['%s=%r' % (key, value)
7717 
      for key, value in self.__dict__.iteritems()]
7718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7719 
 
7720 
  def __eq__(self, other):
7721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7722 
 
7723 
  def __ne__(self, other):
7724 
    return not (self == other)
7725 
 
7726 
class getDefaultPincode_result:
7727 
  """
7728 
  Attributes:
7729 
   - success
7730 
   - ucx
7731 
  """
7732 
 
7733 
  thrift_spec = (
7734 
    (0, TType.STRING, 'success', None, None, ), # 0
7735 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7736 
  )
7737 
 
7738 
  def __init__(self, success=None, ucx=None,):
7739 
    self.success = success
7740 
    self.ucx = ucx
7741 
 
7742 
  def read(self, iprot):
7743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7745 
      return
7746 
    iprot.readStructBegin()
7747 
    while True:
7748 
      (fname, ftype, fid) = iprot.readFieldBegin()
7749 
      if ftype == TType.STOP:
7750 
        break
7751 
      if fid == 0:
7752 
        if ftype == TType.STRING:
7753 
          self.success = iprot.readString();
7754 
        else:
7755 
          iprot.skip(ftype)
7756 
      elif fid == 1:
7757 
        if ftype == TType.STRUCT:
7758 
          self.ucx = UserContextException()
7759 
          self.ucx.read(iprot)
7760 
        else:
7761 
          iprot.skip(ftype)
7762 
      else:
7763 
        iprot.skip(ftype)
7764 
      iprot.readFieldEnd()
7765 
    iprot.readStructEnd()
7766 
 
7767 
  def write(self, oprot):
7768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7770 
      return
7771 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7772 
    if self.success is not None:
785 rajveer 7773 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7774 
      oprot.writeString(self.success)
7775 
      oprot.writeFieldEnd()
3431 rajveer 7776 
    if self.ucx is not None:
785 rajveer 7777 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7778 
      self.ucx.write(oprot)
7779 
      oprot.writeFieldEnd()
7780 
    oprot.writeFieldStop()
7781 
    oprot.writeStructEnd()
7782 
 
3431 rajveer 7783 
  def validate(self):
7784 
    return
7785 
 
7786 
 
785 rajveer 7787 
  def __repr__(self):
7788 
    L = ['%s=%r' % (key, value)
7789 
      for key, value in self.__dict__.iteritems()]
7790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7791 
 
7792 
  def __eq__(self, other):
7793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7794 
 
7795 
  def __ne__(self, other):
7796 
    return not (self == other)
7797 
 
1274 varun.gupt 7798 
class saveUserCommunication_args:
7799 
  """
7800 
  Attributes:
7801 
   - userId
7802 
   - replyTo
7803 
   - communicationType
7804 
   - orderId
7805 
   - airwaybillNo
7806 
   - productName
7807 
   - subject
7808 
   - message
7809 
  """
7810 
 
7811 
  thrift_spec = (
7812 
    None, # 0
7813 
    (1, TType.I64, 'userId', None, None, ), # 1
7814 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7815 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7816 
    (4, TType.I64, 'orderId', None, None, ), # 4
7817 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7818 
    (6, TType.STRING, 'productName', None, None, ), # 6
7819 
    (7, TType.STRING, 'subject', None, None, ), # 7
7820 
    (8, TType.STRING, 'message', None, None, ), # 8
7821 
  )
7822 
 
7823 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7824 
    self.userId = userId
7825 
    self.replyTo = replyTo
7826 
    self.communicationType = communicationType
7827 
    self.orderId = orderId
7828 
    self.airwaybillNo = airwaybillNo
7829 
    self.productName = productName
7830 
    self.subject = subject
7831 
    self.message = message
7832 
 
7833 
  def read(self, iprot):
7834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7836 
      return
7837 
    iprot.readStructBegin()
7838 
    while True:
7839 
      (fname, ftype, fid) = iprot.readFieldBegin()
7840 
      if ftype == TType.STOP:
7841 
        break
7842 
      if fid == 1:
7843 
        if ftype == TType.I64:
7844 
          self.userId = iprot.readI64();
7845 
        else:
7846 
          iprot.skip(ftype)
7847 
      elif fid == 2:
7848 
        if ftype == TType.STRING:
7849 
          self.replyTo = iprot.readString();
7850 
        else:
7851 
          iprot.skip(ftype)
7852 
      elif fid == 3:
7853 
        if ftype == TType.I64:
7854 
          self.communicationType = iprot.readI64();
7855 
        else:
7856 
          iprot.skip(ftype)
7857 
      elif fid == 4:
7858 
        if ftype == TType.I64:
7859 
          self.orderId = iprot.readI64();
7860 
        else:
7861 
          iprot.skip(ftype)
7862 
      elif fid == 5:
7863 
        if ftype == TType.STRING:
7864 
          self.airwaybillNo = iprot.readString();
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      elif fid == 6:
7868 
        if ftype == TType.STRING:
7869 
          self.productName = iprot.readString();
7870 
        else:
7871 
          iprot.skip(ftype)
7872 
      elif fid == 7:
7873 
        if ftype == TType.STRING:
7874 
          self.subject = iprot.readString();
7875 
        else:
7876 
          iprot.skip(ftype)
7877 
      elif fid == 8:
7878 
        if ftype == TType.STRING:
7879 
          self.message = iprot.readString();
7880 
        else:
7881 
          iprot.skip(ftype)
7882 
      else:
7883 
        iprot.skip(ftype)
7884 
      iprot.readFieldEnd()
7885 
    iprot.readStructEnd()
7886 
 
7887 
  def write(self, oprot):
7888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7890 
      return
7891 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7892 
    if self.userId is not None:
1274 varun.gupt 7893 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7894 
      oprot.writeI64(self.userId)
7895 
      oprot.writeFieldEnd()
3431 rajveer 7896 
    if self.replyTo is not None:
1274 varun.gupt 7897 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7898 
      oprot.writeString(self.replyTo)
7899 
      oprot.writeFieldEnd()
3431 rajveer 7900 
    if self.communicationType is not None:
1274 varun.gupt 7901 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7902 
      oprot.writeI64(self.communicationType)
7903 
      oprot.writeFieldEnd()
3431 rajveer 7904 
    if self.orderId is not None:
1274 varun.gupt 7905 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7906 
      oprot.writeI64(self.orderId)
7907 
      oprot.writeFieldEnd()
3431 rajveer 7908 
    if self.airwaybillNo is not None:
1274 varun.gupt 7909 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7910 
      oprot.writeString(self.airwaybillNo)
7911 
      oprot.writeFieldEnd()
3431 rajveer 7912 
    if self.productName is not None:
1274 varun.gupt 7913 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7914 
      oprot.writeString(self.productName)
7915 
      oprot.writeFieldEnd()
3431 rajveer 7916 
    if self.subject is not None:
1274 varun.gupt 7917 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7918 
      oprot.writeString(self.subject)
7919 
      oprot.writeFieldEnd()
3431 rajveer 7920 
    if self.message is not None:
1274 varun.gupt 7921 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7922 
      oprot.writeString(self.message)
7923 
      oprot.writeFieldEnd()
7924 
    oprot.writeFieldStop()
7925 
    oprot.writeStructEnd()
7926 
 
3431 rajveer 7927 
  def validate(self):
7928 
    return
7929 
 
7930 
 
1274 varun.gupt 7931 
  def __repr__(self):
7932 
    L = ['%s=%r' % (key, value)
7933 
      for key, value in self.__dict__.iteritems()]
7934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7935 
 
7936 
  def __eq__(self, other):
7937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7938 
 
7939 
  def __ne__(self, other):
7940 
    return not (self == other)
7941 
 
7942 
class saveUserCommunication_result:
7943 
  """
7944 
  Attributes:
7945 
   - success
7946 
   - ucx
7947 
  """
7948 
 
7949 
  thrift_spec = (
7950 
    (0, TType.BOOL, 'success', None, None, ), # 0
7951 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7952 
  )
7953 
 
7954 
  def __init__(self, success=None, ucx=None,):
7955 
    self.success = success
7956 
    self.ucx = ucx
7957 
 
7958 
  def read(self, iprot):
7959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7961 
      return
7962 
    iprot.readStructBegin()
7963 
    while True:
7964 
      (fname, ftype, fid) = iprot.readFieldBegin()
7965 
      if ftype == TType.STOP:
7966 
        break
7967 
      if fid == 0:
7968 
        if ftype == TType.BOOL:
7969 
          self.success = iprot.readBool();
7970 
        else:
7971 
          iprot.skip(ftype)
7972 
      elif fid == 1:
7973 
        if ftype == TType.STRUCT:
7974 
          self.ucx = UserCommunicationException()
7975 
          self.ucx.read(iprot)
7976 
        else:
7977 
          iprot.skip(ftype)
7978 
      else:
7979 
        iprot.skip(ftype)
7980 
      iprot.readFieldEnd()
7981 
    iprot.readStructEnd()
7982 
 
7983 
  def write(self, oprot):
7984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7986 
      return
7987 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7988 
    if self.success is not None:
1274 varun.gupt 7989 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7990 
      oprot.writeBool(self.success)
7991 
      oprot.writeFieldEnd()
3431 rajveer 7992 
    if self.ucx is not None:
1274 varun.gupt 7993 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7994 
      self.ucx.write(oprot)
7995 
      oprot.writeFieldEnd()
7996 
    oprot.writeFieldStop()
7997 
    oprot.writeStructEnd()
7998 
 
3431 rajveer 7999 
  def validate(self):
8000 
    return
8001 
 
8002 
 
1274 varun.gupt 8003 
  def __repr__(self):
8004 
    L = ['%s=%r' % (key, value)
8005 
      for key, value in self.__dict__.iteritems()]
8006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8007 
 
8008 
  def __eq__(self, other):
8009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8010 
 
8011 
  def __ne__(self, other):
8012 
    return not (self == other)
8013 
 
1590 varun.gupt 8014 
class getUserCommunicationById_args:
8015 
  """
8016 
  Attributes:
8017 
   - id
8018 
  """
8019 
 
8020 
  thrift_spec = (
8021 
    None, # 0
8022 
    (1, TType.I64, 'id', None, None, ), # 1
8023 
  )
8024 
 
8025 
  def __init__(self, id=None,):
8026 
    self.id = id
8027 
 
8028 
  def read(self, iprot):
8029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8031 
      return
8032 
    iprot.readStructBegin()
8033 
    while True:
8034 
      (fname, ftype, fid) = iprot.readFieldBegin()
8035 
      if ftype == TType.STOP:
8036 
        break
8037 
      if fid == 1:
8038 
        if ftype == TType.I64:
8039 
          self.id = iprot.readI64();
8040 
        else:
8041 
          iprot.skip(ftype)
8042 
      else:
8043 
        iprot.skip(ftype)
8044 
      iprot.readFieldEnd()
8045 
    iprot.readStructEnd()
8046 
 
8047 
  def write(self, oprot):
8048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8050 
      return
8051 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8052 
    if self.id is not None:
1590 varun.gupt 8053 
      oprot.writeFieldBegin('id', TType.I64, 1)
8054 
      oprot.writeI64(self.id)
8055 
      oprot.writeFieldEnd()
8056 
    oprot.writeFieldStop()
8057 
    oprot.writeStructEnd()
8058 
 
3431 rajveer 8059 
  def validate(self):
8060 
    return
8061 
 
8062 
 
1590 varun.gupt 8063 
  def __repr__(self):
8064 
    L = ['%s=%r' % (key, value)
8065 
      for key, value in self.__dict__.iteritems()]
8066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8067 
 
8068 
  def __eq__(self, other):
8069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8070 
 
8071 
  def __ne__(self, other):
8072 
    return not (self == other)
8073 
 
8074 
class getUserCommunicationById_result:
8075 
  """
8076 
  Attributes:
8077 
   - success
8078 
   - ucx
8079 
  """
8080 
 
8081 
  thrift_spec = (
8082 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8083 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8084 
  )
8085 
 
8086 
  def __init__(self, success=None, ucx=None,):
8087 
    self.success = success
8088 
    self.ucx = ucx
8089 
 
8090 
  def read(self, iprot):
8091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8093 
      return
8094 
    iprot.readStructBegin()
8095 
    while True:
8096 
      (fname, ftype, fid) = iprot.readFieldBegin()
8097 
      if ftype == TType.STOP:
8098 
        break
8099 
      if fid == 0:
8100 
        if ftype == TType.STRUCT:
8101 
          self.success = UserCommunication()
8102 
          self.success.read(iprot)
8103 
        else:
8104 
          iprot.skip(ftype)
8105 
      elif fid == 1:
8106 
        if ftype == TType.STRUCT:
8107 
          self.ucx = UserCommunicationException()
8108 
          self.ucx.read(iprot)
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      else:
8112 
        iprot.skip(ftype)
8113 
      iprot.readFieldEnd()
8114 
    iprot.readStructEnd()
8115 
 
8116 
  def write(self, oprot):
8117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8119 
      return
8120 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8121 
    if self.success is not None:
1590 varun.gupt 8122 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8123 
      self.success.write(oprot)
8124 
      oprot.writeFieldEnd()
3431 rajveer 8125 
    if self.ucx is not None:
1590 varun.gupt 8126 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8127 
      self.ucx.write(oprot)
8128 
      oprot.writeFieldEnd()
8129 
    oprot.writeFieldStop()
8130 
    oprot.writeStructEnd()
8131 
 
3431 rajveer 8132 
  def validate(self):
8133 
    return
8134 
 
8135 
 
1590 varun.gupt 8136 
  def __repr__(self):
8137 
    L = ['%s=%r' % (key, value)
8138 
      for key, value in self.__dict__.iteritems()]
8139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8140 
 
8141 
  def __eq__(self, other):
8142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8143 
 
8144 
  def __ne__(self, other):
8145 
    return not (self == other)
8146 
 
8147 
class getUserCommunicationByUser_args:
8148 
  """
8149 
  Attributes:
8150 
   - userId
8151 
  """
8152 
 
8153 
  thrift_spec = (
8154 
    None, # 0
8155 
    (1, TType.I64, 'userId', None, None, ), # 1
8156 
  )
8157 
 
8158 
  def __init__(self, userId=None,):
8159 
    self.userId = userId
8160 
 
8161 
  def read(self, iprot):
8162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8164 
      return
8165 
    iprot.readStructBegin()
8166 
    while True:
8167 
      (fname, ftype, fid) = iprot.readFieldBegin()
8168 
      if ftype == TType.STOP:
8169 
        break
8170 
      if fid == 1:
8171 
        if ftype == TType.I64:
8172 
          self.userId = iprot.readI64();
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      else:
8176 
        iprot.skip(ftype)
8177 
      iprot.readFieldEnd()
8178 
    iprot.readStructEnd()
8179 
 
8180 
  def write(self, oprot):
8181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8183 
      return
8184 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8185 
    if self.userId is not None:
1590 varun.gupt 8186 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8187 
      oprot.writeI64(self.userId)
8188 
      oprot.writeFieldEnd()
8189 
    oprot.writeFieldStop()
8190 
    oprot.writeStructEnd()
8191 
 
3431 rajveer 8192 
  def validate(self):
8193 
    return
8194 
 
8195 
 
1590 varun.gupt 8196 
  def __repr__(self):
8197 
    L = ['%s=%r' % (key, value)
8198 
      for key, value in self.__dict__.iteritems()]
8199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8200 
 
8201 
  def __eq__(self, other):
8202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8203 
 
8204 
  def __ne__(self, other):
8205 
    return not (self == other)
8206 
 
8207 
class getUserCommunicationByUser_result:
8208 
  """
8209 
  Attributes:
8210 
   - success
8211 
   - ucx
8212 
  """
8213 
 
8214 
  thrift_spec = (
8215 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8216 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8217 
  )
8218 
 
8219 
  def __init__(self, success=None, ucx=None,):
8220 
    self.success = success
8221 
    self.ucx = ucx
8222 
 
8223 
  def read(self, iprot):
8224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8226 
      return
8227 
    iprot.readStructBegin()
8228 
    while True:
8229 
      (fname, ftype, fid) = iprot.readFieldBegin()
8230 
      if ftype == TType.STOP:
8231 
        break
8232 
      if fid == 0:
8233 
        if ftype == TType.LIST:
8234 
          self.success = []
11592 amit.gupta 8235 
          (_etype107, _size104) = iprot.readListBegin()
8236 
          for _i108 in xrange(_size104):
8237 
            _elem109 = UserCommunication()
8238 
            _elem109.read(iprot)
8239 
            self.success.append(_elem109)
1590 varun.gupt 8240 
          iprot.readListEnd()
8241 
        else:
8242 
          iprot.skip(ftype)
8243 
      elif fid == 1:
8244 
        if ftype == TType.STRUCT:
8245 
          self.ucx = UserCommunicationException()
8246 
          self.ucx.read(iprot)
8247 
        else:
8248 
          iprot.skip(ftype)
8249 
      else:
8250 
        iprot.skip(ftype)
8251 
      iprot.readFieldEnd()
8252 
    iprot.readStructEnd()
8253 
 
8254 
  def write(self, oprot):
8255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8257 
      return
8258 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8259 
    if self.success is not None:
1590 varun.gupt 8260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8261 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8262 
      for iter110 in self.success:
8263 
        iter110.write(oprot)
1590 varun.gupt 8264 
      oprot.writeListEnd()
8265 
      oprot.writeFieldEnd()
3431 rajveer 8266 
    if self.ucx is not None:
1590 varun.gupt 8267 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8268 
      self.ucx.write(oprot)
8269 
      oprot.writeFieldEnd()
8270 
    oprot.writeFieldStop()
8271 
    oprot.writeStructEnd()
8272 
 
3431 rajveer 8273 
  def validate(self):
8274 
    return
8275 
 
8276 
 
1590 varun.gupt 8277 
  def __repr__(self):
8278 
    L = ['%s=%r' % (key, value)
8279 
      for key, value in self.__dict__.iteritems()]
8280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8281 
 
8282 
  def __eq__(self, other):
8283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8284 
 
8285 
  def __ne__(self, other):
8286 
    return not (self == other)
8287 
 
8288 
class getAllUserCommunications_args:
8289 
 
8290 
  thrift_spec = (
8291 
  )
8292 
 
8293 
  def read(self, iprot):
8294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8296 
      return
8297 
    iprot.readStructBegin()
8298 
    while True:
8299 
      (fname, ftype, fid) = iprot.readFieldBegin()
8300 
      if ftype == TType.STOP:
8301 
        break
8302 
      else:
8303 
        iprot.skip(ftype)
8304 
      iprot.readFieldEnd()
8305 
    iprot.readStructEnd()
8306 
 
8307 
  def write(self, oprot):
8308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8310 
      return
8311 
    oprot.writeStructBegin('getAllUserCommunications_args')
8312 
    oprot.writeFieldStop()
8313 
    oprot.writeStructEnd()
8314 
 
3431 rajveer 8315 
  def validate(self):
8316 
    return
8317 
 
8318 
 
1590 varun.gupt 8319 
  def __repr__(self):
8320 
    L = ['%s=%r' % (key, value)
8321 
      for key, value in self.__dict__.iteritems()]
8322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8323 
 
8324 
  def __eq__(self, other):
8325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8326 
 
8327 
  def __ne__(self, other):
8328 
    return not (self == other)
8329 
 
8330 
class getAllUserCommunications_result:
8331 
  """
8332 
  Attributes:
8333 
   - success
8334 
   - ucx
8335 
  """
8336 
 
8337 
  thrift_spec = (
8338 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8339 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8340 
  )
8341 
 
8342 
  def __init__(self, success=None, ucx=None,):
8343 
    self.success = success
8344 
    self.ucx = ucx
8345 
 
8346 
  def read(self, iprot):
8347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8349 
      return
8350 
    iprot.readStructBegin()
8351 
    while True:
8352 
      (fname, ftype, fid) = iprot.readFieldBegin()
8353 
      if ftype == TType.STOP:
8354 
        break
8355 
      if fid == 0:
8356 
        if ftype == TType.LIST:
8357 
          self.success = []
11592 amit.gupta 8358 
          (_etype114, _size111) = iprot.readListBegin()
8359 
          for _i115 in xrange(_size111):
8360 
            _elem116 = UserCommunication()
8361 
            _elem116.read(iprot)
8362 
            self.success.append(_elem116)
1590 varun.gupt 8363 
          iprot.readListEnd()
8364 
        else:
8365 
          iprot.skip(ftype)
8366 
      elif fid == 1:
8367 
        if ftype == TType.STRUCT:
8368 
          self.ucx = UserCommunicationException()
8369 
          self.ucx.read(iprot)
8370 
        else:
8371 
          iprot.skip(ftype)
8372 
      else:
8373 
        iprot.skip(ftype)
8374 
      iprot.readFieldEnd()
8375 
    iprot.readStructEnd()
8376 
 
8377 
  def write(self, oprot):
8378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8380 
      return
8381 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8382 
    if self.success is not None:
1590 varun.gupt 8383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8385 
      for iter117 in self.success:
8386 
        iter117.write(oprot)
1590 varun.gupt 8387 
      oprot.writeListEnd()
8388 
      oprot.writeFieldEnd()
3431 rajveer 8389 
    if self.ucx is not None:
1590 varun.gupt 8390 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8391 
      self.ucx.write(oprot)
8392 
      oprot.writeFieldEnd()
8393 
    oprot.writeFieldStop()
8394 
    oprot.writeStructEnd()
8395 
 
3431 rajveer 8396 
  def validate(self):
8397 
    return
8398 
 
8399 
 
1590 varun.gupt 8400 
  def __repr__(self):
8401 
    L = ['%s=%r' % (key, value)
8402 
      for key, value in self.__dict__.iteritems()]
8403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8404 
 
8405 
  def __eq__(self, other):
8406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8407 
 
8408 
  def __ne__(self, other):
8409 
    return not (self == other)
8410 
 
5407 amar.kumar 8411 
class removeUserCommunication_args:
8412 
  """
8413 
  Attributes:
8414 
   - id
8415 
  """
8416 
 
8417 
  thrift_spec = (
8418 
    None, # 0
8419 
    (1, TType.I64, 'id', None, None, ), # 1
8420 
  )
8421 
 
8422 
  def __init__(self, id=None,):
8423 
    self.id = id
8424 
 
8425 
  def read(self, iprot):
8426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8428 
      return
8429 
    iprot.readStructBegin()
8430 
    while True:
8431 
      (fname, ftype, fid) = iprot.readFieldBegin()
8432 
      if ftype == TType.STOP:
8433 
        break
8434 
      if fid == 1:
8435 
        if ftype == TType.I64:
8436 
          self.id = iprot.readI64();
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      else:
8440 
        iprot.skip(ftype)
8441 
      iprot.readFieldEnd()
8442 
    iprot.readStructEnd()
8443 
 
8444 
  def write(self, oprot):
8445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8447 
      return
8448 
    oprot.writeStructBegin('removeUserCommunication_args')
8449 
    if self.id is not None:
8450 
      oprot.writeFieldBegin('id', TType.I64, 1)
8451 
      oprot.writeI64(self.id)
8452 
      oprot.writeFieldEnd()
8453 
    oprot.writeFieldStop()
8454 
    oprot.writeStructEnd()
8455 
 
8456 
  def validate(self):
8457 
    return
8458 
 
8459 
 
8460 
  def __repr__(self):
8461 
    L = ['%s=%r' % (key, value)
8462 
      for key, value in self.__dict__.iteritems()]
8463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8464 
 
8465 
  def __eq__(self, other):
8466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8467 
 
8468 
  def __ne__(self, other):
8469 
    return not (self == other)
8470 
 
8471 
class removeUserCommunication_result:
8472 
  """
8473 
  Attributes:
8474 
   - ucx
8475 
  """
8476 
 
8477 
  thrift_spec = (
8478 
    None, # 0
8479 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8480 
  )
8481 
 
8482 
  def __init__(self, ucx=None,):
8483 
    self.ucx = ucx
8484 
 
8485 
  def read(self, iprot):
8486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8488 
      return
8489 
    iprot.readStructBegin()
8490 
    while True:
8491 
      (fname, ftype, fid) = iprot.readFieldBegin()
8492 
      if ftype == TType.STOP:
8493 
        break
8494 
      if fid == 1:
8495 
        if ftype == TType.STRUCT:
8496 
          self.ucx = UserCommunicationException()
8497 
          self.ucx.read(iprot)
8498 
        else:
8499 
          iprot.skip(ftype)
8500 
      else:
8501 
        iprot.skip(ftype)
8502 
      iprot.readFieldEnd()
8503 
    iprot.readStructEnd()
8504 
 
8505 
  def write(self, oprot):
8506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8508 
      return
8509 
    oprot.writeStructBegin('removeUserCommunication_result')
8510 
    if self.ucx is not None:
8511 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8512 
      self.ucx.write(oprot)
8513 
      oprot.writeFieldEnd()
8514 
    oprot.writeFieldStop()
8515 
    oprot.writeStructEnd()
8516 
 
8517 
  def validate(self):
8518 
    return
8519 
 
8520 
 
8521 
  def __repr__(self):
8522 
    L = ['%s=%r' % (key, value)
8523 
      for key, value in self.__dict__.iteritems()]
8524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8525 
 
8526 
  def __eq__(self, other):
8527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8528 
 
8529 
  def __ne__(self, other):
8530 
    return not (self == other)
8531 
 
1845 vikas 8532 
class createMasterAffiliate_args:
8533 
  """
8534 
  Attributes:
8535 
   - name
1859 vikas 8536 
   - addedOn
1845 vikas 8537 
  """
8538 
 
8539 
  thrift_spec = (
8540 
    None, # 0
8541 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8542 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8543 
  )
8544 
 
1859 vikas 8545 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8546 
    self.name = name
1859 vikas 8547 
    self.addedOn = addedOn
1845 vikas 8548 
 
8549 
  def read(self, iprot):
8550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8552 
      return
8553 
    iprot.readStructBegin()
8554 
    while True:
8555 
      (fname, ftype, fid) = iprot.readFieldBegin()
8556 
      if ftype == TType.STOP:
8557 
        break
8558 
      if fid == 1:
8559 
        if ftype == TType.STRING:
8560 
          self.name = iprot.readString();
8561 
        else:
8562 
          iprot.skip(ftype)
1859 vikas 8563 
      elif fid == 2:
8564 
        if ftype == TType.I64:
8565 
          self.addedOn = iprot.readI64();
8566 
        else:
8567 
          iprot.skip(ftype)
1845 vikas 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('createMasterAffiliate_args')
3431 rajveer 8578 
    if self.name is not None:
1845 vikas 8579 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8580 
      oprot.writeString(self.name)
8581 
      oprot.writeFieldEnd()
3431 rajveer 8582 
    if self.addedOn is not None:
1859 vikas 8583 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8584 
      oprot.writeI64(self.addedOn)
8585 
      oprot.writeFieldEnd()
1845 vikas 8586 
    oprot.writeFieldStop()
8587 
    oprot.writeStructEnd()
8588 
 
3431 rajveer 8589 
  def validate(self):
8590 
    return
8591 
 
8592 
 
1845 vikas 8593 
  def __repr__(self):
8594 
    L = ['%s=%r' % (key, value)
8595 
      for key, value in self.__dict__.iteritems()]
8596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8597 
 
8598 
  def __eq__(self, other):
8599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8600 
 
8601 
  def __ne__(self, other):
8602 
    return not (self == other)
8603 
 
8604 
class createMasterAffiliate_result:
8605 
  """
8606 
  Attributes:
8607 
   - success
8608 
   - utx
8609 
  """
8610 
 
8611 
  thrift_spec = (
8612 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8613 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8614 
  )
8615 
 
8616 
  def __init__(self, success=None, utx=None,):
8617 
    self.success = success
8618 
    self.utx = utx
8619 
 
8620 
  def read(self, iprot):
8621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8623 
      return
8624 
    iprot.readStructBegin()
8625 
    while True:
8626 
      (fname, ftype, fid) = iprot.readFieldBegin()
8627 
      if ftype == TType.STOP:
8628 
        break
8629 
      if fid == 0:
8630 
        if ftype == TType.STRUCT:
8631 
          self.success = MasterAffiliate()
8632 
          self.success.read(iprot)
8633 
        else:
8634 
          iprot.skip(ftype)
8635 
      elif fid == 1:
8636 
        if ftype == TType.STRUCT:
1996 vikas 8637 
          self.utx = UserAffiliateException()
1845 vikas 8638 
          self.utx.read(iprot)
8639 
        else:
8640 
          iprot.skip(ftype)
8641 
      else:
8642 
        iprot.skip(ftype)
8643 
      iprot.readFieldEnd()
8644 
    iprot.readStructEnd()
8645 
 
8646 
  def write(self, oprot):
8647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8649 
      return
8650 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8651 
    if self.success is not None:
1845 vikas 8652 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8653 
      self.success.write(oprot)
8654 
      oprot.writeFieldEnd()
3431 rajveer 8655 
    if self.utx is not None:
1845 vikas 8656 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8657 
      self.utx.write(oprot)
8658 
      oprot.writeFieldEnd()
8659 
    oprot.writeFieldStop()
8660 
    oprot.writeStructEnd()
8661 
 
3431 rajveer 8662 
  def validate(self):
8663 
    return
8664 
 
8665 
 
1845 vikas 8666 
  def __repr__(self):
8667 
    L = ['%s=%r' % (key, value)
8668 
      for key, value in self.__dict__.iteritems()]
8669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8670 
 
8671 
  def __eq__(self, other):
8672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8673 
 
8674 
  def __ne__(self, other):
8675 
    return not (self == other)
8676 
 
1899 vikas 8677 
class getAllMasterAffiliates_args:
8678 
 
8679 
  thrift_spec = (
8680 
  )
8681 
 
8682 
  def read(self, iprot):
8683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8685 
      return
8686 
    iprot.readStructBegin()
8687 
    while True:
8688 
      (fname, ftype, fid) = iprot.readFieldBegin()
8689 
      if ftype == TType.STOP:
8690 
        break
8691 
      else:
8692 
        iprot.skip(ftype)
8693 
      iprot.readFieldEnd()
8694 
    iprot.readStructEnd()
8695 
 
8696 
  def write(self, oprot):
8697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8699 
      return
8700 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8701 
    oprot.writeFieldStop()
8702 
    oprot.writeStructEnd()
8703 
 
3431 rajveer 8704 
  def validate(self):
8705 
    return
8706 
 
8707 
 
1899 vikas 8708 
  def __repr__(self):
8709 
    L = ['%s=%r' % (key, value)
8710 
      for key, value in self.__dict__.iteritems()]
8711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8712 
 
8713 
  def __eq__(self, other):
8714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8715 
 
8716 
  def __ne__(self, other):
8717 
    return not (self == other)
8718 
 
8719 
class getAllMasterAffiliates_result:
8720 
  """
8721 
  Attributes:
8722 
   - success
8723 
   - utx
8724 
  """
8725 
 
8726 
  thrift_spec = (
8727 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8728 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8729 
  )
8730 
 
8731 
  def __init__(self, success=None, utx=None,):
8732 
    self.success = success
8733 
    self.utx = utx
8734 
 
8735 
  def read(self, iprot):
8736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8738 
      return
8739 
    iprot.readStructBegin()
8740 
    while True:
8741 
      (fname, ftype, fid) = iprot.readFieldBegin()
8742 
      if ftype == TType.STOP:
8743 
        break
8744 
      if fid == 0:
8745 
        if ftype == TType.LIST:
8746 
          self.success = []
11592 amit.gupta 8747 
          (_etype121, _size118) = iprot.readListBegin()
8748 
          for _i122 in xrange(_size118):
8749 
            _elem123 = MasterAffiliate()
8750 
            _elem123.read(iprot)
8751 
            self.success.append(_elem123)
1899 vikas 8752 
          iprot.readListEnd()
8753 
        else:
8754 
          iprot.skip(ftype)
8755 
      elif fid == 1:
8756 
        if ftype == TType.STRUCT:
1996 vikas 8757 
          self.utx = UserAffiliateException()
1899 vikas 8758 
          self.utx.read(iprot)
8759 
        else:
8760 
          iprot.skip(ftype)
8761 
      else:
8762 
        iprot.skip(ftype)
8763 
      iprot.readFieldEnd()
8764 
    iprot.readStructEnd()
8765 
 
8766 
  def write(self, oprot):
8767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8769 
      return
8770 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8771 
    if self.success is not None:
1899 vikas 8772 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8773 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8774 
      for iter124 in self.success:
8775 
        iter124.write(oprot)
1899 vikas 8776 
      oprot.writeListEnd()
8777 
      oprot.writeFieldEnd()
3431 rajveer 8778 
    if self.utx is not None:
1899 vikas 8779 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8780 
      self.utx.write(oprot)
8781 
      oprot.writeFieldEnd()
8782 
    oprot.writeFieldStop()
8783 
    oprot.writeStructEnd()
8784 
 
3431 rajveer 8785 
  def validate(self):
8786 
    return
8787 
 
8788 
 
1899 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 
 
1845 vikas 8800 
class getMasterAffiliateById_args:
8801 
  """
8802 
  Attributes:
8803 
   - id
8804 
  """
8805 
 
8806 
  thrift_spec = (
8807 
    None, # 0
8808 
    (1, TType.I64, 'id', None, None, ), # 1
8809 
  )
8810 
 
8811 
  def __init__(self, id=None,):
8812 
    self.id = id
8813 
 
8814 
  def read(self, iprot):
8815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8817 
      return
8818 
    iprot.readStructBegin()
8819 
    while True:
8820 
      (fname, ftype, fid) = iprot.readFieldBegin()
8821 
      if ftype == TType.STOP:
8822 
        break
8823 
      if fid == 1:
8824 
        if ftype == TType.I64:
8825 
          self.id = iprot.readI64();
8826 
        else:
8827 
          iprot.skip(ftype)
8828 
      else:
8829 
        iprot.skip(ftype)
8830 
      iprot.readFieldEnd()
8831 
    iprot.readStructEnd()
8832 
 
8833 
  def write(self, oprot):
8834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8836 
      return
8837 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8838 
    if self.id is not None:
1845 vikas 8839 
      oprot.writeFieldBegin('id', TType.I64, 1)
8840 
      oprot.writeI64(self.id)
8841 
      oprot.writeFieldEnd()
8842 
    oprot.writeFieldStop()
8843 
    oprot.writeStructEnd()
8844 
 
3431 rajveer 8845 
  def validate(self):
8846 
    return
8847 
 
8848 
 
1845 vikas 8849 
  def __repr__(self):
8850 
    L = ['%s=%r' % (key, value)
8851 
      for key, value in self.__dict__.iteritems()]
8852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8853 
 
8854 
  def __eq__(self, other):
8855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8856 
 
8857 
  def __ne__(self, other):
8858 
    return not (self == other)
8859 
 
8860 
class getMasterAffiliateById_result:
8861 
  """
8862 
  Attributes:
8863 
   - success
8864 
   - utx
8865 
  """
8866 
 
8867 
  thrift_spec = (
8868 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8869 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8870 
  )
8871 
 
8872 
  def __init__(self, success=None, utx=None,):
8873 
    self.success = success
8874 
    self.utx = utx
8875 
 
8876 
  def read(self, iprot):
8877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8879 
      return
8880 
    iprot.readStructBegin()
8881 
    while True:
8882 
      (fname, ftype, fid) = iprot.readFieldBegin()
8883 
      if ftype == TType.STOP:
8884 
        break
8885 
      if fid == 0:
8886 
        if ftype == TType.STRUCT:
8887 
          self.success = MasterAffiliate()
8888 
          self.success.read(iprot)
8889 
        else:
8890 
          iprot.skip(ftype)
8891 
      elif fid == 1:
8892 
        if ftype == TType.STRUCT:
1996 vikas 8893 
          self.utx = UserAffiliateException()
1845 vikas 8894 
          self.utx.read(iprot)
8895 
        else:
8896 
          iprot.skip(ftype)
8897 
      else:
8898 
        iprot.skip(ftype)
8899 
      iprot.readFieldEnd()
8900 
    iprot.readStructEnd()
8901 
 
8902 
  def write(self, oprot):
8903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8905 
      return
8906 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8907 
    if self.success is not None:
1845 vikas 8908 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8909 
      self.success.write(oprot)
8910 
      oprot.writeFieldEnd()
3431 rajveer 8911 
    if self.utx is not None:
1845 vikas 8912 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8913 
      self.utx.write(oprot)
8914 
      oprot.writeFieldEnd()
8915 
    oprot.writeFieldStop()
8916 
    oprot.writeStructEnd()
8917 
 
3431 rajveer 8918 
  def validate(self):
8919 
    return
8920 
 
8921 
 
1845 vikas 8922 
  def __repr__(self):
8923 
    L = ['%s=%r' % (key, value)
8924 
      for key, value in self.__dict__.iteritems()]
8925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8926 
 
8927 
  def __eq__(self, other):
8928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8929 
 
8930 
  def __ne__(self, other):
8931 
    return not (self == other)
8932 
 
8933 
class getMasterAffiliateByName_args:
8934 
  """
8935 
  Attributes:
8936 
   - name
8937 
  """
8938 
 
8939 
  thrift_spec = (
8940 
    None, # 0
8941 
    (1, TType.STRING, 'name', None, None, ), # 1
8942 
  )
8943 
 
8944 
  def __init__(self, name=None,):
8945 
    self.name = name
8946 
 
8947 
  def read(self, iprot):
8948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8950 
      return
8951 
    iprot.readStructBegin()
8952 
    while True:
8953 
      (fname, ftype, fid) = iprot.readFieldBegin()
8954 
      if ftype == TType.STOP:
8955 
        break
8956 
      if fid == 1:
8957 
        if ftype == TType.STRING:
8958 
          self.name = iprot.readString();
8959 
        else:
8960 
          iprot.skip(ftype)
8961 
      else:
8962 
        iprot.skip(ftype)
8963 
      iprot.readFieldEnd()
8964 
    iprot.readStructEnd()
8965 
 
8966 
  def write(self, oprot):
8967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8969 
      return
8970 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8971 
    if self.name is not None:
1845 vikas 8972 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8973 
      oprot.writeString(self.name)
8974 
      oprot.writeFieldEnd()
8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
3431 rajveer 8978 
  def validate(self):
8979 
    return
8980 
 
8981 
 
1845 vikas 8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
8993 
class getMasterAffiliateByName_result:
8994 
  """
8995 
  Attributes:
8996 
   - success
8997 
   - utx
8998 
  """
8999 
 
9000 
  thrift_spec = (
9001 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9002 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9003 
  )
9004 
 
9005 
  def __init__(self, success=None, utx=None,):
9006 
    self.success = success
9007 
    self.utx = utx
9008 
 
9009 
  def read(self, iprot):
9010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9012 
      return
9013 
    iprot.readStructBegin()
9014 
    while True:
9015 
      (fname, ftype, fid) = iprot.readFieldBegin()
9016 
      if ftype == TType.STOP:
9017 
        break
9018 
      if fid == 0:
9019 
        if ftype == TType.STRUCT:
9020 
          self.success = MasterAffiliate()
9021 
          self.success.read(iprot)
9022 
        else:
9023 
          iprot.skip(ftype)
9024 
      elif fid == 1:
9025 
        if ftype == TType.STRUCT:
1996 vikas 9026 
          self.utx = UserAffiliateException()
1845 vikas 9027 
          self.utx.read(iprot)
9028 
        else:
9029 
          iprot.skip(ftype)
9030 
      else:
9031 
        iprot.skip(ftype)
9032 
      iprot.readFieldEnd()
9033 
    iprot.readStructEnd()
9034 
 
9035 
  def write(self, oprot):
9036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9038 
      return
9039 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9040 
    if self.success is not None:
1845 vikas 9041 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9042 
      self.success.write(oprot)
9043 
      oprot.writeFieldEnd()
3431 rajveer 9044 
    if self.utx is not None:
1845 vikas 9045 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9046 
      self.utx.write(oprot)
9047 
      oprot.writeFieldEnd()
9048 
    oprot.writeFieldStop()
9049 
    oprot.writeStructEnd()
9050 
 
3431 rajveer 9051 
  def validate(self):
9052 
    return
9053 
 
9054 
 
1845 vikas 9055 
  def __repr__(self):
9056 
    L = ['%s=%r' % (key, value)
9057 
      for key, value in self.__dict__.iteritems()]
9058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9059 
 
9060 
  def __eq__(self, other):
9061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9062 
 
9063 
  def __ne__(self, other):
9064 
    return not (self == other)
9065 
 
9066 
class createAffiliate_args:
9067 
  """
9068 
  Attributes:
9069 
   - name
9070 
   - url
9071 
   - masterAffiliateId
1859 vikas 9072 
   - addedOn
1845 vikas 9073 
  """
9074 
 
9075 
  thrift_spec = (
9076 
    None, # 0
9077 
    (1, TType.STRING, 'name', None, None, ), # 1
9078 
    (2, TType.STRING, 'url', None, None, ), # 2
9079 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9080 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9081 
  )
9082 
 
1859 vikas 9083 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9084 
    self.name = name
9085 
    self.url = url
9086 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9087 
    self.addedOn = addedOn
1845 vikas 9088 
 
9089 
  def read(self, iprot):
9090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9092 
      return
9093 
    iprot.readStructBegin()
9094 
    while True:
9095 
      (fname, ftype, fid) = iprot.readFieldBegin()
9096 
      if ftype == TType.STOP:
9097 
        break
9098 
      if fid == 1:
9099 
        if ftype == TType.STRING:
9100 
          self.name = iprot.readString();
9101 
        else:
9102 
          iprot.skip(ftype)
9103 
      elif fid == 2:
9104 
        if ftype == TType.STRING:
9105 
          self.url = iprot.readString();
9106 
        else:
9107 
          iprot.skip(ftype)
9108 
      elif fid == 3:
9109 
        if ftype == TType.I64:
9110 
          self.masterAffiliateId = iprot.readI64();
9111 
        else:
9112 
          iprot.skip(ftype)
1859 vikas 9113 
      elif fid == 4:
9114 
        if ftype == TType.I64:
9115 
          self.addedOn = iprot.readI64();
9116 
        else:
9117 
          iprot.skip(ftype)
1845 vikas 9118 
      else:
9119 
        iprot.skip(ftype)
9120 
      iprot.readFieldEnd()
9121 
    iprot.readStructEnd()
9122 
 
9123 
  def write(self, oprot):
9124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9126 
      return
9127 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9128 
    if self.name is not None:
1845 vikas 9129 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9130 
      oprot.writeString(self.name)
9131 
      oprot.writeFieldEnd()
3431 rajveer 9132 
    if self.url is not None:
1845 vikas 9133 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9134 
      oprot.writeString(self.url)
9135 
      oprot.writeFieldEnd()
3431 rajveer 9136 
    if self.masterAffiliateId is not None:
1845 vikas 9137 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9138 
      oprot.writeI64(self.masterAffiliateId)
9139 
      oprot.writeFieldEnd()
3431 rajveer 9140 
    if self.addedOn is not None:
1859 vikas 9141 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9142 
      oprot.writeI64(self.addedOn)
9143 
      oprot.writeFieldEnd()
1845 vikas 9144 
    oprot.writeFieldStop()
9145 
    oprot.writeStructEnd()
9146 
 
3431 rajveer 9147 
  def validate(self):
9148 
    return
9149 
 
9150 
 
1845 vikas 9151 
  def __repr__(self):
9152 
    L = ['%s=%r' % (key, value)
9153 
      for key, value in self.__dict__.iteritems()]
9154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9155 
 
9156 
  def __eq__(self, other):
9157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9158 
 
9159 
  def __ne__(self, other):
9160 
    return not (self == other)
9161 
 
9162 
class createAffiliate_result:
9163 
  """
9164 
  Attributes:
9165 
   - success
9166 
   - utx
9167 
  """
9168 
 
9169 
  thrift_spec = (
9170 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9171 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9172 
  )
9173 
 
9174 
  def __init__(self, success=None, utx=None,):
9175 
    self.success = success
9176 
    self.utx = utx
9177 
 
9178 
  def read(self, iprot):
9179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9181 
      return
9182 
    iprot.readStructBegin()
9183 
    while True:
9184 
      (fname, ftype, fid) = iprot.readFieldBegin()
9185 
      if ftype == TType.STOP:
9186 
        break
9187 
      if fid == 0:
9188 
        if ftype == TType.STRUCT:
9189 
          self.success = Affiliate()
9190 
          self.success.read(iprot)
9191 
        else:
9192 
          iprot.skip(ftype)
9193 
      elif fid == 1:
9194 
        if ftype == TType.STRUCT:
1996 vikas 9195 
          self.utx = UserAffiliateException()
1845 vikas 9196 
          self.utx.read(iprot)
9197 
        else:
9198 
          iprot.skip(ftype)
9199 
      else:
9200 
        iprot.skip(ftype)
9201 
      iprot.readFieldEnd()
9202 
    iprot.readStructEnd()
9203 
 
9204 
  def write(self, oprot):
9205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9207 
      return
9208 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9209 
    if self.success is not None:
1845 vikas 9210 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9211 
      self.success.write(oprot)
9212 
      oprot.writeFieldEnd()
3431 rajveer 9213 
    if self.utx is not None:
1845 vikas 9214 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9215 
      self.utx.write(oprot)
9216 
      oprot.writeFieldEnd()
9217 
    oprot.writeFieldStop()
9218 
    oprot.writeStructEnd()
9219 
 
3431 rajveer 9220 
  def validate(self):
9221 
    return
9222 
 
9223 
 
1845 vikas 9224 
  def __repr__(self):
9225 
    L = ['%s=%r' % (key, value)
9226 
      for key, value in self.__dict__.iteritems()]
9227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9228 
 
9229 
  def __eq__(self, other):
9230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9231 
 
9232 
  def __ne__(self, other):
9233 
    return not (self == other)
9234 
 
9235 
class getAffiliateById_args:
9236 
  """
9237 
  Attributes:
9238 
   - id
9239 
  """
9240 
 
9241 
  thrift_spec = (
9242 
    None, # 0
9243 
    (1, TType.I64, 'id', None, None, ), # 1
9244 
  )
9245 
 
9246 
  def __init__(self, id=None,):
9247 
    self.id = id
9248 
 
9249 
  def read(self, iprot):
9250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9252 
      return
9253 
    iprot.readStructBegin()
9254 
    while True:
9255 
      (fname, ftype, fid) = iprot.readFieldBegin()
9256 
      if ftype == TType.STOP:
9257 
        break
9258 
      if fid == 1:
9259 
        if ftype == TType.I64:
9260 
          self.id = iprot.readI64();
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      else:
9264 
        iprot.skip(ftype)
9265 
      iprot.readFieldEnd()
9266 
    iprot.readStructEnd()
9267 
 
9268 
  def write(self, oprot):
9269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9271 
      return
9272 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9273 
    if self.id is not None:
1845 vikas 9274 
      oprot.writeFieldBegin('id', TType.I64, 1)
9275 
      oprot.writeI64(self.id)
9276 
      oprot.writeFieldEnd()
9277 
    oprot.writeFieldStop()
9278 
    oprot.writeStructEnd()
9279 
 
3431 rajveer 9280 
  def validate(self):
9281 
    return
9282 
 
9283 
 
1845 vikas 9284 
  def __repr__(self):
9285 
    L = ['%s=%r' % (key, value)
9286 
      for key, value in self.__dict__.iteritems()]
9287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9288 
 
9289 
  def __eq__(self, other):
9290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9291 
 
9292 
  def __ne__(self, other):
9293 
    return not (self == other)
9294 
 
9295 
class getAffiliateById_result:
9296 
  """
9297 
  Attributes:
9298 
   - success
9299 
   - utx
9300 
  """
9301 
 
9302 
  thrift_spec = (
9303 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9304 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9305 
  )
9306 
 
9307 
  def __init__(self, success=None, utx=None,):
9308 
    self.success = success
9309 
    self.utx = utx
9310 
 
9311 
  def read(self, iprot):
9312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9314 
      return
9315 
    iprot.readStructBegin()
9316 
    while True:
9317 
      (fname, ftype, fid) = iprot.readFieldBegin()
9318 
      if ftype == TType.STOP:
9319 
        break
9320 
      if fid == 0:
9321 
        if ftype == TType.STRUCT:
9322 
          self.success = Affiliate()
9323 
          self.success.read(iprot)
9324 
        else:
9325 
          iprot.skip(ftype)
9326 
      elif fid == 1:
9327 
        if ftype == TType.STRUCT:
1996 vikas 9328 
          self.utx = UserAffiliateException()
1845 vikas 9329 
          self.utx.read(iprot)
9330 
        else:
9331 
          iprot.skip(ftype)
9332 
      else:
9333 
        iprot.skip(ftype)
9334 
      iprot.readFieldEnd()
9335 
    iprot.readStructEnd()
9336 
 
9337 
  def write(self, oprot):
9338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9340 
      return
9341 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9342 
    if self.success is not None:
1845 vikas 9343 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9344 
      self.success.write(oprot)
9345 
      oprot.writeFieldEnd()
3431 rajveer 9346 
    if self.utx is not None:
1845 vikas 9347 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9348 
      self.utx.write(oprot)
9349 
      oprot.writeFieldEnd()
9350 
    oprot.writeFieldStop()
9351 
    oprot.writeStructEnd()
9352 
 
3431 rajveer 9353 
  def validate(self):
9354 
    return
9355 
 
9356 
 
1845 vikas 9357 
  def __repr__(self):
9358 
    L = ['%s=%r' % (key, value)
9359 
      for key, value in self.__dict__.iteritems()]
9360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9361 
 
9362 
  def __eq__(self, other):
9363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9364 
 
9365 
  def __ne__(self, other):
9366 
    return not (self == other)
9367 
 
9368 
class getAffiliateByName_args:
9369 
  """
9370 
  Attributes:
9371 
   - name
9372 
  """
9373 
 
9374 
  thrift_spec = (
9375 
    None, # 0
9376 
    (1, TType.STRING, 'name', None, None, ), # 1
9377 
  )
9378 
 
9379 
  def __init__(self, name=None,):
9380 
    self.name = name
9381 
 
9382 
  def read(self, iprot):
9383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9385 
      return
9386 
    iprot.readStructBegin()
9387 
    while True:
9388 
      (fname, ftype, fid) = iprot.readFieldBegin()
9389 
      if ftype == TType.STOP:
9390 
        break
9391 
      if fid == 1:
9392 
        if ftype == TType.STRING:
9393 
          self.name = iprot.readString();
9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      else:
9397 
        iprot.skip(ftype)
9398 
      iprot.readFieldEnd()
9399 
    iprot.readStructEnd()
9400 
 
9401 
  def write(self, oprot):
9402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9404 
      return
9405 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9406 
    if self.name is not None:
1845 vikas 9407 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9408 
      oprot.writeString(self.name)
9409 
      oprot.writeFieldEnd()
9410 
    oprot.writeFieldStop()
9411 
    oprot.writeStructEnd()
9412 
 
3431 rajveer 9413 
  def validate(self):
9414 
    return
9415 
 
9416 
 
1845 vikas 9417 
  def __repr__(self):
9418 
    L = ['%s=%r' % (key, value)
9419 
      for key, value in self.__dict__.iteritems()]
9420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9421 
 
9422 
  def __eq__(self, other):
9423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9424 
 
9425 
  def __ne__(self, other):
9426 
    return not (self == other)
9427 
 
9428 
class getAffiliateByName_result:
9429 
  """
9430 
  Attributes:
9431 
   - success
9432 
   - utx
9433 
  """
9434 
 
9435 
  thrift_spec = (
9436 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9437 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9438 
  )
9439 
 
9440 
  def __init__(self, success=None, utx=None,):
9441 
    self.success = success
9442 
    self.utx = utx
9443 
 
9444 
  def read(self, iprot):
9445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9447 
      return
9448 
    iprot.readStructBegin()
9449 
    while True:
9450 
      (fname, ftype, fid) = iprot.readFieldBegin()
9451 
      if ftype == TType.STOP:
9452 
        break
9453 
      if fid == 0:
9454 
        if ftype == TType.STRUCT:
9455 
          self.success = Affiliate()
9456 
          self.success.read(iprot)
9457 
        else:
9458 
          iprot.skip(ftype)
9459 
      elif fid == 1:
9460 
        if ftype == TType.STRUCT:
1996 vikas 9461 
          self.utx = UserAffiliateException()
1845 vikas 9462 
          self.utx.read(iprot)
9463 
        else:
9464 
          iprot.skip(ftype)
9465 
      else:
9466 
        iprot.skip(ftype)
9467 
      iprot.readFieldEnd()
9468 
    iprot.readStructEnd()
9469 
 
9470 
  def write(self, oprot):
9471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9473 
      return
9474 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9475 
    if self.success is not None:
1845 vikas 9476 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9477 
      self.success.write(oprot)
9478 
      oprot.writeFieldEnd()
3431 rajveer 9479 
    if self.utx is not None:
1845 vikas 9480 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9481 
      self.utx.write(oprot)
9482 
      oprot.writeFieldEnd()
9483 
    oprot.writeFieldStop()
9484 
    oprot.writeStructEnd()
9485 
 
3431 rajveer 9486 
  def validate(self):
9487 
    return
9488 
 
9489 
 
1845 vikas 9490 
  def __repr__(self):
9491 
    L = ['%s=%r' % (key, value)
9492 
      for key, value in self.__dict__.iteritems()]
9493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9494 
 
9495 
  def __eq__(self, other):
9496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9497 
 
9498 
  def __ne__(self, other):
9499 
    return not (self == other)
9500 
 
1996 vikas 9501 
class getTrackerById_args:
1845 vikas 9502 
  """
9503 
  Attributes:
9504 
   - id
9505 
  """
9506 
 
9507 
  thrift_spec = (
9508 
    None, # 0
9509 
    (1, TType.I64, 'id', None, None, ), # 1
9510 
  )
9511 
 
9512 
  def __init__(self, id=None,):
9513 
    self.id = id
9514 
 
9515 
  def read(self, iprot):
9516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9518 
      return
9519 
    iprot.readStructBegin()
9520 
    while True:
9521 
      (fname, ftype, fid) = iprot.readFieldBegin()
9522 
      if ftype == TType.STOP:
9523 
        break
9524 
      if fid == 1:
9525 
        if ftype == TType.I64:
9526 
          self.id = iprot.readI64();
9527 
        else:
9528 
          iprot.skip(ftype)
9529 
      else:
9530 
        iprot.skip(ftype)
9531 
      iprot.readFieldEnd()
9532 
    iprot.readStructEnd()
9533 
 
9534 
  def write(self, oprot):
9535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9537 
      return
1996 vikas 9538 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9539 
    if self.id is not None:
1845 vikas 9540 
      oprot.writeFieldBegin('id', TType.I64, 1)
9541 
      oprot.writeI64(self.id)
9542 
      oprot.writeFieldEnd()
9543 
    oprot.writeFieldStop()
9544 
    oprot.writeStructEnd()
9545 
 
3431 rajveer 9546 
  def validate(self):
9547 
    return
9548 
 
9549 
 
1845 vikas 9550 
  def __repr__(self):
9551 
    L = ['%s=%r' % (key, value)
9552 
      for key, value in self.__dict__.iteritems()]
9553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9554 
 
9555 
  def __eq__(self, other):
9556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9557 
 
9558 
  def __ne__(self, other):
9559 
    return not (self == other)
9560 
 
9561 
class getTrackerById_result:
9562 
  """
9563 
  Attributes:
9564 
   - success
9565 
   - utx
9566 
  """
9567 
 
9568 
  thrift_spec = (
9569 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9570 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9571 
  )
9572 
 
9573 
  def __init__(self, success=None, utx=None,):
9574 
    self.success = success
9575 
    self.utx = utx
9576 
 
9577 
  def read(self, iprot):
9578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9580 
      return
9581 
    iprot.readStructBegin()
9582 
    while True:
9583 
      (fname, ftype, fid) = iprot.readFieldBegin()
9584 
      if ftype == TType.STOP:
9585 
        break
9586 
      if fid == 0:
9587 
        if ftype == TType.STRUCT:
9588 
          self.success = Tracker()
9589 
          self.success.read(iprot)
9590 
        else:
9591 
          iprot.skip(ftype)
9592 
      elif fid == 1:
9593 
        if ftype == TType.STRUCT:
1996 vikas 9594 
          self.utx = UserAffiliateException()
1845 vikas 9595 
          self.utx.read(iprot)
9596 
        else:
9597 
          iprot.skip(ftype)
9598 
      else:
9599 
        iprot.skip(ftype)
9600 
      iprot.readFieldEnd()
9601 
    iprot.readStructEnd()
9602 
 
9603 
  def write(self, oprot):
9604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9606 
      return
9607 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9608 
    if self.success is not None:
1845 vikas 9609 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9610 
      self.success.write(oprot)
9611 
      oprot.writeFieldEnd()
3431 rajveer 9612 
    if self.utx is not None:
1845 vikas 9613 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9614 
      self.utx.write(oprot)
9615 
      oprot.writeFieldEnd()
9616 
    oprot.writeFieldStop()
9617 
    oprot.writeStructEnd()
9618 
 
3431 rajveer 9619 
  def validate(self):
9620 
    return
9621 
 
9622 
 
1845 vikas 9623 
  def __repr__(self):
9624 
    L = ['%s=%r' % (key, value)
9625 
      for key, value in self.__dict__.iteritems()]
9626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9627 
 
9628 
  def __eq__(self, other):
9629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9630 
 
9631 
  def __ne__(self, other):
9632 
    return not (self == other)
9633 
 
1996 vikas 9634 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9635 
  """
9636 
  Attributes:
1996 vikas 9637 
   - id
1845 vikas 9638 
  """
9639 
 
9640 
  thrift_spec = (
9641 
    None, # 0
1996 vikas 9642 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9643 
  )
9644 
 
1996 vikas 9645 
  def __init__(self, id=None,):
9646 
    self.id = id
1845 vikas 9647 
 
9648 
  def read(self, iprot):
9649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9651 
      return
9652 
    iprot.readStructBegin()
9653 
    while True:
9654 
      (fname, ftype, fid) = iprot.readFieldBegin()
9655 
      if ftype == TType.STOP:
9656 
        break
9657 
      if fid == 1:
9658 
        if ftype == TType.I64:
1996 vikas 9659 
          self.id = iprot.readI64();
1845 vikas 9660 
        else:
9661 
          iprot.skip(ftype)
9662 
      else:
9663 
        iprot.skip(ftype)
9664 
      iprot.readFieldEnd()
9665 
    iprot.readStructEnd()
9666 
 
9667 
  def write(self, oprot):
9668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9670 
      return
1996 vikas 9671 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9672 
    if self.id is not None:
1996 vikas 9673 
      oprot.writeFieldBegin('id', TType.I64, 1)
9674 
      oprot.writeI64(self.id)
1845 vikas 9675 
      oprot.writeFieldEnd()
9676 
    oprot.writeFieldStop()
9677 
    oprot.writeStructEnd()
9678 
 
3431 rajveer 9679 
  def validate(self):
9680 
    return
9681 
 
9682 
 
1845 vikas 9683 
  def __repr__(self):
9684 
    L = ['%s=%r' % (key, value)
9685 
      for key, value in self.__dict__.iteritems()]
9686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9687 
 
9688 
  def __eq__(self, other):
9689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9690 
 
9691 
  def __ne__(self, other):
9692 
    return not (self == other)
9693 
 
1996 vikas 9694 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9695 
  """
9696 
  Attributes:
9697 
   - success
9698 
   - utx
9699 
  """
9700 
 
9701 
  thrift_spec = (
1996 vikas 9702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9703 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9704 
  )
9705 
 
9706 
  def __init__(self, success=None, utx=None,):
9707 
    self.success = success
9708 
    self.utx = utx
9709 
 
9710 
  def read(self, iprot):
9711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9713 
      return
9714 
    iprot.readStructBegin()
9715 
    while True:
9716 
      (fname, ftype, fid) = iprot.readFieldBegin()
9717 
      if ftype == TType.STOP:
9718 
        break
9719 
      if fid == 0:
9720 
        if ftype == TType.LIST:
9721 
          self.success = []
11592 amit.gupta 9722 
          (_etype128, _size125) = iprot.readListBegin()
9723 
          for _i129 in xrange(_size125):
9724 
            _elem130 = Affiliate()
9725 
            _elem130.read(iprot)
9726 
            self.success.append(_elem130)
1845 vikas 9727 
          iprot.readListEnd()
9728 
        else:
9729 
          iprot.skip(ftype)
9730 
      elif fid == 1:
9731 
        if ftype == TType.STRUCT:
1996 vikas 9732 
          self.utx = UserAffiliateException()
1845 vikas 9733 
          self.utx.read(iprot)
9734 
        else:
9735 
          iprot.skip(ftype)
9736 
      else:
9737 
        iprot.skip(ftype)
9738 
      iprot.readFieldEnd()
9739 
    iprot.readStructEnd()
9740 
 
9741 
  def write(self, oprot):
9742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9744 
      return
1996 vikas 9745 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9746 
    if self.success is not None:
1845 vikas 9747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9749 
      for iter131 in self.success:
9750 
        iter131.write(oprot)
1845 vikas 9751 
      oprot.writeListEnd()
9752 
      oprot.writeFieldEnd()
3431 rajveer 9753 
    if self.utx is not None:
1845 vikas 9754 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9755 
      self.utx.write(oprot)
9756 
      oprot.writeFieldEnd()
9757 
    oprot.writeFieldStop()
9758 
    oprot.writeStructEnd()
9759 
 
3431 rajveer 9760 
  def validate(self):
9761 
    return
9762 
 
9763 
 
1845 vikas 9764 
  def __repr__(self):
9765 
    L = ['%s=%r' % (key, value)
9766 
      for key, value in self.__dict__.iteritems()]
9767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9768 
 
9769 
  def __eq__(self, other):
9770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9771 
 
9772 
  def __ne__(self, other):
9773 
    return not (self == other)
9774 
 
9775 
class addTrackLog_args:
9776 
  """
9777 
  Attributes:
1996 vikas 9778 
   - affiliateId
1845 vikas 9779 
   - userId
9780 
   - event
9781 
   - url
9782 
   - data
1859 vikas 9783 
   - addedOn
1845 vikas 9784 
  """
9785 
 
9786 
  thrift_spec = (
9787 
    None, # 0
1996 vikas 9788 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9789 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9790 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9791 
    (4, TType.STRING, 'url', None, None, ), # 4
9792 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9793 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9794 
  )
9795 
 
1996 vikas 9796 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9797 
    self.affiliateId = affiliateId
1845 vikas 9798 
    self.userId = userId
9799 
    self.event = event
9800 
    self.url = url
9801 
    self.data = data
1859 vikas 9802 
    self.addedOn = addedOn
1845 vikas 9803 
 
9804 
  def read(self, iprot):
9805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9807 
      return
9808 
    iprot.readStructBegin()
9809 
    while True:
9810 
      (fname, ftype, fid) = iprot.readFieldBegin()
9811 
      if ftype == TType.STOP:
9812 
        break
9813 
      if fid == 1:
9814 
        if ftype == TType.I64:
1996 vikas 9815 
          self.affiliateId = iprot.readI64();
1845 vikas 9816 
        else:
9817 
          iprot.skip(ftype)
9818 
      elif fid == 2:
9819 
        if ftype == TType.I64:
9820 
          self.userId = iprot.readI64();
9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      elif fid == 3:
3378 vikas 9824 
        if ftype == TType.I32:
9825 
          self.event = iprot.readI32();
1845 vikas 9826 
        else:
9827 
          iprot.skip(ftype)
9828 
      elif fid == 4:
9829 
        if ftype == TType.STRING:
9830 
          self.url = iprot.readString();
9831 
        else:
9832 
          iprot.skip(ftype)
9833 
      elif fid == 5:
9834 
        if ftype == TType.STRING:
9835 
          self.data = iprot.readString();
9836 
        else:
9837 
          iprot.skip(ftype)
1859 vikas 9838 
      elif fid == 6:
9839 
        if ftype == TType.I64:
9840 
          self.addedOn = iprot.readI64();
9841 
        else:
9842 
          iprot.skip(ftype)
1845 vikas 9843 
      else:
9844 
        iprot.skip(ftype)
9845 
      iprot.readFieldEnd()
9846 
    iprot.readStructEnd()
9847 
 
9848 
  def write(self, oprot):
9849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9851 
      return
9852 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9853 
    if self.affiliateId is not None:
1996 vikas 9854 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9855 
      oprot.writeI64(self.affiliateId)
1845 vikas 9856 
      oprot.writeFieldEnd()
3431 rajveer 9857 
    if self.userId is not None:
1845 vikas 9858 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9859 
      oprot.writeI64(self.userId)
9860 
      oprot.writeFieldEnd()
3431 rajveer 9861 
    if self.event is not None:
3378 vikas 9862 
      oprot.writeFieldBegin('event', TType.I32, 3)
9863 
      oprot.writeI32(self.event)
1845 vikas 9864 
      oprot.writeFieldEnd()
3431 rajveer 9865 
    if self.url is not None:
1845 vikas 9866 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9867 
      oprot.writeString(self.url)
9868 
      oprot.writeFieldEnd()
3431 rajveer 9869 
    if self.data is not None:
1845 vikas 9870 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9871 
      oprot.writeString(self.data)
9872 
      oprot.writeFieldEnd()
3431 rajveer 9873 
    if self.addedOn is not None:
1859 vikas 9874 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9875 
      oprot.writeI64(self.addedOn)
9876 
      oprot.writeFieldEnd()
1845 vikas 9877 
    oprot.writeFieldStop()
9878 
    oprot.writeStructEnd()
9879 
 
3431 rajveer 9880 
  def validate(self):
9881 
    return
9882 
 
9883 
 
1845 vikas 9884 
  def __repr__(self):
9885 
    L = ['%s=%r' % (key, value)
9886 
      for key, value in self.__dict__.iteritems()]
9887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9888 
 
9889 
  def __eq__(self, other):
9890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9891 
 
9892 
  def __ne__(self, other):
9893 
    return not (self == other)
9894 
 
9895 
class addTrackLog_result:
9896 
  """
9897 
  Attributes:
9898 
   - success
9899 
   - utx
9900 
  """
9901 
 
9902 
  thrift_spec = (
9903 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9904 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9905 
  )
9906 
 
9907 
  def __init__(self, success=None, utx=None,):
9908 
    self.success = success
9909 
    self.utx = utx
9910 
 
9911 
  def read(self, iprot):
9912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9914 
      return
9915 
    iprot.readStructBegin()
9916 
    while True:
9917 
      (fname, ftype, fid) = iprot.readFieldBegin()
9918 
      if ftype == TType.STOP:
9919 
        break
9920 
      if fid == 0:
9921 
        if ftype == TType.I64:
9922 
          self.success = iprot.readI64();
9923 
        else:
9924 
          iprot.skip(ftype)
9925 
      elif fid == 1:
9926 
        if ftype == TType.STRUCT:
1996 vikas 9927 
          self.utx = UserAffiliateException()
1845 vikas 9928 
          self.utx.read(iprot)
9929 
        else:
9930 
          iprot.skip(ftype)
9931 
      else:
9932 
        iprot.skip(ftype)
9933 
      iprot.readFieldEnd()
9934 
    iprot.readStructEnd()
9935 
 
9936 
  def write(self, oprot):
9937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9939 
      return
9940 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9941 
    if self.success is not None:
1845 vikas 9942 
      oprot.writeFieldBegin('success', TType.I64, 0)
9943 
      oprot.writeI64(self.success)
9944 
      oprot.writeFieldEnd()
3431 rajveer 9945 
    if self.utx is not None:
1845 vikas 9946 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9947 
      self.utx.write(oprot)
9948 
      oprot.writeFieldEnd()
9949 
    oprot.writeFieldStop()
9950 
    oprot.writeStructEnd()
9951 
 
3431 rajveer 9952 
  def validate(self):
9953 
    return
9954 
 
9955 
 
1845 vikas 9956 
  def __repr__(self):
9957 
    L = ['%s=%r' % (key, value)
9958 
      for key, value in self.__dict__.iteritems()]
9959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9960 
 
9961 
  def __eq__(self, other):
9962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9963 
 
9964 
  def __ne__(self, other):
9965 
    return not (self == other)
9966 
 
9967 
class getTrackLogById_args:
9968 
  """
9969 
  Attributes:
9970 
   - id
9971 
  """
9972 
 
9973 
  thrift_spec = (
9974 
    None, # 0
9975 
    (1, TType.I64, 'id', None, None, ), # 1
9976 
  )
9977 
 
9978 
  def __init__(self, id=None,):
9979 
    self.id = id
9980 
 
9981 
  def read(self, iprot):
9982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9984 
      return
9985 
    iprot.readStructBegin()
9986 
    while True:
9987 
      (fname, ftype, fid) = iprot.readFieldBegin()
9988 
      if ftype == TType.STOP:
9989 
        break
9990 
      if fid == 1:
9991 
        if ftype == TType.I64:
9992 
          self.id = iprot.readI64();
9993 
        else:
9994 
          iprot.skip(ftype)
9995 
      else:
9996 
        iprot.skip(ftype)
9997 
      iprot.readFieldEnd()
9998 
    iprot.readStructEnd()
9999 
 
10000 
  def write(self, oprot):
10001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10003 
      return
10004 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10005 
    if self.id is not None:
1845 vikas 10006 
      oprot.writeFieldBegin('id', TType.I64, 1)
10007 
      oprot.writeI64(self.id)
10008 
      oprot.writeFieldEnd()
10009 
    oprot.writeFieldStop()
10010 
    oprot.writeStructEnd()
10011 
 
3431 rajveer 10012 
  def validate(self):
10013 
    return
10014 
 
10015 
 
1845 vikas 10016 
  def __repr__(self):
10017 
    L = ['%s=%r' % (key, value)
10018 
      for key, value in self.__dict__.iteritems()]
10019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10020 
 
10021 
  def __eq__(self, other):
10022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10023 
 
10024 
  def __ne__(self, other):
10025 
    return not (self == other)
10026 
 
10027 
class getTrackLogById_result:
10028 
  """
10029 
  Attributes:
10030 
   - success
10031 
   - utx
10032 
  """
10033 
 
10034 
  thrift_spec = (
10035 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10036 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10037 
  )
10038 
 
10039 
  def __init__(self, success=None, utx=None,):
10040 
    self.success = success
10041 
    self.utx = utx
10042 
 
10043 
  def read(self, iprot):
10044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10046 
      return
10047 
    iprot.readStructBegin()
10048 
    while True:
10049 
      (fname, ftype, fid) = iprot.readFieldBegin()
10050 
      if ftype == TType.STOP:
10051 
        break
10052 
      if fid == 0:
10053 
        if ftype == TType.STRUCT:
10054 
          self.success = TrackLog()
10055 
          self.success.read(iprot)
10056 
        else:
10057 
          iprot.skip(ftype)
10058 
      elif fid == 1:
10059 
        if ftype == TType.STRUCT:
1996 vikas 10060 
          self.utx = UserAffiliateException()
1845 vikas 10061 
          self.utx.read(iprot)
10062 
        else:
10063 
          iprot.skip(ftype)
10064 
      else:
10065 
        iprot.skip(ftype)
10066 
      iprot.readFieldEnd()
10067 
    iprot.readStructEnd()
10068 
 
10069 
  def write(self, oprot):
10070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10072 
      return
10073 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10074 
    if self.success is not None:
1845 vikas 10075 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10076 
      self.success.write(oprot)
10077 
      oprot.writeFieldEnd()
3431 rajveer 10078 
    if self.utx is not None:
1845 vikas 10079 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10080 
      self.utx.write(oprot)
10081 
      oprot.writeFieldEnd()
10082 
    oprot.writeFieldStop()
10083 
    oprot.writeStructEnd()
10084 
 
3431 rajveer 10085 
  def validate(self):
10086 
    return
10087 
 
10088 
 
1845 vikas 10089 
  def __repr__(self):
10090 
    L = ['%s=%r' % (key, value)
10091 
      for key, value in self.__dict__.iteritems()]
10092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10093 
 
10094 
  def __eq__(self, other):
10095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10096 
 
10097 
  def __ne__(self, other):
10098 
    return not (self == other)
10099 
 
1996 vikas 10100 
class getTrackLogsByAffiliate_args:
1845 vikas 10101 
  """
10102 
  Attributes:
1996 vikas 10103 
   - affiliateId
3293 vikas 10104 
   - startDate
10105 
   - endDate
1845 vikas 10106 
  """
10107 
 
10108 
  thrift_spec = (
10109 
    None, # 0
1996 vikas 10110 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10111 
    (2, TType.I64, 'startDate', None, None, ), # 2
10112 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10113 
  )
10114 
 
3293 vikas 10115 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10116 
    self.affiliateId = affiliateId
3293 vikas 10117 
    self.startDate = startDate
10118 
    self.endDate = endDate
1845 vikas 10119 
 
10120 
  def read(self, iprot):
10121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10123 
      return
10124 
    iprot.readStructBegin()
10125 
    while True:
10126 
      (fname, ftype, fid) = iprot.readFieldBegin()
10127 
      if ftype == TType.STOP:
10128 
        break
10129 
      if fid == 1:
10130 
        if ftype == TType.I64:
1996 vikas 10131 
          self.affiliateId = iprot.readI64();
1845 vikas 10132 
        else:
10133 
          iprot.skip(ftype)
3293 vikas 10134 
      elif fid == 2:
10135 
        if ftype == TType.I64:
10136 
          self.startDate = iprot.readI64();
10137 
        else:
10138 
          iprot.skip(ftype)
10139 
      elif fid == 3:
10140 
        if ftype == TType.I64:
10141 
          self.endDate = iprot.readI64();
10142 
        else:
10143 
          iprot.skip(ftype)
1845 vikas 10144 
      else:
10145 
        iprot.skip(ftype)
10146 
      iprot.readFieldEnd()
10147 
    iprot.readStructEnd()
10148 
 
10149 
  def write(self, oprot):
10150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10152 
      return
1996 vikas 10153 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10154 
    if self.affiliateId is not None:
1996 vikas 10155 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10156 
      oprot.writeI64(self.affiliateId)
1845 vikas 10157 
      oprot.writeFieldEnd()
3431 rajveer 10158 
    if self.startDate is not None:
3293 vikas 10159 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10160 
      oprot.writeI64(self.startDate)
10161 
      oprot.writeFieldEnd()
3431 rajveer 10162 
    if self.endDate is not None:
3293 vikas 10163 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10164 
      oprot.writeI64(self.endDate)
10165 
      oprot.writeFieldEnd()
1845 vikas 10166 
    oprot.writeFieldStop()
10167 
    oprot.writeStructEnd()
10168 
 
3431 rajveer 10169 
  def validate(self):
10170 
    return
10171 
 
10172 
 
1845 vikas 10173 
  def __repr__(self):
10174 
    L = ['%s=%r' % (key, value)
10175 
      for key, value in self.__dict__.iteritems()]
10176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10177 
 
10178 
  def __eq__(self, other):
10179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10180 
 
10181 
  def __ne__(self, other):
10182 
    return not (self == other)
10183 
 
1996 vikas 10184 
class getTrackLogsByAffiliate_result:
1845 vikas 10185 
  """
10186 
  Attributes:
10187 
   - success
10188 
   - utx
10189 
  """
10190 
 
10191 
  thrift_spec = (
10192 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10193 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10194 
  )
10195 
 
10196 
  def __init__(self, success=None, utx=None,):
10197 
    self.success = success
10198 
    self.utx = utx
10199 
 
10200 
  def read(self, iprot):
10201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10203 
      return
10204 
    iprot.readStructBegin()
10205 
    while True:
10206 
      (fname, ftype, fid) = iprot.readFieldBegin()
10207 
      if ftype == TType.STOP:
10208 
        break
10209 
      if fid == 0:
10210 
        if ftype == TType.LIST:
10211 
          self.success = []
11592 amit.gupta 10212 
          (_etype135, _size132) = iprot.readListBegin()
10213 
          for _i136 in xrange(_size132):
10214 
            _elem137 = TrackLog()
10215 
            _elem137.read(iprot)
10216 
            self.success.append(_elem137)
1845 vikas 10217 
          iprot.readListEnd()
10218 
        else:
10219 
          iprot.skip(ftype)
10220 
      elif fid == 1:
10221 
        if ftype == TType.STRUCT:
1996 vikas 10222 
          self.utx = UserAffiliateException()
1845 vikas 10223 
          self.utx.read(iprot)
10224 
        else:
10225 
          iprot.skip(ftype)
10226 
      else:
10227 
        iprot.skip(ftype)
10228 
      iprot.readFieldEnd()
10229 
    iprot.readStructEnd()
10230 
 
10231 
  def write(self, oprot):
10232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10234 
      return
1996 vikas 10235 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10236 
    if self.success is not None:
1845 vikas 10237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10238 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10239 
      for iter138 in self.success:
10240 
        iter138.write(oprot)
1845 vikas 10241 
      oprot.writeListEnd()
10242 
      oprot.writeFieldEnd()
3431 rajveer 10243 
    if self.utx is not None:
1845 vikas 10244 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10245 
      self.utx.write(oprot)
10246 
      oprot.writeFieldEnd()
10247 
    oprot.writeFieldStop()
10248 
    oprot.writeStructEnd()
10249 
 
3431 rajveer 10250 
  def validate(self):
10251 
    return
10252 
 
10253 
 
1845 vikas 10254 
  def __repr__(self):
10255 
    L = ['%s=%r' % (key, value)
10256 
      for key, value in self.__dict__.iteritems()]
10257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10258 
 
10259 
  def __eq__(self, other):
10260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10261 
 
10262 
  def __ne__(self, other):
10263 
    return not (self == other)
10264 
 
10265 
class getTrackLogsByUser_args:
10266 
  """
10267 
  Attributes:
10268 
   - userId
10269 
  """
10270 
 
10271 
  thrift_spec = (
10272 
    None, # 0
10273 
    (1, TType.I64, 'userId', None, None, ), # 1
10274 
  )
10275 
 
10276 
  def __init__(self, userId=None,):
10277 
    self.userId = userId
10278 
 
10279 
  def read(self, iprot):
10280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10282 
      return
10283 
    iprot.readStructBegin()
10284 
    while True:
10285 
      (fname, ftype, fid) = iprot.readFieldBegin()
10286 
      if ftype == TType.STOP:
10287 
        break
10288 
      if fid == 1:
10289 
        if ftype == TType.I64:
10290 
          self.userId = iprot.readI64();
10291 
        else:
10292 
          iprot.skip(ftype)
10293 
      else:
10294 
        iprot.skip(ftype)
10295 
      iprot.readFieldEnd()
10296 
    iprot.readStructEnd()
10297 
 
10298 
  def write(self, oprot):
10299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10301 
      return
10302 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10303 
    if self.userId is not None:
1845 vikas 10304 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10305 
      oprot.writeI64(self.userId)
10306 
      oprot.writeFieldEnd()
10307 
    oprot.writeFieldStop()
10308 
    oprot.writeStructEnd()
10309 
 
3431 rajveer 10310 
  def validate(self):
10311 
    return
10312 
 
10313 
 
1845 vikas 10314 
  def __repr__(self):
10315 
    L = ['%s=%r' % (key, value)
10316 
      for key, value in self.__dict__.iteritems()]
10317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10318 
 
10319 
  def __eq__(self, other):
10320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10321 
 
10322 
  def __ne__(self, other):
10323 
    return not (self == other)
10324 
 
10325 
class getTrackLogsByUser_result:
10326 
  """
10327 
  Attributes:
10328 
   - success
10329 
   - utx
10330 
  """
10331 
 
10332 
  thrift_spec = (
10333 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10334 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10335 
  )
10336 
 
10337 
  def __init__(self, success=None, utx=None,):
10338 
    self.success = success
10339 
    self.utx = utx
10340 
 
10341 
  def read(self, iprot):
10342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10344 
      return
10345 
    iprot.readStructBegin()
10346 
    while True:
10347 
      (fname, ftype, fid) = iprot.readFieldBegin()
10348 
      if ftype == TType.STOP:
10349 
        break
10350 
      if fid == 0:
10351 
        if ftype == TType.LIST:
10352 
          self.success = []
11592 amit.gupta 10353 
          (_etype142, _size139) = iprot.readListBegin()
10354 
          for _i143 in xrange(_size139):
10355 
            _elem144 = TrackLog()
10356 
            _elem144.read(iprot)
10357 
            self.success.append(_elem144)
1845 vikas 10358 
          iprot.readListEnd()
10359 
        else:
10360 
          iprot.skip(ftype)
10361 
      elif fid == 1:
10362 
        if ftype == TType.STRUCT:
1996 vikas 10363 
          self.utx = UserAffiliateException()
1845 vikas 10364 
          self.utx.read(iprot)
10365 
        else:
10366 
          iprot.skip(ftype)
10367 
      else:
10368 
        iprot.skip(ftype)
10369 
      iprot.readFieldEnd()
10370 
    iprot.readStructEnd()
10371 
 
10372 
  def write(self, oprot):
10373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10375 
      return
10376 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10377 
    if self.success is not None:
1845 vikas 10378 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10379 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10380 
      for iter145 in self.success:
10381 
        iter145.write(oprot)
1845 vikas 10382 
      oprot.writeListEnd()
10383 
      oprot.writeFieldEnd()
3431 rajveer 10384 
    if self.utx is not None:
1845 vikas 10385 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10386 
      self.utx.write(oprot)
10387 
      oprot.writeFieldEnd()
10388 
    oprot.writeFieldStop()
10389 
    oprot.writeStructEnd()
10390 
 
3431 rajveer 10391 
  def validate(self):
10392 
    return
10393 
 
10394 
 
1845 vikas 10395 
  def __repr__(self):
10396 
    L = ['%s=%r' % (key, value)
10397 
      for key, value in self.__dict__.iteritems()]
10398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10399 
 
10400 
  def __eq__(self, other):
10401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10402 
 
10403 
  def __ne__(self, other):
10404 
    return not (self == other)
10405 
 
10406 
class getTrackLogs_args:
10407 
  """
10408 
  Attributes:
10409 
   - userId
10410 
   - event
10411 
   - url
10412 
  """
10413 
 
10414 
  thrift_spec = (
10415 
    None, # 0
1996 vikas 10416 
    (1, TType.I64, 'userId', None, None, ), # 1
10417 
    (2, TType.STRING, 'event', None, None, ), # 2
10418 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10419 
  )
10420 
 
1996 vikas 10421 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10422 
    self.userId = userId
10423 
    self.event = event
10424 
    self.url = url
10425 
 
10426 
  def read(self, iprot):
10427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10429 
      return
10430 
    iprot.readStructBegin()
10431 
    while True:
10432 
      (fname, ftype, fid) = iprot.readFieldBegin()
10433 
      if ftype == TType.STOP:
10434 
        break
10435 
      if fid == 1:
10436 
        if ftype == TType.I64:
1996 vikas 10437 
          self.userId = iprot.readI64();
1845 vikas 10438 
        else:
10439 
          iprot.skip(ftype)
10440 
      elif fid == 2:
10441 
        if ftype == TType.STRING:
10442 
          self.event = iprot.readString();
10443 
        else:
10444 
          iprot.skip(ftype)
1996 vikas 10445 
      elif fid == 3:
1845 vikas 10446 
        if ftype == TType.STRING:
10447 
          self.url = iprot.readString();
10448 
        else:
10449 
          iprot.skip(ftype)
10450 
      else:
10451 
        iprot.skip(ftype)
10452 
      iprot.readFieldEnd()
10453 
    iprot.readStructEnd()
10454 
 
10455 
  def write(self, oprot):
10456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10458 
      return
10459 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10460 
    if self.userId is not None:
1996 vikas 10461 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10462 
      oprot.writeI64(self.userId)
10463 
      oprot.writeFieldEnd()
3431 rajveer 10464 
    if self.event is not None:
1996 vikas 10465 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10466 
      oprot.writeString(self.event)
10467 
      oprot.writeFieldEnd()
3431 rajveer 10468 
    if self.url is not None:
1996 vikas 10469 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10470 
      oprot.writeString(self.url)
10471 
      oprot.writeFieldEnd()
10472 
    oprot.writeFieldStop()
10473 
    oprot.writeStructEnd()
10474 
 
3431 rajveer 10475 
  def validate(self):
10476 
    return
10477 
 
10478 
 
1845 vikas 10479 
  def __repr__(self):
10480 
    L = ['%s=%r' % (key, value)
10481 
      for key, value in self.__dict__.iteritems()]
10482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10483 
 
10484 
  def __eq__(self, other):
10485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10486 
 
10487 
  def __ne__(self, other):
10488 
    return not (self == other)
10489 
 
10490 
class getTrackLogs_result:
10491 
  """
10492 
  Attributes:
10493 
   - success
10494 
   - utx
10495 
  """
10496 
 
10497 
  thrift_spec = (
10498 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10499 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10500 
  )
10501 
 
10502 
  def __init__(self, success=None, utx=None,):
10503 
    self.success = success
10504 
    self.utx = utx
10505 
 
10506 
  def read(self, iprot):
10507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10509 
      return
10510 
    iprot.readStructBegin()
10511 
    while True:
10512 
      (fname, ftype, fid) = iprot.readFieldBegin()
10513 
      if ftype == TType.STOP:
10514 
        break
10515 
      if fid == 0:
10516 
        if ftype == TType.LIST:
10517 
          self.success = []
11592 amit.gupta 10518 
          (_etype149, _size146) = iprot.readListBegin()
10519 
          for _i150 in xrange(_size146):
10520 
            _elem151 = TrackLog()
10521 
            _elem151.read(iprot)
10522 
            self.success.append(_elem151)
1845 vikas 10523 
          iprot.readListEnd()
10524 
        else:
10525 
          iprot.skip(ftype)
10526 
      elif fid == 1:
10527 
        if ftype == TType.STRUCT:
1996 vikas 10528 
          self.utx = UserAffiliateException()
1845 vikas 10529 
          self.utx.read(iprot)
10530 
        else:
10531 
          iprot.skip(ftype)
10532 
      else:
10533 
        iprot.skip(ftype)
10534 
      iprot.readFieldEnd()
10535 
    iprot.readStructEnd()
10536 
 
10537 
  def write(self, oprot):
10538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10540 
      return
10541 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10542 
    if self.success is not None:
1845 vikas 10543 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10544 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10545 
      for iter152 in self.success:
10546 
        iter152.write(oprot)
1845 vikas 10547 
      oprot.writeListEnd()
10548 
      oprot.writeFieldEnd()
3431 rajveer 10549 
    if self.utx is not None:
1845 vikas 10550 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10551 
      self.utx.write(oprot)
10552 
      oprot.writeFieldEnd()
10553 
    oprot.writeFieldStop()
10554 
    oprot.writeStructEnd()
10555 
 
3431 rajveer 10556 
  def validate(self):
10557 
    return
10558 
 
10559 
 
1845 vikas 10560 
  def __repr__(self):
10561 
    L = ['%s=%r' % (key, value)
10562 
      for key, value in self.__dict__.iteritems()]
10563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10564 
 
10565 
  def __eq__(self, other):
10566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10567 
 
10568 
  def __ne__(self, other):
10569 
    return not (self == other)
10570 
 
559 chandransh 10571 
class getCurrentCart_args:
94 ashish 10572 
  """
10573 
  Attributes:
559 chandransh 10574 
   - userId
10575 
  """
10576 
 
10577 
  thrift_spec = (
10578 
    None, # 0
10579 
    (1, TType.I64, 'userId', None, None, ), # 1
10580 
  )
10581 
 
10582 
  def __init__(self, userId=None,):
10583 
    self.userId = userId
10584 
 
10585 
  def read(self, iprot):
10586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10588 
      return
10589 
    iprot.readStructBegin()
10590 
    while True:
10591 
      (fname, ftype, fid) = iprot.readFieldBegin()
10592 
      if ftype == TType.STOP:
10593 
        break
10594 
      if fid == 1:
10595 
        if ftype == TType.I64:
10596 
          self.userId = iprot.readI64();
10597 
        else:
10598 
          iprot.skip(ftype)
10599 
      else:
10600 
        iprot.skip(ftype)
10601 
      iprot.readFieldEnd()
10602 
    iprot.readStructEnd()
10603 
 
10604 
  def write(self, oprot):
10605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10607 
      return
10608 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10609 
    if self.userId is not None:
559 chandransh 10610 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10611 
      oprot.writeI64(self.userId)
10612 
      oprot.writeFieldEnd()
10613 
    oprot.writeFieldStop()
10614 
    oprot.writeStructEnd()
10615 
 
3431 rajveer 10616 
  def validate(self):
10617 
    return
10618 
 
10619 
 
559 chandransh 10620 
  def __repr__(self):
10621 
    L = ['%s=%r' % (key, value)
10622 
      for key, value in self.__dict__.iteritems()]
10623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10624 
 
10625 
  def __eq__(self, other):
10626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10627 
 
10628 
  def __ne__(self, other):
10629 
    return not (self == other)
10630 
 
10631 
class getCurrentCart_result:
10632 
  """
10633 
  Attributes:
94 ashish 10634 
   - success
559 chandransh 10635 
   - scx
94 ashish 10636 
  """
10637 
 
10638 
  thrift_spec = (
559 chandransh 10639 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10640 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10641 
  )
10642 
 
559 chandransh 10643 
  def __init__(self, success=None, scx=None,):
94 ashish 10644 
    self.success = success
559 chandransh 10645 
    self.scx = scx
94 ashish 10646 
 
10647 
  def read(self, iprot):
10648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10650 
      return
10651 
    iprot.readStructBegin()
10652 
    while True:
10653 
      (fname, ftype, fid) = iprot.readFieldBegin()
10654 
      if ftype == TType.STOP:
10655 
        break
10656 
      if fid == 0:
559 chandransh 10657 
        if ftype == TType.STRUCT:
10658 
          self.success = Cart()
10659 
          self.success.read(iprot)
94 ashish 10660 
        else:
10661 
          iprot.skip(ftype)
10662 
      elif fid == 1:
10663 
        if ftype == TType.STRUCT:
559 chandransh 10664 
          self.scx = ShoppingCartException()
10665 
          self.scx.read(iprot)
94 ashish 10666 
        else:
10667 
          iprot.skip(ftype)
10668 
      else:
10669 
        iprot.skip(ftype)
10670 
      iprot.readFieldEnd()
10671 
    iprot.readStructEnd()
10672 
 
10673 
  def write(self, oprot):
10674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10676 
      return
559 chandransh 10677 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10678 
    if self.success is not None:
559 chandransh 10679 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10680 
      self.success.write(oprot)
94 ashish 10681 
      oprot.writeFieldEnd()
3431 rajveer 10682 
    if self.scx is not None:
559 chandransh 10683 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10684 
      self.scx.write(oprot)
94 ashish 10685 
      oprot.writeFieldEnd()
10686 
    oprot.writeFieldStop()
10687 
    oprot.writeStructEnd()
10688 
 
3431 rajveer 10689 
  def validate(self):
10690 
    return
10691 
 
10692 
 
94 ashish 10693 
  def __repr__(self):
10694 
    L = ['%s=%r' % (key, value)
10695 
      for key, value in self.__dict__.iteritems()]
10696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10697 
 
10698 
  def __eq__(self, other):
10699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10700 
 
10701 
  def __ne__(self, other):
10702 
    return not (self == other)
10703 
 
559 chandransh 10704 
class getCart_args:
504 rajveer 10705 
  """
10706 
  Attributes:
559 chandransh 10707 
   - cartId
504 rajveer 10708 
  """
10709 
 
10710 
  thrift_spec = (
10711 
    None, # 0
559 chandransh 10712 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10713 
  )
10714 
 
559 chandransh 10715 
  def __init__(self, cartId=None,):
10716 
    self.cartId = cartId
504 rajveer 10717 
 
10718 
  def read(self, iprot):
10719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10721 
      return
10722 
    iprot.readStructBegin()
10723 
    while True:
10724 
      (fname, ftype, fid) = iprot.readFieldBegin()
10725 
      if ftype == TType.STOP:
10726 
        break
10727 
      if fid == 1:
10728 
        if ftype == TType.I64:
559 chandransh 10729 
          self.cartId = iprot.readI64();
504 rajveer 10730 
        else:
10731 
          iprot.skip(ftype)
10732 
      else:
10733 
        iprot.skip(ftype)
10734 
      iprot.readFieldEnd()
10735 
    iprot.readStructEnd()
10736 
 
10737 
  def write(self, oprot):
10738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10740 
      return
559 chandransh 10741 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10742 
    if self.cartId is not None:
559 chandransh 10743 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10744 
      oprot.writeI64(self.cartId)
504 rajveer 10745 
      oprot.writeFieldEnd()
10746 
    oprot.writeFieldStop()
10747 
    oprot.writeStructEnd()
10748 
 
3431 rajveer 10749 
  def validate(self):
10750 
    return
10751 
 
10752 
 
504 rajveer 10753 
  def __repr__(self):
10754 
    L = ['%s=%r' % (key, value)
10755 
      for key, value in self.__dict__.iteritems()]
10756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10757 
 
10758 
  def __eq__(self, other):
10759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10760 
 
10761 
  def __ne__(self, other):
10762 
    return not (self == other)
10763 
 
559 chandransh 10764 
class getCart_result:
504 rajveer 10765 
  """
10766 
  Attributes:
10767 
   - success
559 chandransh 10768 
   - scx
504 rajveer 10769 
  """
10770 
 
10771 
  thrift_spec = (
559 chandransh 10772 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10773 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10774 
  )
10775 
 
559 chandransh 10776 
  def __init__(self, success=None, scx=None,):
504 rajveer 10777 
    self.success = success
559 chandransh 10778 
    self.scx = scx
504 rajveer 10779 
 
10780 
  def read(self, iprot):
10781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10783 
      return
10784 
    iprot.readStructBegin()
10785 
    while True:
10786 
      (fname, ftype, fid) = iprot.readFieldBegin()
10787 
      if ftype == TType.STOP:
10788 
        break
10789 
      if fid == 0:
559 chandransh 10790 
        if ftype == TType.STRUCT:
10791 
          self.success = Cart()
10792 
          self.success.read(iprot)
504 rajveer 10793 
        else:
10794 
          iprot.skip(ftype)
10795 
      elif fid == 1:
10796 
        if ftype == TType.STRUCT:
559 chandransh 10797 
          self.scx = ShoppingCartException()
10798 
          self.scx.read(iprot)
504 rajveer 10799 
        else:
10800 
          iprot.skip(ftype)
10801 
      else:
10802 
        iprot.skip(ftype)
10803 
      iprot.readFieldEnd()
10804 
    iprot.readStructEnd()
10805 
 
10806 
  def write(self, oprot):
10807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10809 
      return
559 chandransh 10810 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10811 
    if self.success is not None:
559 chandransh 10812 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10813 
      self.success.write(oprot)
504 rajveer 10814 
      oprot.writeFieldEnd()
3431 rajveer 10815 
    if self.scx is not None:
559 chandransh 10816 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10817 
      self.scx.write(oprot)
504 rajveer 10818 
      oprot.writeFieldEnd()
10819 
    oprot.writeFieldStop()
10820 
    oprot.writeStructEnd()
10821 
 
3431 rajveer 10822 
  def validate(self):
10823 
    return
10824 
 
10825 
 
504 rajveer 10826 
  def __repr__(self):
10827 
    L = ['%s=%r' % (key, value)
10828 
      for key, value in self.__dict__.iteritems()]
10829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10830 
 
10831 
  def __eq__(self, other):
10832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10833 
 
10834 
  def __ne__(self, other):
10835 
    return not (self == other)
10836 
 
559 chandransh 10837 
class getCartsByTime_args:
10838 
  """
10839 
  Attributes:
10840 
   - from_time
10841 
   - to_time
10842 
   - status
10843 
  """
10844 
 
10845 
  thrift_spec = (
10846 
    None, # 0
10847 
    (1, TType.I64, 'from_time', None, None, ), # 1
10848 
    (2, TType.I64, 'to_time', None, None, ), # 2
10849 
    (3, TType.I32, 'status', None, None, ), # 3
10850 
  )
10851 
 
10852 
  def __init__(self, from_time=None, to_time=None, status=None,):
10853 
    self.from_time = from_time
10854 
    self.to_time = to_time
10855 
    self.status = status
10856 
 
10857 
  def read(self, iprot):
10858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10860 
      return
10861 
    iprot.readStructBegin()
10862 
    while True:
10863 
      (fname, ftype, fid) = iprot.readFieldBegin()
10864 
      if ftype == TType.STOP:
10865 
        break
10866 
      if fid == 1:
94 ashish 10867 
        if ftype == TType.I64:
559 chandransh 10868 
          self.from_time = iprot.readI64();
94 ashish 10869 
        else:
10870 
          iprot.skip(ftype)
122 ashish 10871 
      elif fid == 2:
559 chandransh 10872 
        if ftype == TType.I64:
10873 
          self.to_time = iprot.readI64();
122 ashish 10874 
        else:
10875 
          iprot.skip(ftype)
559 chandransh 10876 
      elif fid == 3:
10877 
        if ftype == TType.I32:
10878 
          self.status = iprot.readI32();
10879 
        else:
10880 
          iprot.skip(ftype)
94 ashish 10881 
      else:
10882 
        iprot.skip(ftype)
10883 
      iprot.readFieldEnd()
10884 
    iprot.readStructEnd()
10885 
 
10886 
  def write(self, oprot):
10887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10889 
      return
559 chandransh 10890 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10891 
    if self.from_time is not None:
559 chandransh 10892 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10893 
      oprot.writeI64(self.from_time)
94 ashish 10894 
      oprot.writeFieldEnd()
3431 rajveer 10895 
    if self.to_time is not None:
559 chandransh 10896 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10897 
      oprot.writeI64(self.to_time)
122 ashish 10898 
      oprot.writeFieldEnd()
3431 rajveer 10899 
    if self.status is not None:
559 chandransh 10900 
      oprot.writeFieldBegin('status', TType.I32, 3)
10901 
      oprot.writeI32(self.status)
10902 
      oprot.writeFieldEnd()
94 ashish 10903 
    oprot.writeFieldStop()
10904 
    oprot.writeStructEnd()
10905 
 
3431 rajveer 10906 
  def validate(self):
10907 
    return
10908 
 
10909 
 
94 ashish 10910 
  def __repr__(self):
10911 
    L = ['%s=%r' % (key, value)
10912 
      for key, value in self.__dict__.iteritems()]
10913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10914 
 
10915 
  def __eq__(self, other):
10916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10917 
 
10918 
  def __ne__(self, other):
10919 
    return not (self == other)
10920 
 
559 chandransh 10921 
class getCartsByTime_result:
94 ashish 10922 
  """
10923 
  Attributes:
10924 
   - success
559 chandransh 10925 
   - scx
94 ashish 10926 
  """
10927 
 
10928 
  thrift_spec = (
559 chandransh 10929 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10930 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10931 
  )
10932 
 
559 chandransh 10933 
  def __init__(self, success=None, scx=None,):
94 ashish 10934 
    self.success = success
559 chandransh 10935 
    self.scx = scx
94 ashish 10936 
 
10937 
  def read(self, iprot):
10938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10940 
      return
10941 
    iprot.readStructBegin()
10942 
    while True:
10943 
      (fname, ftype, fid) = iprot.readFieldBegin()
10944 
      if ftype == TType.STOP:
10945 
        break
10946 
      if fid == 0:
559 chandransh 10947 
        if ftype == TType.LIST:
10948 
          self.success = []
11592 amit.gupta 10949 
          (_etype156, _size153) = iprot.readListBegin()
10950 
          for _i157 in xrange(_size153):
10951 
            _elem158 = Cart()
10952 
            _elem158.read(iprot)
10953 
            self.success.append(_elem158)
559 chandransh 10954 
          iprot.readListEnd()
94 ashish 10955 
        else:
10956 
          iprot.skip(ftype)
10957 
      elif fid == 1:
10958 
        if ftype == TType.STRUCT:
559 chandransh 10959 
          self.scx = ShoppingCartException()
10960 
          self.scx.read(iprot)
94 ashish 10961 
        else:
10962 
          iprot.skip(ftype)
10963 
      else:
10964 
        iprot.skip(ftype)
10965 
      iprot.readFieldEnd()
10966 
    iprot.readStructEnd()
10967 
 
10968 
  def write(self, oprot):
10969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10971 
      return
559 chandransh 10972 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10973 
    if self.success is not None:
559 chandransh 10974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10976 
      for iter159 in self.success:
10977 
        iter159.write(oprot)
559 chandransh 10978 
      oprot.writeListEnd()
94 ashish 10979 
      oprot.writeFieldEnd()
3431 rajveer 10980 
    if self.scx is not None:
559 chandransh 10981 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10982 
      self.scx.write(oprot)
94 ashish 10983 
      oprot.writeFieldEnd()
10984 
    oprot.writeFieldStop()
10985 
    oprot.writeStructEnd()
10986 
 
3431 rajveer 10987 
  def validate(self):
10988 
    return
10989 
 
10990 
 
94 ashish 10991 
  def __repr__(self):
10992 
    L = ['%s=%r' % (key, value)
10993 
      for key, value in self.__dict__.iteritems()]
10994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10995 
 
10996 
  def __eq__(self, other):
10997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10998 
 
10999 
  def __ne__(self, other):
11000 
    return not (self == other)
11001 
 
559 chandransh 11002 
class addItemToCart_args:
11003 
  """
11004 
  Attributes:
11005 
   - cartId
11006 
   - itemId
11007 
   - quantity
3557 rajveer 11008 
   - sourceId
559 chandransh 11009 
  """
11010 
 
11011 
  thrift_spec = (
11012 
    None, # 0
11013 
    (1, TType.I64, 'cartId', None, None, ), # 1
11014 
    (2, TType.I64, 'itemId', None, None, ), # 2
11015 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11016 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11017 
  )
11018 
 
3557 rajveer 11019 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11020 
    self.cartId = cartId
11021 
    self.itemId = itemId
11022 
    self.quantity = quantity
3557 rajveer 11023 
    self.sourceId = sourceId
559 chandransh 11024 
 
11025 
  def read(self, iprot):
11026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11028 
      return
11029 
    iprot.readStructBegin()
11030 
    while True:
11031 
      (fname, ftype, fid) = iprot.readFieldBegin()
11032 
      if ftype == TType.STOP:
11033 
        break
11034 
      if fid == 1:
11035 
        if ftype == TType.I64:
11036 
          self.cartId = iprot.readI64();
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      elif fid == 2:
11040 
        if ftype == TType.I64:
11041 
          self.itemId = iprot.readI64();
11042 
        else:
11043 
          iprot.skip(ftype)
11044 
      elif fid == 3:
11045 
        if ftype == TType.I64:
11046 
          self.quantity = iprot.readI64();
11047 
        else:
11048 
          iprot.skip(ftype)
3557 rajveer 11049 
      elif fid == 4:
11050 
        if ftype == TType.I64:
11051 
          self.sourceId = iprot.readI64();
11052 
        else:
11053 
          iprot.skip(ftype)
559 chandransh 11054 
      else:
11055 
        iprot.skip(ftype)
11056 
      iprot.readFieldEnd()
11057 
    iprot.readStructEnd()
11058 
 
11059 
  def write(self, oprot):
11060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11062 
      return
11063 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11064 
    if self.cartId is not None:
559 chandransh 11065 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11066 
      oprot.writeI64(self.cartId)
11067 
      oprot.writeFieldEnd()
3431 rajveer 11068 
    if self.itemId is not None:
559 chandransh 11069 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11070 
      oprot.writeI64(self.itemId)
11071 
      oprot.writeFieldEnd()
3431 rajveer 11072 
    if self.quantity is not None:
559 chandransh 11073 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11074 
      oprot.writeI64(self.quantity)
11075 
      oprot.writeFieldEnd()
3557 rajveer 11076 
    if self.sourceId is not None:
11077 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11078 
      oprot.writeI64(self.sourceId)
11079 
      oprot.writeFieldEnd()
559 chandransh 11080 
    oprot.writeFieldStop()
11081 
    oprot.writeStructEnd()
11082 
 
3431 rajveer 11083 
  def validate(self):
11084 
    return
11085 
 
11086 
 
559 chandransh 11087 
  def __repr__(self):
11088 
    L = ['%s=%r' % (key, value)
11089 
      for key, value in self.__dict__.iteritems()]
11090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11091 
 
11092 
  def __eq__(self, other):
11093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11094 
 
11095 
  def __ne__(self, other):
11096 
    return not (self == other)
11097 
 
11098 
class addItemToCart_result:
11099 
  """
11100 
  Attributes:
2035 rajveer 11101 
   - success
559 chandransh 11102 
   - scx
11103 
  """
11104 
 
11105 
  thrift_spec = (
2035 rajveer 11106 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11107 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11108 
  )
11109 
 
2035 rajveer 11110 
  def __init__(self, success=None, scx=None,):
11111 
    self.success = success
559 chandransh 11112 
    self.scx = scx
11113 
 
11114 
  def read(self, iprot):
11115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11117 
      return
11118 
    iprot.readStructBegin()
11119 
    while True:
11120 
      (fname, ftype, fid) = iprot.readFieldBegin()
11121 
      if ftype == TType.STOP:
11122 
        break
2035 rajveer 11123 
      if fid == 0:
11124 
        if ftype == TType.STRING:
11125 
          self.success = iprot.readString();
11126 
        else:
11127 
          iprot.skip(ftype)
11128 
      elif fid == 1:
559 chandransh 11129 
        if ftype == TType.STRUCT:
11130 
          self.scx = ShoppingCartException()
11131 
          self.scx.read(iprot)
11132 
        else:
11133 
          iprot.skip(ftype)
11134 
      else:
11135 
        iprot.skip(ftype)
11136 
      iprot.readFieldEnd()
11137 
    iprot.readStructEnd()
11138 
 
11139 
  def write(self, oprot):
11140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11142 
      return
11143 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11144 
    if self.success is not None:
2035 rajveer 11145 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11146 
      oprot.writeString(self.success)
11147 
      oprot.writeFieldEnd()
3431 rajveer 11148 
    if self.scx is not None:
559 chandransh 11149 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11150 
      self.scx.write(oprot)
11151 
      oprot.writeFieldEnd()
11152 
    oprot.writeFieldStop()
11153 
    oprot.writeStructEnd()
11154 
 
3431 rajveer 11155 
  def validate(self):
11156 
    return
11157 
 
11158 
 
559 chandransh 11159 
  def __repr__(self):
11160 
    L = ['%s=%r' % (key, value)
11161 
      for key, value in self.__dict__.iteritems()]
11162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11163 
 
11164 
  def __eq__(self, other):
11165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11166 
 
11167 
  def __ne__(self, other):
11168 
    return not (self == other)
11169 
 
11170 
class deleteItemFromCart_args:
11171 
  """
11172 
  Attributes:
11173 
   - cartId
11174 
   - itemId
11175 
  """
11176 
 
11177 
  thrift_spec = (
11178 
    None, # 0
11179 
    (1, TType.I64, 'cartId', None, None, ), # 1
11180 
    (2, TType.I64, 'itemId', None, None, ), # 2
11181 
  )
11182 
 
11183 
  def __init__(self, cartId=None, itemId=None,):
11184 
    self.cartId = cartId
11185 
    self.itemId = itemId
11186 
 
11187 
  def read(self, iprot):
11188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11190 
      return
11191 
    iprot.readStructBegin()
11192 
    while True:
11193 
      (fname, ftype, fid) = iprot.readFieldBegin()
11194 
      if ftype == TType.STOP:
11195 
        break
11196 
      if fid == 1:
11197 
        if ftype == TType.I64:
11198 
          self.cartId = iprot.readI64();
11199 
        else:
11200 
          iprot.skip(ftype)
11201 
      elif fid == 2:
11202 
        if ftype == TType.I64:
11203 
          self.itemId = iprot.readI64();
11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
11215 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11216 
    if self.cartId is not None:
559 chandransh 11217 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11218 
      oprot.writeI64(self.cartId)
11219 
      oprot.writeFieldEnd()
3431 rajveer 11220 
    if self.itemId is not None:
559 chandransh 11221 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11222 
      oprot.writeI64(self.itemId)
11223 
      oprot.writeFieldEnd()
11224 
    oprot.writeFieldStop()
11225 
    oprot.writeStructEnd()
11226 
 
3431 rajveer 11227 
  def validate(self):
11228 
    return
11229 
 
11230 
 
559 chandransh 11231 
  def __repr__(self):
11232 
    L = ['%s=%r' % (key, value)
11233 
      for key, value in self.__dict__.iteritems()]
11234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11235 
 
11236 
  def __eq__(self, other):
11237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11238 
 
11239 
  def __ne__(self, other):
11240 
    return not (self == other)
11241 
 
11242 
class deleteItemFromCart_result:
11243 
  """
11244 
  Attributes:
11245 
   - scx
11246 
  """
11247 
 
11248 
  thrift_spec = (
11249 
    None, # 0
11250 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11251 
  )
11252 
 
11253 
  def __init__(self, scx=None,):
11254 
    self.scx = scx
11255 
 
11256 
  def read(self, iprot):
11257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11259 
      return
11260 
    iprot.readStructBegin()
11261 
    while True:
11262 
      (fname, ftype, fid) = iprot.readFieldBegin()
11263 
      if ftype == TType.STOP:
11264 
        break
11265 
      if fid == 1:
11266 
        if ftype == TType.STRUCT:
11267 
          self.scx = ShoppingCartException()
11268 
          self.scx.read(iprot)
11269 
        else:
11270 
          iprot.skip(ftype)
11271 
      else:
11272 
        iprot.skip(ftype)
11273 
      iprot.readFieldEnd()
11274 
    iprot.readStructEnd()
11275 
 
11276 
  def write(self, oprot):
11277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11279 
      return
11280 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11281 
    if self.scx is not None:
559 chandransh 11282 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11283 
      self.scx.write(oprot)
11284 
      oprot.writeFieldEnd()
11285 
    oprot.writeFieldStop()
11286 
    oprot.writeStructEnd()
11287 
 
3431 rajveer 11288 
  def validate(self):
11289 
    return
11290 
 
11291 
 
559 chandransh 11292 
  def __repr__(self):
11293 
    L = ['%s=%r' % (key, value)
11294 
      for key, value in self.__dict__.iteritems()]
11295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11296 
 
11297 
  def __eq__(self, other):
11298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11299 
 
11300 
  def __ne__(self, other):
11301 
    return not (self == other)
11302 
 
11303 
class addAddressToCart_args:
11304 
  """
11305 
  Attributes:
11306 
   - cartId
11307 
   - addressId
11308 
  """
11309 
 
11310 
  thrift_spec = (
11311 
    None, # 0
11312 
    (1, TType.I64, 'cartId', None, None, ), # 1
11313 
    (2, TType.I64, 'addressId', None, None, ), # 2
11314 
  )
11315 
 
11316 
  def __init__(self, cartId=None, addressId=None,):
11317 
    self.cartId = cartId
11318 
    self.addressId = addressId
11319 
 
11320 
  def read(self, iprot):
11321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11323 
      return
11324 
    iprot.readStructBegin()
11325 
    while True:
11326 
      (fname, ftype, fid) = iprot.readFieldBegin()
11327 
      if ftype == TType.STOP:
11328 
        break
11329 
      if fid == 1:
11330 
        if ftype == TType.I64:
11331 
          self.cartId = iprot.readI64();
11332 
        else:
11333 
          iprot.skip(ftype)
11334 
      elif fid == 2:
11335 
        if ftype == TType.I64:
11336 
          self.addressId = iprot.readI64();
11337 
        else:
11338 
          iprot.skip(ftype)
11339 
      else:
11340 
        iprot.skip(ftype)
11341 
      iprot.readFieldEnd()
11342 
    iprot.readStructEnd()
11343 
 
11344 
  def write(self, oprot):
11345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11347 
      return
11348 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11349 
    if self.cartId is not None:
559 chandransh 11350 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11351 
      oprot.writeI64(self.cartId)
11352 
      oprot.writeFieldEnd()
3431 rajveer 11353 
    if self.addressId is not None:
559 chandransh 11354 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11355 
      oprot.writeI64(self.addressId)
11356 
      oprot.writeFieldEnd()
11357 
    oprot.writeFieldStop()
11358 
    oprot.writeStructEnd()
11359 
 
3431 rajveer 11360 
  def validate(self):
11361 
    return
11362 
 
11363 
 
559 chandransh 11364 
  def __repr__(self):
11365 
    L = ['%s=%r' % (key, value)
11366 
      for key, value in self.__dict__.iteritems()]
11367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11368 
 
11369 
  def __eq__(self, other):
11370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11371 
 
11372 
  def __ne__(self, other):
11373 
    return not (self == other)
11374 
 
11375 
class addAddressToCart_result:
575 chandransh 11376 
  """
11377 
  Attributes:
11378 
   - scx
11379 
  """
559 chandransh 11380 
 
11381 
  thrift_spec = (
575 chandransh 11382 
    None, # 0
11383 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11384 
  )
11385 
 
575 chandransh 11386 
  def __init__(self, scx=None,):
11387 
    self.scx = scx
11388 
 
559 chandransh 11389 
  def read(self, iprot):
11390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11392 
      return
11393 
    iprot.readStructBegin()
11394 
    while True:
11395 
      (fname, ftype, fid) = iprot.readFieldBegin()
11396 
      if ftype == TType.STOP:
11397 
        break
575 chandransh 11398 
      if fid == 1:
11399 
        if ftype == TType.STRUCT:
11400 
          self.scx = ShoppingCartException()
11401 
          self.scx.read(iprot)
11402 
        else:
11403 
          iprot.skip(ftype)
559 chandransh 11404 
      else:
11405 
        iprot.skip(ftype)
11406 
      iprot.readFieldEnd()
11407 
    iprot.readStructEnd()
11408 
 
11409 
  def write(self, oprot):
11410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11412 
      return
11413 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11414 
    if self.scx is not None:
575 chandransh 11415 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11416 
      self.scx.write(oprot)
11417 
      oprot.writeFieldEnd()
559 chandransh 11418 
    oprot.writeFieldStop()
11419 
    oprot.writeStructEnd()
11420 
 
3431 rajveer 11421 
  def validate(self):
11422 
    return
11423 
 
11424 
 
559 chandransh 11425 
  def __repr__(self):
11426 
    L = ['%s=%r' % (key, value)
11427 
      for key, value in self.__dict__.iteritems()]
11428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11429 
 
11430 
  def __eq__(self, other):
11431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11432 
 
11433 
  def __ne__(self, other):
11434 
    return not (self == other)
11435 
 
5553 rajveer 11436 
class addStoreToCart_args:
11437 
  """
11438 
  Attributes:
11439 
   - cartId
11440 
   - storeId
11441 
  """
11442 
 
11443 
  thrift_spec = (
11444 
    None, # 0
11445 
    (1, TType.I64, 'cartId', None, None, ), # 1
11446 
    (2, TType.I64, 'storeId', None, None, ), # 2
11447 
  )
11448 
 
11449 
  def __init__(self, cartId=None, storeId=None,):
11450 
    self.cartId = cartId
11451 
    self.storeId = storeId
11452 
 
11453 
  def read(self, iprot):
11454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11456 
      return
11457 
    iprot.readStructBegin()
11458 
    while True:
11459 
      (fname, ftype, fid) = iprot.readFieldBegin()
11460 
      if ftype == TType.STOP:
11461 
        break
11462 
      if fid == 1:
11463 
        if ftype == TType.I64:
11464 
          self.cartId = iprot.readI64();
11465 
        else:
11466 
          iprot.skip(ftype)
11467 
      elif fid == 2:
11468 
        if ftype == TType.I64:
11469 
          self.storeId = iprot.readI64();
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      else:
11473 
        iprot.skip(ftype)
11474 
      iprot.readFieldEnd()
11475 
    iprot.readStructEnd()
11476 
 
11477 
  def write(self, oprot):
11478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11480 
      return
11481 
    oprot.writeStructBegin('addStoreToCart_args')
11482 
    if self.cartId is not None:
11483 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11484 
      oprot.writeI64(self.cartId)
11485 
      oprot.writeFieldEnd()
11486 
    if self.storeId is not None:
11487 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11488 
      oprot.writeI64(self.storeId)
11489 
      oprot.writeFieldEnd()
11490 
    oprot.writeFieldStop()
11491 
    oprot.writeStructEnd()
11492 
 
11493 
  def validate(self):
11494 
    return
11495 
 
11496 
 
11497 
  def __repr__(self):
11498 
    L = ['%s=%r' % (key, value)
11499 
      for key, value in self.__dict__.iteritems()]
11500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11501 
 
11502 
  def __eq__(self, other):
11503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11504 
 
11505 
  def __ne__(self, other):
11506 
    return not (self == other)
11507 
 
11508 
class addStoreToCart_result:
11509 
  """
11510 
  Attributes:
11511 
   - scx
11512 
  """
11513 
 
11514 
  thrift_spec = (
11515 
    None, # 0
11516 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11517 
  )
11518 
 
11519 
  def __init__(self, scx=None,):
11520 
    self.scx = scx
11521 
 
11522 
  def read(self, iprot):
11523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11525 
      return
11526 
    iprot.readStructBegin()
11527 
    while True:
11528 
      (fname, ftype, fid) = iprot.readFieldBegin()
11529 
      if ftype == TType.STOP:
11530 
        break
11531 
      if fid == 1:
11532 
        if ftype == TType.STRUCT:
11533 
          self.scx = ShoppingCartException()
11534 
          self.scx.read(iprot)
11535 
        else:
11536 
          iprot.skip(ftype)
11537 
      else:
11538 
        iprot.skip(ftype)
11539 
      iprot.readFieldEnd()
11540 
    iprot.readStructEnd()
11541 
 
11542 
  def write(self, oprot):
11543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11545 
      return
11546 
    oprot.writeStructBegin('addStoreToCart_result')
11547 
    if self.scx is not None:
11548 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11549 
      self.scx.write(oprot)
11550 
      oprot.writeFieldEnd()
11551 
    oprot.writeFieldStop()
11552 
    oprot.writeStructEnd()
11553 
 
11554 
  def validate(self):
11555 
    return
11556 
 
11557 
 
11558 
  def __repr__(self):
11559 
    L = ['%s=%r' % (key, value)
11560 
      for key, value in self.__dict__.iteritems()]
11561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11562 
 
11563 
  def __eq__(self, other):
11564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11565 
 
11566 
  def __ne__(self, other):
11567 
    return not (self == other)
11568 
 
1976 varun.gupt 11569 
class applyCouponToCart_args:
11570 
  """
11571 
  Attributes:
6922 anupam.sin 11572 
   - cart
1976 varun.gupt 11573 
   - couponCode
11574 
  """
11575 
 
11576 
  thrift_spec = (
11577 
    None, # 0
6922 anupam.sin 11578 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11579 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11580 
  )
11581 
 
6922 anupam.sin 11582 
  def __init__(self, cart=None, couponCode=None,):
11583 
    self.cart = cart
1976 varun.gupt 11584 
    self.couponCode = couponCode
11585 
 
11586 
  def read(self, iprot):
11587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11589 
      return
11590 
    iprot.readStructBegin()
11591 
    while True:
11592 
      (fname, ftype, fid) = iprot.readFieldBegin()
11593 
      if ftype == TType.STOP:
11594 
        break
11595 
      if fid == 1:
6922 anupam.sin 11596 
        if ftype == TType.STRUCT:
11597 
          self.cart = Cart()
11598 
          self.cart.read(iprot)
1976 varun.gupt 11599 
        else:
11600 
          iprot.skip(ftype)
11601 
      elif fid == 2:
11602 
        if ftype == TType.STRING:
11603 
          self.couponCode = iprot.readString();
11604 
        else:
11605 
          iprot.skip(ftype)
11606 
      else:
11607 
        iprot.skip(ftype)
11608 
      iprot.readFieldEnd()
11609 
    iprot.readStructEnd()
11610 
 
11611 
  def write(self, oprot):
11612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11614 
      return
11615 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11616 
    if self.cart is not None:
11617 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11618 
      self.cart.write(oprot)
1976 varun.gupt 11619 
      oprot.writeFieldEnd()
3431 rajveer 11620 
    if self.couponCode is not None:
1976 varun.gupt 11621 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11622 
      oprot.writeString(self.couponCode)
11623 
      oprot.writeFieldEnd()
11624 
    oprot.writeFieldStop()
11625 
    oprot.writeStructEnd()
11626 
 
3431 rajveer 11627 
  def validate(self):
11628 
    return
11629 
 
11630 
 
1976 varun.gupt 11631 
  def __repr__(self):
11632 
    L = ['%s=%r' % (key, value)
11633 
      for key, value in self.__dict__.iteritems()]
11634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11635 
 
11636 
  def __eq__(self, other):
11637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11638 
 
11639 
  def __ne__(self, other):
11640 
    return not (self == other)
11641 
 
11642 
class applyCouponToCart_result:
11643 
  """
11644 
  Attributes:
11645 
   - scx
11646 
  """
11647 
 
11648 
  thrift_spec = (
11649 
    None, # 0
11650 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11651 
  )
11652 
 
11653 
  def __init__(self, scx=None,):
11654 
    self.scx = scx
11655 
 
11656 
  def read(self, iprot):
11657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11659 
      return
11660 
    iprot.readStructBegin()
11661 
    while True:
11662 
      (fname, ftype, fid) = iprot.readFieldBegin()
11663 
      if ftype == TType.STOP:
11664 
        break
11665 
      if fid == 1:
11666 
        if ftype == TType.STRUCT:
11667 
          self.scx = ShoppingCartException()
11668 
          self.scx.read(iprot)
11669 
        else:
11670 
          iprot.skip(ftype)
11671 
      else:
11672 
        iprot.skip(ftype)
11673 
      iprot.readFieldEnd()
11674 
    iprot.readStructEnd()
11675 
 
11676 
  def write(self, oprot):
11677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11679 
      return
11680 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11681 
    if self.scx is not None:
1976 varun.gupt 11682 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11683 
      self.scx.write(oprot)
11684 
      oprot.writeFieldEnd()
11685 
    oprot.writeFieldStop()
11686 
    oprot.writeStructEnd()
11687 
 
3431 rajveer 11688 
  def validate(self):
11689 
    return
11690 
 
11691 
 
1976 varun.gupt 11692 
  def __repr__(self):
11693 
    L = ['%s=%r' % (key, value)
11694 
      for key, value in self.__dict__.iteritems()]
11695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11696 
 
11697 
  def __eq__(self, other):
11698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11699 
 
11700 
  def __ne__(self, other):
11701 
    return not (self == other)
11702 
 
11703 
class removeCoupon_args:
11704 
  """
11705 
  Attributes:
11706 
   - cartId
11707 
  """
11708 
 
11709 
  thrift_spec = (
11710 
    None, # 0
11711 
    (1, TType.I64, 'cartId', None, None, ), # 1
11712 
  )
11713 
 
11714 
  def __init__(self, cartId=None,):
11715 
    self.cartId = cartId
11716 
 
11717 
  def read(self, iprot):
11718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11720 
      return
11721 
    iprot.readStructBegin()
11722 
    while True:
11723 
      (fname, ftype, fid) = iprot.readFieldBegin()
11724 
      if ftype == TType.STOP:
11725 
        break
11726 
      if fid == 1:
11727 
        if ftype == TType.I64:
11728 
          self.cartId = iprot.readI64();
11729 
        else:
11730 
          iprot.skip(ftype)
11731 
      else:
11732 
        iprot.skip(ftype)
11733 
      iprot.readFieldEnd()
11734 
    iprot.readStructEnd()
11735 
 
11736 
  def write(self, oprot):
11737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11739 
      return
11740 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11741 
    if self.cartId is not None:
1976 varun.gupt 11742 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11743 
      oprot.writeI64(self.cartId)
11744 
      oprot.writeFieldEnd()
11745 
    oprot.writeFieldStop()
11746 
    oprot.writeStructEnd()
11747 
 
3431 rajveer 11748 
  def validate(self):
11749 
    return
11750 
 
11751 
 
1976 varun.gupt 11752 
  def __repr__(self):
11753 
    L = ['%s=%r' % (key, value)
11754 
      for key, value in self.__dict__.iteritems()]
11755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11756 
 
11757 
  def __eq__(self, other):
11758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11759 
 
11760 
  def __ne__(self, other):
11761 
    return not (self == other)
11762 
 
11763 
class removeCoupon_result:
11764 
  """
11765 
  Attributes:
11766 
   - scx
11767 
  """
11768 
 
11769 
  thrift_spec = (
11770 
    None, # 0
11771 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11772 
  )
11773 
 
11774 
  def __init__(self, scx=None,):
11775 
    self.scx = scx
11776 
 
11777 
  def read(self, iprot):
11778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11780 
      return
11781 
    iprot.readStructBegin()
11782 
    while True:
11783 
      (fname, ftype, fid) = iprot.readFieldBegin()
11784 
      if ftype == TType.STOP:
11785 
        break
11786 
      if fid == 1:
11787 
        if ftype == TType.STRUCT:
11788 
          self.scx = ShoppingCartException()
11789 
          self.scx.read(iprot)
11790 
        else:
11791 
          iprot.skip(ftype)
11792 
      else:
11793 
        iprot.skip(ftype)
11794 
      iprot.readFieldEnd()
11795 
    iprot.readStructEnd()
11796 
 
11797 
  def write(self, oprot):
11798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11800 
      return
11801 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11802 
    if self.scx is not None:
1976 varun.gupt 11803 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11804 
      self.scx.write(oprot)
11805 
      oprot.writeFieldEnd()
11806 
    oprot.writeFieldStop()
11807 
    oprot.writeStructEnd()
11808 
 
3431 rajveer 11809 
  def validate(self):
11810 
    return
11811 
 
11812 
 
1976 varun.gupt 11813 
  def __repr__(self):
11814 
    L = ['%s=%r' % (key, value)
11815 
      for key, value in self.__dict__.iteritems()]
11816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11817 
 
11818 
  def __eq__(self, other):
11819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11820 
 
11821 
  def __ne__(self, other):
11822 
    return not (self == other)
11823 
 
3554 varun.gupt 11824 
class deleteDiscountsFromCart_args:
11825 
  """
11826 
  Attributes:
11827 
   - cartId
11828 
  """
11829 
 
11830 
  thrift_spec = (
11831 
    None, # 0
11832 
    (1, TType.I64, 'cartId', None, None, ), # 1
11833 
  )
11834 
 
11835 
  def __init__(self, cartId=None,):
11836 
    self.cartId = cartId
11837 
 
11838 
  def read(self, iprot):
11839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11841 
      return
11842 
    iprot.readStructBegin()
11843 
    while True:
11844 
      (fname, ftype, fid) = iprot.readFieldBegin()
11845 
      if ftype == TType.STOP:
11846 
        break
11847 
      if fid == 1:
11848 
        if ftype == TType.I64:
11849 
          self.cartId = iprot.readI64();
11850 
        else:
11851 
          iprot.skip(ftype)
11852 
      else:
11853 
        iprot.skip(ftype)
11854 
      iprot.readFieldEnd()
11855 
    iprot.readStructEnd()
11856 
 
11857 
  def write(self, oprot):
11858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11860 
      return
11861 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11862 
    if self.cartId is not None:
11863 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11864 
      oprot.writeI64(self.cartId)
11865 
      oprot.writeFieldEnd()
11866 
    oprot.writeFieldStop()
11867 
    oprot.writeStructEnd()
11868 
 
11869 
  def validate(self):
11870 
    return
11871 
 
11872 
 
11873 
  def __repr__(self):
11874 
    L = ['%s=%r' % (key, value)
11875 
      for key, value in self.__dict__.iteritems()]
11876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11877 
 
11878 
  def __eq__(self, other):
11879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11880 
 
11881 
  def __ne__(self, other):
11882 
    return not (self == other)
11883 
 
11884 
class deleteDiscountsFromCart_result:
11885 
  """
11886 
  Attributes:
11887 
   - scx
11888 
  """
11889 
 
11890 
  thrift_spec = (
11891 
    None, # 0
11892 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11893 
  )
11894 
 
11895 
  def __init__(self, scx=None,):
11896 
    self.scx = scx
11897 
 
11898 
  def read(self, iprot):
11899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11901 
      return
11902 
    iprot.readStructBegin()
11903 
    while True:
11904 
      (fname, ftype, fid) = iprot.readFieldBegin()
11905 
      if ftype == TType.STOP:
11906 
        break
11907 
      if fid == 1:
11908 
        if ftype == TType.STRUCT:
11909 
          self.scx = ShoppingCartException()
11910 
          self.scx.read(iprot)
11911 
        else:
11912 
          iprot.skip(ftype)
11913 
      else:
11914 
        iprot.skip(ftype)
11915 
      iprot.readFieldEnd()
11916 
    iprot.readStructEnd()
11917 
 
11918 
  def write(self, oprot):
11919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11921 
      return
11922 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11923 
    if self.scx is not None:
11924 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11925 
      self.scx.write(oprot)
11926 
      oprot.writeFieldEnd()
11927 
    oprot.writeFieldStop()
11928 
    oprot.writeStructEnd()
11929 
 
11930 
  def validate(self):
11931 
    return
11932 
 
11933 
 
11934 
  def __repr__(self):
11935 
    L = ['%s=%r' % (key, value)
11936 
      for key, value in self.__dict__.iteritems()]
11937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11938 
 
11939 
  def __eq__(self, other):
11940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11941 
 
11942 
  def __ne__(self, other):
11943 
    return not (self == other)
11944 
 
11945 
class saveDiscounts_args:
11946 
  """
11947 
  Attributes:
11948 
   - discounts
11949 
  """
11950 
 
11951 
  thrift_spec = (
11952 
    None, # 0
11953 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11954 
  )
11955 
 
11956 
  def __init__(self, discounts=None,):
11957 
    self.discounts = discounts
11958 
 
11959 
  def read(self, iprot):
11960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11962 
      return
11963 
    iprot.readStructBegin()
11964 
    while True:
11965 
      (fname, ftype, fid) = iprot.readFieldBegin()
11966 
      if ftype == TType.STOP:
11967 
        break
11968 
      if fid == 1:
11969 
        if ftype == TType.LIST:
11970 
          self.discounts = []
11592 amit.gupta 11971 
          (_etype163, _size160) = iprot.readListBegin()
11972 
          for _i164 in xrange(_size160):
11973 
            _elem165 = Discount()
11974 
            _elem165.read(iprot)
11975 
            self.discounts.append(_elem165)
3554 varun.gupt 11976 
          iprot.readListEnd()
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      else:
11980 
        iprot.skip(ftype)
11981 
      iprot.readFieldEnd()
11982 
    iprot.readStructEnd()
11983 
 
11984 
  def write(self, oprot):
11985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11987 
      return
11988 
    oprot.writeStructBegin('saveDiscounts_args')
11989 
    if self.discounts is not None:
11990 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11991 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11992 
      for iter166 in self.discounts:
11993 
        iter166.write(oprot)
3554 varun.gupt 11994 
      oprot.writeListEnd()
11995 
      oprot.writeFieldEnd()
11996 
    oprot.writeFieldStop()
11997 
    oprot.writeStructEnd()
11998 
 
11999 
  def validate(self):
12000 
    return
12001 
 
12002 
 
12003 
  def __repr__(self):
12004 
    L = ['%s=%r' % (key, value)
12005 
      for key, value in self.__dict__.iteritems()]
12006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12007 
 
12008 
  def __eq__(self, other):
12009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12010 
 
12011 
  def __ne__(self, other):
12012 
    return not (self == other)
12013 
 
12014 
class saveDiscounts_result:
12015 
  """
12016 
  Attributes:
12017 
   - scx
12018 
  """
12019 
 
12020 
  thrift_spec = (
12021 
    None, # 0
12022 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12023 
  )
12024 
 
12025 
  def __init__(self, scx=None,):
12026 
    self.scx = scx
12027 
 
12028 
  def read(self, iprot):
12029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12031 
      return
12032 
    iprot.readStructBegin()
12033 
    while True:
12034 
      (fname, ftype, fid) = iprot.readFieldBegin()
12035 
      if ftype == TType.STOP:
12036 
        break
12037 
      if fid == 1:
12038 
        if ftype == TType.STRUCT:
12039 
          self.scx = ShoppingCartException()
12040 
          self.scx.read(iprot)
12041 
        else:
12042 
          iprot.skip(ftype)
12043 
      else:
12044 
        iprot.skip(ftype)
12045 
      iprot.readFieldEnd()
12046 
    iprot.readStructEnd()
12047 
 
12048 
  def write(self, oprot):
12049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12051 
      return
12052 
    oprot.writeStructBegin('saveDiscounts_result')
12053 
    if self.scx is not None:
12054 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12055 
      self.scx.write(oprot)
12056 
      oprot.writeFieldEnd()
12057 
    oprot.writeFieldStop()
12058 
    oprot.writeStructEnd()
12059 
 
12060 
  def validate(self):
12061 
    return
12062 
 
12063 
 
12064 
  def __repr__(self):
12065 
    L = ['%s=%r' % (key, value)
12066 
      for key, value in self.__dict__.iteritems()]
12067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12068 
 
12069 
  def __eq__(self, other):
12070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12071 
 
12072 
  def __ne__(self, other):
12073 
    return not (self == other)
12074 
 
690 chandransh 12075 
class createOrders_args:
559 chandransh 12076 
  """
12077 
  Attributes:
12078 
   - cartId
2815 vikas 12079 
   - sessionSource
12080 
   - sessionStartTime
3858 vikas 12081 
   - firstSource
12082 
   - firstSourceTime
5326 rajveer 12083 
   - userId
6389 rajveer 12084 
   - schemeId
11526 amit.gupta 12085 
   - orderSource
559 chandransh 12086 
  """
12087 
 
12088 
  thrift_spec = (
12089 
    None, # 0
12090 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12091 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12092 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12093 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12094 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12095 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12096 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12097 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12098 
  )
12099 
 
11526 amit.gupta 12100 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12101 
    self.cartId = cartId
2815 vikas 12102 
    self.sessionSource = sessionSource
12103 
    self.sessionStartTime = sessionStartTime
3858 vikas 12104 
    self.firstSource = firstSource
12105 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12106 
    self.userId = userId
6389 rajveer 12107 
    self.schemeId = schemeId
11526 amit.gupta 12108 
    self.orderSource = orderSource
559 chandransh 12109 
 
12110 
  def read(self, iprot):
12111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12113 
      return
12114 
    iprot.readStructBegin()
12115 
    while True:
12116 
      (fname, ftype, fid) = iprot.readFieldBegin()
12117 
      if ftype == TType.STOP:
12118 
        break
12119 
      if fid == 1:
12120 
        if ftype == TType.I64:
12121 
          self.cartId = iprot.readI64();
12122 
        else:
12123 
          iprot.skip(ftype)
2815 vikas 12124 
      elif fid == 2:
12125 
        if ftype == TType.STRING:
12126 
          self.sessionSource = iprot.readString();
12127 
        else:
12128 
          iprot.skip(ftype)
12129 
      elif fid == 3:
12130 
        if ftype == TType.I64:
12131 
          self.sessionStartTime = iprot.readI64();
12132 
        else:
12133 
          iprot.skip(ftype)
3858 vikas 12134 
      elif fid == 4:
12135 
        if ftype == TType.STRING:
12136 
          self.firstSource = iprot.readString();
12137 
        else:
12138 
          iprot.skip(ftype)
12139 
      elif fid == 5:
12140 
        if ftype == TType.I64:
12141 
          self.firstSourceTime = iprot.readI64();
12142 
        else:
12143 
          iprot.skip(ftype)
5326 rajveer 12144 
      elif fid == 6:
12145 
        if ftype == TType.I64:
12146 
          self.userId = iprot.readI64();
12147 
        else:
12148 
          iprot.skip(ftype)
6389 rajveer 12149 
      elif fid == 7:
12150 
        if ftype == TType.I64:
12151 
          self.schemeId = iprot.readI64();
12152 
        else:
12153 
          iprot.skip(ftype)
11526 amit.gupta 12154 
      elif fid == 8:
12155 
        if ftype == TType.I64:
12156 
          self.orderSource = iprot.readI64();
12157 
        else:
12158 
          iprot.skip(ftype)
559 chandransh 12159 
      else:
12160 
        iprot.skip(ftype)
12161 
      iprot.readFieldEnd()
12162 
    iprot.readStructEnd()
12163 
 
12164 
  def write(self, oprot):
12165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12167 
      return
690 chandransh 12168 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12169 
    if self.cartId is not None:
559 chandransh 12170 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12171 
      oprot.writeI64(self.cartId)
12172 
      oprot.writeFieldEnd()
3431 rajveer 12173 
    if self.sessionSource is not None:
2815 vikas 12174 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12175 
      oprot.writeString(self.sessionSource)
12176 
      oprot.writeFieldEnd()
3431 rajveer 12177 
    if self.sessionStartTime is not None:
2815 vikas 12178 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12179 
      oprot.writeI64(self.sessionStartTime)
12180 
      oprot.writeFieldEnd()
3858 vikas 12181 
    if self.firstSource is not None:
12182 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12183 
      oprot.writeString(self.firstSource)
12184 
      oprot.writeFieldEnd()
12185 
    if self.firstSourceTime is not None:
12186 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12187 
      oprot.writeI64(self.firstSourceTime)
12188 
      oprot.writeFieldEnd()
5326 rajveer 12189 
    if self.userId is not None:
12190 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12191 
      oprot.writeI64(self.userId)
12192 
      oprot.writeFieldEnd()
6389 rajveer 12193 
    if self.schemeId is not None:
12194 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12195 
      oprot.writeI64(self.schemeId)
12196 
      oprot.writeFieldEnd()
11526 amit.gupta 12197 
    if self.orderSource is not None:
12198 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12199 
      oprot.writeI64(self.orderSource)
12200 
      oprot.writeFieldEnd()
559 chandransh 12201 
    oprot.writeFieldStop()
12202 
    oprot.writeStructEnd()
12203 
 
3431 rajveer 12204 
  def validate(self):
12205 
    return
12206 
 
12207 
 
559 chandransh 12208 
  def __repr__(self):
12209 
    L = ['%s=%r' % (key, value)
12210 
      for key, value in self.__dict__.iteritems()]
12211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12212 
 
12213 
  def __eq__(self, other):
12214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12215 
 
12216 
  def __ne__(self, other):
12217 
    return not (self == other)
12218 
 
690 chandransh 12219 
class createOrders_result:
559 chandransh 12220 
  """
12221 
  Attributes:
94 ashish 12222 
   - success
559 chandransh 12223 
   - scx
94 ashish 12224 
  """
12225 
 
12226 
  thrift_spec = (
575 chandransh 12227 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12228 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12229 
  )
12230 
 
559 chandransh 12231 
  def __init__(self, success=None, scx=None,):
94 ashish 12232 
    self.success = success
559 chandransh 12233 
    self.scx = scx
94 ashish 12234 
 
12235 
  def read(self, iprot):
12236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12238 
      return
12239 
    iprot.readStructBegin()
12240 
    while True:
12241 
      (fname, ftype, fid) = iprot.readFieldBegin()
12242 
      if ftype == TType.STOP:
12243 
        break
12244 
      if fid == 0:
575 chandransh 12245 
        if ftype == TType.I64:
12246 
          self.success = iprot.readI64();
94 ashish 12247 
        else:
12248 
          iprot.skip(ftype)
12249 
      elif fid == 1:
12250 
        if ftype == TType.STRUCT:
559 chandransh 12251 
          self.scx = ShoppingCartException()
12252 
          self.scx.read(iprot)
94 ashish 12253 
        else:
12254 
          iprot.skip(ftype)
12255 
      else:
12256 
        iprot.skip(ftype)
12257 
      iprot.readFieldEnd()
12258 
    iprot.readStructEnd()
12259 
 
12260 
  def write(self, oprot):
12261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12263 
      return
690 chandransh 12264 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12265 
    if self.success is not None:
575 chandransh 12266 
      oprot.writeFieldBegin('success', TType.I64, 0)
12267 
      oprot.writeI64(self.success)
94 ashish 12268 
      oprot.writeFieldEnd()
3431 rajveer 12269 
    if self.scx is not None:
559 chandransh 12270 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12271 
      self.scx.write(oprot)
94 ashish 12272 
      oprot.writeFieldEnd()
12273 
    oprot.writeFieldStop()
12274 
    oprot.writeStructEnd()
12275 
 
3431 rajveer 12276 
  def validate(self):
12277 
    return
12278 
 
12279 
 
94 ashish 12280 
  def __repr__(self):
12281 
    L = ['%s=%r' % (key, value)
12282 
      for key, value in self.__dict__.iteritems()]
12283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12284 
 
12285 
  def __eq__(self, other):
12286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12287 
 
12288 
  def __ne__(self, other):
12289 
    return not (self == other)
12290 
 
559 chandransh 12291 
class validateCart_args:
94 ashish 12292 
  """
12293 
  Attributes:
559 chandransh 12294 
   - cartId
3557 rajveer 12295 
   - sourceId
94 ashish 12296 
  """
12297 
 
12298 
  thrift_spec = (
12299 
    None, # 0
559 chandransh 12300 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12301 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12302 
  )
12303 
 
3557 rajveer 12304 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12305 
    self.cartId = cartId
3557 rajveer 12306 
    self.sourceId = sourceId
94 ashish 12307 
 
12308 
  def read(self, iprot):
12309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12311 
      return
12312 
    iprot.readStructBegin()
12313 
    while True:
12314 
      (fname, ftype, fid) = iprot.readFieldBegin()
12315 
      if ftype == TType.STOP:
12316 
        break
12317 
      if fid == 1:
12318 
        if ftype == TType.I64:
559 chandransh 12319 
          self.cartId = iprot.readI64();
94 ashish 12320 
        else:
12321 
          iprot.skip(ftype)
3557 rajveer 12322 
      elif fid == 2:
12323 
        if ftype == TType.I64:
12324 
          self.sourceId = iprot.readI64();
12325 
        else:
12326 
          iprot.skip(ftype)
94 ashish 12327 
      else:
12328 
        iprot.skip(ftype)
12329 
      iprot.readFieldEnd()
12330 
    iprot.readStructEnd()
12331 
 
12332 
  def write(self, oprot):
12333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12335 
      return
559 chandransh 12336 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12337 
    if self.cartId is not None:
559 chandransh 12338 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12339 
      oprot.writeI64(self.cartId)
94 ashish 12340 
      oprot.writeFieldEnd()
3557 rajveer 12341 
    if self.sourceId is not None:
12342 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12343 
      oprot.writeI64(self.sourceId)
12344 
      oprot.writeFieldEnd()
94 ashish 12345 
    oprot.writeFieldStop()
12346 
    oprot.writeStructEnd()
12347 
 
3431 rajveer 12348 
  def validate(self):
12349 
    return
12350 
 
12351 
 
94 ashish 12352 
  def __repr__(self):
12353 
    L = ['%s=%r' % (key, value)
12354 
      for key, value in self.__dict__.iteritems()]
12355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12356 
 
12357 
  def __eq__(self, other):
12358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12359 
 
12360 
  def __ne__(self, other):
12361 
    return not (self == other)
12362 
 
559 chandransh 12363 
class validateCart_result:
94 ashish 12364 
  """
12365 
  Attributes:
12366 
   - success
575 chandransh 12367 
   - scex
94 ashish 12368 
  """
12369 
 
12370 
  thrift_spec = (
6736 amit.gupta 12371 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12372 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12373 
  )
12374 
 
575 chandransh 12375 
  def __init__(self, success=None, scex=None,):
94 ashish 12376 
    self.success = success
575 chandransh 12377 
    self.scex = scex
94 ashish 12378 
 
12379 
  def read(self, iprot):
12380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12382 
      return
12383 
    iprot.readStructBegin()
12384 
    while True:
12385 
      (fname, ftype, fid) = iprot.readFieldBegin()
12386 
      if ftype == TType.STOP:
12387 
        break
12388 
      if fid == 0:
6736 amit.gupta 12389 
        if ftype == TType.LIST:
12390 
          self.success = []
11592 amit.gupta 12391 
          (_etype170, _size167) = iprot.readListBegin()
12392 
          for _i171 in xrange(_size167):
12393 
            _elem172 = iprot.readString();
12394 
            self.success.append(_elem172)
6736 amit.gupta 12395 
          iprot.readListEnd()
94 ashish 12396 
        else:
12397 
          iprot.skip(ftype)
575 chandransh 12398 
      elif fid == 1:
12399 
        if ftype == TType.STRUCT:
12400 
          self.scex = ShoppingCartException()
12401 
          self.scex.read(iprot)
12402 
        else:
12403 
          iprot.skip(ftype)
94 ashish 12404 
      else:
12405 
        iprot.skip(ftype)
12406 
      iprot.readFieldEnd()
12407 
    iprot.readStructEnd()
12408 
 
12409 
  def write(self, oprot):
12410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12412 
      return
559 chandransh 12413 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12414 
    if self.success is not None:
6736 amit.gupta 12415 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12416 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12417 
      for iter173 in self.success:
12418 
        oprot.writeString(iter173)
6736 amit.gupta 12419 
      oprot.writeListEnd()
94 ashish 12420 
      oprot.writeFieldEnd()
3431 rajveer 12421 
    if self.scex is not None:
575 chandransh 12422 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12423 
      self.scex.write(oprot)
12424 
      oprot.writeFieldEnd()
559 chandransh 12425 
    oprot.writeFieldStop()
12426 
    oprot.writeStructEnd()
12427 
 
3431 rajveer 12428 
  def validate(self):
12429 
    return
12430 
 
12431 
 
559 chandransh 12432 
  def __repr__(self):
12433 
    L = ['%s=%r' % (key, value)
12434 
      for key, value in self.__dict__.iteritems()]
12435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12436 
 
12437 
  def __eq__(self, other):
12438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12439 
 
12440 
  def __ne__(self, other):
12441 
    return not (self == other)
12442 
 
11980 amit.gupta 12443 
class validateCartWithDealerCoupon_args:
12444 
  """
12445 
  Attributes:
12446 
   - cartId
12447 
   - sourceId
12448 
   - dealCoupon
12449 
  """
12450 
 
12451 
  thrift_spec = (
12452 
    None, # 0
12453 
    (1, TType.I64, 'cartId', None, None, ), # 1
12454 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12455 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12456 
  )
12457 
 
12458 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12459 
    self.cartId = cartId
12460 
    self.sourceId = sourceId
12461 
    self.dealCoupon = dealCoupon
12462 
 
12463 
  def read(self, iprot):
12464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12466 
      return
12467 
    iprot.readStructBegin()
12468 
    while True:
12469 
      (fname, ftype, fid) = iprot.readFieldBegin()
12470 
      if ftype == TType.STOP:
12471 
        break
12472 
      if fid == 1:
12473 
        if ftype == TType.I64:
12474 
          self.cartId = iprot.readI64();
12475 
        else:
12476 
          iprot.skip(ftype)
12477 
      elif fid == 2:
12478 
        if ftype == TType.I64:
12479 
          self.sourceId = iprot.readI64();
12480 
        else:
12481 
          iprot.skip(ftype)
12482 
      elif fid == 3:
12483 
        if ftype == TType.STRING:
12484 
          self.dealCoupon = iprot.readString();
12485 
        else:
12486 
          iprot.skip(ftype)
12487 
      else:
12488 
        iprot.skip(ftype)
12489 
      iprot.readFieldEnd()
12490 
    iprot.readStructEnd()
12491 
 
12492 
  def write(self, oprot):
12493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12495 
      return
12496 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12497 
    if self.cartId is not None:
12498 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12499 
      oprot.writeI64(self.cartId)
12500 
      oprot.writeFieldEnd()
12501 
    if self.sourceId is not None:
12502 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12503 
      oprot.writeI64(self.sourceId)
12504 
      oprot.writeFieldEnd()
12505 
    if self.dealCoupon is not None:
12506 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12507 
      oprot.writeString(self.dealCoupon)
12508 
      oprot.writeFieldEnd()
12509 
    oprot.writeFieldStop()
12510 
    oprot.writeStructEnd()
12511 
 
12512 
  def validate(self):
12513 
    return
12514 
 
12515 
 
12516 
  def __repr__(self):
12517 
    L = ['%s=%r' % (key, value)
12518 
      for key, value in self.__dict__.iteritems()]
12519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12520 
 
12521 
  def __eq__(self, other):
12522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12523 
 
12524 
  def __ne__(self, other):
12525 
    return not (self == other)
12526 
 
12527 
class validateCartWithDealerCoupon_result:
12528 
  """
12529 
  Attributes:
12530 
   - success
12531 
   - scex
12532 
  """
12533 
 
12534 
  thrift_spec = (
12535 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12536 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12537 
  )
12538 
 
12539 
  def __init__(self, success=None, scex=None,):
12540 
    self.success = success
12541 
    self.scex = scex
12542 
 
12543 
  def read(self, iprot):
12544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12546 
      return
12547 
    iprot.readStructBegin()
12548 
    while True:
12549 
      (fname, ftype, fid) = iprot.readFieldBegin()
12550 
      if ftype == TType.STOP:
12551 
        break
12552 
      if fid == 0:
12553 
        if ftype == TType.LIST:
12554 
          self.success = []
12555 
          (_etype177, _size174) = iprot.readListBegin()
12556 
          for _i178 in xrange(_size174):
12557 
            _elem179 = iprot.readString();
12558 
            self.success.append(_elem179)
12559 
          iprot.readListEnd()
12560 
        else:
12561 
          iprot.skip(ftype)
12562 
      elif fid == 1:
12563 
        if ftype == TType.STRUCT:
12564 
          self.scex = ShoppingCartException()
12565 
          self.scex.read(iprot)
12566 
        else:
12567 
          iprot.skip(ftype)
12568 
      else:
12569 
        iprot.skip(ftype)
12570 
      iprot.readFieldEnd()
12571 
    iprot.readStructEnd()
12572 
 
12573 
  def write(self, oprot):
12574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12576 
      return
12577 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12578 
    if self.success is not None:
12579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12580 
      oprot.writeListBegin(TType.STRING, len(self.success))
12581 
      for iter180 in self.success:
12582 
        oprot.writeString(iter180)
12583 
      oprot.writeListEnd()
12584 
      oprot.writeFieldEnd()
12585 
    if self.scex is not None:
12586 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12587 
      self.scex.write(oprot)
12588 
      oprot.writeFieldEnd()
12589 
    oprot.writeFieldStop()
12590 
    oprot.writeStructEnd()
12591 
 
12592 
  def validate(self):
12593 
    return
12594 
 
12595 
 
12596 
  def __repr__(self):
12597 
    L = ['%s=%r' % (key, value)
12598 
      for key, value in self.__dict__.iteritems()]
12599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12600 
 
12601 
  def __eq__(self, other):
12602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12603 
 
12604 
  def __ne__(self, other):
12605 
    return not (self == other)
12606 
 
690 chandransh 12607 
class mergeCart_args:
575 chandransh 12608 
  """
12609 
  Attributes:
690 chandransh 12610 
   - fromCartId
12611 
   - toCartId
12612 
  """
12613 
 
12614 
  thrift_spec = (
12615 
    None, # 0
12616 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12617 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12618 
  )
12619 
 
12620 
  def __init__(self, fromCartId=None, toCartId=None,):
12621 
    self.fromCartId = fromCartId
12622 
    self.toCartId = toCartId
12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
12633 
      if fid == 1:
12634 
        if ftype == TType.I64:
12635 
          self.fromCartId = iprot.readI64();
12636 
        else:
12637 
          iprot.skip(ftype)
12638 
      elif fid == 2:
12639 
        if ftype == TType.I64:
12640 
          self.toCartId = iprot.readI64();
12641 
        else:
12642 
          iprot.skip(ftype)
12643 
      else:
12644 
        iprot.skip(ftype)
12645 
      iprot.readFieldEnd()
12646 
    iprot.readStructEnd()
12647 
 
12648 
  def write(self, oprot):
12649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12651 
      return
12652 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12653 
    if self.fromCartId is not None:
690 chandransh 12654 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12655 
      oprot.writeI64(self.fromCartId)
12656 
      oprot.writeFieldEnd()
3431 rajveer 12657 
    if self.toCartId is not None:
690 chandransh 12658 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12659 
      oprot.writeI64(self.toCartId)
12660 
      oprot.writeFieldEnd()
12661 
    oprot.writeFieldStop()
12662 
    oprot.writeStructEnd()
12663 
 
3431 rajveer 12664 
  def validate(self):
12665 
    return
12666 
 
12667 
 
690 chandransh 12668 
  def __repr__(self):
12669 
    L = ['%s=%r' % (key, value)
12670 
      for key, value in self.__dict__.iteritems()]
12671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12672 
 
12673 
  def __eq__(self, other):
12674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12675 
 
12676 
  def __ne__(self, other):
12677 
    return not (self == other)
12678 
 
12679 
class mergeCart_result:
12680 
 
12681 
  thrift_spec = (
12682 
  )
12683 
 
12684 
  def read(self, iprot):
12685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12687 
      return
12688 
    iprot.readStructBegin()
12689 
    while True:
12690 
      (fname, ftype, fid) = iprot.readFieldBegin()
12691 
      if ftype == TType.STOP:
12692 
        break
12693 
      else:
12694 
        iprot.skip(ftype)
12695 
      iprot.readFieldEnd()
12696 
    iprot.readStructEnd()
12697 
 
12698 
  def write(self, oprot):
12699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12701 
      return
12702 
    oprot.writeStructBegin('mergeCart_result')
12703 
    oprot.writeFieldStop()
12704 
    oprot.writeStructEnd()
12705 
 
3431 rajveer 12706 
  def validate(self):
12707 
    return
12708 
 
12709 
 
690 chandransh 12710 
  def __repr__(self):
12711 
    L = ['%s=%r' % (key, value)
12712 
      for key, value in self.__dict__.iteritems()]
12713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12714 
 
12715 
  def __eq__(self, other):
12716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12717 
 
12718 
  def __ne__(self, other):
12719 
    return not (self == other)
12720 
 
12721 
class checkOut_args:
12722 
  """
12723 
  Attributes:
575 chandransh 12724 
   - cartId
12725 
  """
12726 
 
12727 
  thrift_spec = (
12728 
    None, # 0
12729 
    (1, TType.I64, 'cartId', None, None, ), # 1
12730 
  )
12731 
 
12732 
  def __init__(self, cartId=None,):
12733 
    self.cartId = cartId
12734 
 
12735 
  def read(self, iprot):
12736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12738 
      return
12739 
    iprot.readStructBegin()
12740 
    while True:
12741 
      (fname, ftype, fid) = iprot.readFieldBegin()
12742 
      if ftype == TType.STOP:
12743 
        break
12744 
      if fid == 1:
12745 
        if ftype == TType.I64:
12746 
          self.cartId = iprot.readI64();
12747 
        else:
12748 
          iprot.skip(ftype)
12749 
      else:
12750 
        iprot.skip(ftype)
12751 
      iprot.readFieldEnd()
12752 
    iprot.readStructEnd()
12753 
 
12754 
  def write(self, oprot):
12755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12757 
      return
690 chandransh 12758 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12759 
    if self.cartId is not None:
575 chandransh 12760 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12761 
      oprot.writeI64(self.cartId)
12762 
      oprot.writeFieldEnd()
12763 
    oprot.writeFieldStop()
12764 
    oprot.writeStructEnd()
12765 
 
3431 rajveer 12766 
  def validate(self):
12767 
    return
12768 
 
12769 
 
575 chandransh 12770 
  def __repr__(self):
12771 
    L = ['%s=%r' % (key, value)
12772 
      for key, value in self.__dict__.iteritems()]
12773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12774 
 
12775 
  def __eq__(self, other):
12776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12777 
 
12778 
  def __ne__(self, other):
12779 
    return not (self == other)
12780 
 
690 chandransh 12781 
class checkOut_result:
575 chandransh 12782 
  """
12783 
  Attributes:
12784 
   - success
12785 
   - scex
12786 
  """
12787 
 
12788 
  thrift_spec = (
12789 
    (0, TType.BOOL, 'success', None, None, ), # 0
12790 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12791 
  )
12792 
 
12793 
  def __init__(self, success=None, scex=None,):
12794 
    self.success = success
12795 
    self.scex = scex
12796 
 
12797 
  def read(self, iprot):
12798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12800 
      return
12801 
    iprot.readStructBegin()
12802 
    while True:
12803 
      (fname, ftype, fid) = iprot.readFieldBegin()
12804 
      if ftype == TType.STOP:
12805 
        break
12806 
      if fid == 0:
12807 
        if ftype == TType.BOOL:
12808 
          self.success = iprot.readBool();
12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      elif fid == 1:
12812 
        if ftype == TType.STRUCT:
12813 
          self.scex = ShoppingCartException()
12814 
          self.scex.read(iprot)
12815 
        else:
12816 
          iprot.skip(ftype)
12817 
      else:
12818 
        iprot.skip(ftype)
12819 
      iprot.readFieldEnd()
12820 
    iprot.readStructEnd()
12821 
 
12822 
  def write(self, oprot):
12823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12825 
      return
690 chandransh 12826 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12827 
    if self.success is not None:
575 chandransh 12828 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12829 
      oprot.writeBool(self.success)
12830 
      oprot.writeFieldEnd()
3431 rajveer 12831 
    if self.scex is not None:
575 chandransh 12832 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12833 
      self.scex.write(oprot)
12834 
      oprot.writeFieldEnd()
12835 
    oprot.writeFieldStop()
12836 
    oprot.writeStructEnd()
12837 
 
3431 rajveer 12838 
  def validate(self):
12839 
    return
12840 
 
12841 
 
575 chandransh 12842 
  def __repr__(self):
12843 
    L = ['%s=%r' % (key, value)
12844 
      for key, value in self.__dict__.iteritems()]
12845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12846 
 
12847 
  def __eq__(self, other):
12848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12849 
 
12850 
  def __ne__(self, other):
12851 
    return not (self == other)
12852 
 
690 chandransh 12853 
class resetCart_args:
559 chandransh 12854 
  """
12855 
  Attributes:
690 chandransh 12856 
   - cartId
12857 
   - items
559 chandransh 12858 
  """
12859 
 
12860 
  thrift_spec = (
12861 
    None, # 0
690 chandransh 12862 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12863 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12864 
  )
12865 
 
690 chandransh 12866 
  def __init__(self, cartId=None, items=None,):
12867 
    self.cartId = cartId
12868 
    self.items = items
559 chandransh 12869 
 
12870 
  def read(self, iprot):
12871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12873 
      return
12874 
    iprot.readStructBegin()
12875 
    while True:
12876 
      (fname, ftype, fid) = iprot.readFieldBegin()
12877 
      if ftype == TType.STOP:
12878 
        break
12879 
      if fid == 1:
12880 
        if ftype == TType.I64:
690 chandransh 12881 
          self.cartId = iprot.readI64();
559 chandransh 12882 
        else:
12883 
          iprot.skip(ftype)
12884 
      elif fid == 2:
690 chandransh 12885 
        if ftype == TType.MAP:
12886 
          self.items = {}
11980 amit.gupta 12887 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12888 
          for _i185 in xrange(_size181):
12889 
            _key186 = iprot.readI64();
12890 
            _val187 = iprot.readDouble();
12891 
            self.items[_key186] = _val187
690 chandransh 12892 
          iprot.readMapEnd()
559 chandransh 12893 
        else:
12894 
          iprot.skip(ftype)
12895 
      else:
12896 
        iprot.skip(ftype)
12897 
      iprot.readFieldEnd()
12898 
    iprot.readStructEnd()
12899 
 
12900 
  def write(self, oprot):
12901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12903 
      return
690 chandransh 12904 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12905 
    if self.cartId is not None:
690 chandransh 12906 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12907 
      oprot.writeI64(self.cartId)
94 ashish 12908 
      oprot.writeFieldEnd()
3431 rajveer 12909 
    if self.items is not None:
690 chandransh 12910 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12911 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12912 
      for kiter188,viter189 in self.items.items():
12913 
        oprot.writeI64(kiter188)
12914 
        oprot.writeDouble(viter189)
690 chandransh 12915 
      oprot.writeMapEnd()
559 chandransh 12916 
      oprot.writeFieldEnd()
94 ashish 12917 
    oprot.writeFieldStop()
12918 
    oprot.writeStructEnd()
12919 
 
3431 rajveer 12920 
  def validate(self):
12921 
    return
12922 
 
12923 
 
94 ashish 12924 
  def __repr__(self):
12925 
    L = ['%s=%r' % (key, value)
12926 
      for key, value in self.__dict__.iteritems()]
12927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12928 
 
12929 
  def __eq__(self, other):
12930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12931 
 
12932 
  def __ne__(self, other):
12933 
    return not (self == other)
12934 
 
690 chandransh 12935 
class resetCart_result:
12936 
  """
12937 
  Attributes:
12938 
   - success
12939 
   - scex
12940 
  """
559 chandransh 12941 
 
12942 
  thrift_spec = (
690 chandransh 12943 
    (0, TType.BOOL, 'success', None, None, ), # 0
12944 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12945 
  )
12946 
 
690 chandransh 12947 
  def __init__(self, success=None, scex=None,):
12948 
    self.success = success
12949 
    self.scex = scex
12950 
 
559 chandransh 12951 
  def read(self, iprot):
12952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12954 
      return
12955 
    iprot.readStructBegin()
12956 
    while True:
12957 
      (fname, ftype, fid) = iprot.readFieldBegin()
12958 
      if ftype == TType.STOP:
12959 
        break
690 chandransh 12960 
      if fid == 0:
12961 
        if ftype == TType.BOOL:
12962 
          self.success = iprot.readBool();
12963 
        else:
12964 
          iprot.skip(ftype)
12965 
      elif fid == 1:
12966 
        if ftype == TType.STRUCT:
12967 
          self.scex = ShoppingCartException()
12968 
          self.scex.read(iprot)
12969 
        else:
12970 
          iprot.skip(ftype)
559 chandransh 12971 
      else:
12972 
        iprot.skip(ftype)
12973 
      iprot.readFieldEnd()
12974 
    iprot.readStructEnd()
12975 
 
12976 
  def write(self, oprot):
12977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12979 
      return
690 chandransh 12980 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12981 
    if self.success is not None:
690 chandransh 12982 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12983 
      oprot.writeBool(self.success)
12984 
      oprot.writeFieldEnd()
3431 rajveer 12985 
    if self.scex is not None:
690 chandransh 12986 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12987 
      self.scex.write(oprot)
12988 
      oprot.writeFieldEnd()
559 chandransh 12989 
    oprot.writeFieldStop()
12990 
    oprot.writeStructEnd()
12991 
 
3431 rajveer 12992 
  def validate(self):
12993 
    return
12994 
 
12995 
 
559 chandransh 12996 
  def __repr__(self):
12997 
    L = ['%s=%r' % (key, value)
12998 
      for key, value in self.__dict__.iteritems()]
12999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13000 
 
13001 
  def __eq__(self, other):
13002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13003 
 
13004 
  def __ne__(self, other):
13005 
    return not (self == other)
13006 
 
2981 rajveer 13007 
class getUserCount_args:
94 ashish 13008 
  """
13009 
  Attributes:
2981 rajveer 13010 
   - userType
559 chandransh 13011 
  """
13012 
 
13013 
  thrift_spec = (
13014 
    None, # 0
2981 rajveer 13015 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13016 
  )
13017 
 
2981 rajveer 13018 
  def __init__(self, userType=None,):
13019 
    self.userType = userType
559 chandransh 13020 
 
13021 
  def read(self, iprot):
13022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13024 
      return
13025 
    iprot.readStructBegin()
13026 
    while True:
13027 
      (fname, ftype, fid) = iprot.readFieldBegin()
13028 
      if ftype == TType.STOP:
13029 
        break
13030 
      if fid == 1:
2981 rajveer 13031 
        if ftype == TType.I32:
13032 
          self.userType = iprot.readI32();
559 chandransh 13033 
        else:
13034 
          iprot.skip(ftype)
13035 
      else:
13036 
        iprot.skip(ftype)
13037 
      iprot.readFieldEnd()
13038 
    iprot.readStructEnd()
13039 
 
13040 
  def write(self, oprot):
13041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13043 
      return
2981 rajveer 13044 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13045 
    if self.userType is not None:
2981 rajveer 13046 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13047 
      oprot.writeI32(self.userType)
559 chandransh 13048 
      oprot.writeFieldEnd()
13049 
    oprot.writeFieldStop()
13050 
    oprot.writeStructEnd()
13051 
 
3431 rajveer 13052 
  def validate(self):
13053 
    return
13054 
 
13055 
 
559 chandransh 13056 
  def __repr__(self):
13057 
    L = ['%s=%r' % (key, value)
13058 
      for key, value in self.__dict__.iteritems()]
13059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13060 
 
13061 
  def __eq__(self, other):
13062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13063 
 
13064 
  def __ne__(self, other):
13065 
    return not (self == other)
13066 
 
2981 rajveer 13067 
class getUserCount_result:
94 ashish 13068 
  """
13069 
  Attributes:
13070 
   - success
13071 
  """
13072 
 
13073 
  thrift_spec = (
2981 rajveer 13074 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13075 
  )
13076 
 
2981 rajveer 13077 
  def __init__(self, success=None,):
94 ashish 13078 
    self.success = success
13079 
 
13080 
  def read(self, iprot):
13081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13083 
      return
13084 
    iprot.readStructBegin()
13085 
    while True:
13086 
      (fname, ftype, fid) = iprot.readFieldBegin()
13087 
      if ftype == TType.STOP:
13088 
        break
13089 
      if fid == 0:
2981 rajveer 13090 
        if ftype == TType.I64:
13091 
          self.success = iprot.readI64();
94 ashish 13092 
        else:
13093 
          iprot.skip(ftype)
13094 
      else:
13095 
        iprot.skip(ftype)
13096 
      iprot.readFieldEnd()
13097 
    iprot.readStructEnd()
13098 
 
13099 
  def write(self, oprot):
13100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13102 
      return
2981 rajveer 13103 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13104 
    if self.success is not None:
2981 rajveer 13105 
      oprot.writeFieldBegin('success', TType.I64, 0)
13106 
      oprot.writeI64(self.success)
94 ashish 13107 
      oprot.writeFieldEnd()
13108 
    oprot.writeFieldStop()
13109 
    oprot.writeStructEnd()
13110 
 
3431 rajveer 13111 
  def validate(self):
13112 
    return
13113 
 
13114 
 
94 ashish 13115 
  def __repr__(self):
13116 
    L = ['%s=%r' % (key, value)
13117 
      for key, value in self.__dict__.iteritems()]
13118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13119 
 
13120 
  def __eq__(self, other):
13121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13122 
 
13123 
  def __ne__(self, other):
13124 
    return not (self == other)
13125 
 
2981 rajveer 13126 
class getAllUsers_args:
94 ashish 13127 
  """
13128 
  Attributes:
2981 rajveer 13129 
   - userType
13130 
   - startDate
13131 
   - endDate
94 ashish 13132 
  """
13133 
 
13134 
  thrift_spec = (
13135 
    None, # 0
2981 rajveer 13136 
    (1, TType.I32, 'userType', None, None, ), # 1
13137 
    (2, TType.I64, 'startDate', None, None, ), # 2
13138 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13139 
  )
13140 
 
2981 rajveer 13141 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13142 
    self.userType = userType
13143 
    self.startDate = startDate
13144 
    self.endDate = endDate
94 ashish 13145 
 
13146 
  def read(self, iprot):
13147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13149 
      return
13150 
    iprot.readStructBegin()
13151 
    while True:
13152 
      (fname, ftype, fid) = iprot.readFieldBegin()
13153 
      if ftype == TType.STOP:
13154 
        break
13155 
      if fid == 1:
2981 rajveer 13156 
        if ftype == TType.I32:
13157 
          self.userType = iprot.readI32();
94 ashish 13158 
        else:
13159 
          iprot.skip(ftype)
13160 
      elif fid == 2:
559 chandransh 13161 
        if ftype == TType.I64:
2981 rajveer 13162 
          self.startDate = iprot.readI64();
94 ashish 13163 
        else:
13164 
          iprot.skip(ftype)
2981 rajveer 13165 
      elif fid == 3:
13166 
        if ftype == TType.I64:
13167 
          self.endDate = iprot.readI64();
13168 
        else:
13169 
          iprot.skip(ftype)
94 ashish 13170 
      else:
13171 
        iprot.skip(ftype)
13172 
      iprot.readFieldEnd()
13173 
    iprot.readStructEnd()
13174 
 
13175 
  def write(self, oprot):
13176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13178 
      return
2981 rajveer 13179 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13180 
    if self.userType is not None:
2981 rajveer 13181 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13182 
      oprot.writeI32(self.userType)
94 ashish 13183 
      oprot.writeFieldEnd()
3431 rajveer 13184 
    if self.startDate is not None:
2981 rajveer 13185 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13186 
      oprot.writeI64(self.startDate)
94 ashish 13187 
      oprot.writeFieldEnd()
3431 rajveer 13188 
    if self.endDate is not None:
2981 rajveer 13189 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13190 
      oprot.writeI64(self.endDate)
13191 
      oprot.writeFieldEnd()
94 ashish 13192 
    oprot.writeFieldStop()
13193 
    oprot.writeStructEnd()
13194 
 
3431 rajveer 13195 
  def validate(self):
13196 
    return
13197 
 
13198 
 
94 ashish 13199 
  def __repr__(self):
13200 
    L = ['%s=%r' % (key, value)
13201 
      for key, value in self.__dict__.iteritems()]
13202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13203 
 
13204 
  def __eq__(self, other):
13205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13206 
 
13207 
  def __ne__(self, other):
13208 
    return not (self == other)
13209 
 
2981 rajveer 13210 
class getAllUsers_result:
94 ashish 13211 
  """
13212 
  Attributes:
13213 
   - success
13214 
  """
13215 
 
13216 
  thrift_spec = (
2981 rajveer 13217 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13218 
  )
13219 
 
2981 rajveer 13220 
  def __init__(self, success=None,):
94 ashish 13221 
    self.success = success
13222 
 
13223 
  def read(self, iprot):
13224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13226 
      return
13227 
    iprot.readStructBegin()
13228 
    while True:
13229 
      (fname, ftype, fid) = iprot.readFieldBegin()
13230 
      if ftype == TType.STOP:
13231 
        break
13232 
      if fid == 0:
2981 rajveer 13233 
        if ftype == TType.LIST:
13234 
          self.success = []
11980 amit.gupta 13235 
          (_etype193, _size190) = iprot.readListBegin()
13236 
          for _i194 in xrange(_size190):
13237 
            _elem195 = User()
13238 
            _elem195.read(iprot)
13239 
            self.success.append(_elem195)
2981 rajveer 13240 
          iprot.readListEnd()
94 ashish 13241 
        else:
13242 
          iprot.skip(ftype)
13243 
      else:
13244 
        iprot.skip(ftype)
13245 
      iprot.readFieldEnd()
13246 
    iprot.readStructEnd()
13247 
 
13248 
  def write(self, oprot):
13249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13251 
      return
2981 rajveer 13252 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13253 
    if self.success is not None:
2981 rajveer 13254 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13255 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13256 
      for iter196 in self.success:
13257 
        iter196.write(oprot)
2981 rajveer 13258 
      oprot.writeListEnd()
94 ashish 13259 
      oprot.writeFieldEnd()
13260 
    oprot.writeFieldStop()
13261 
    oprot.writeStructEnd()
13262 
 
3431 rajveer 13263 
  def validate(self):
13264 
    return
13265 
 
13266 
 
94 ashish 13267 
  def __repr__(self):
13268 
    L = ['%s=%r' % (key, value)
13269 
      for key, value in self.__dict__.iteritems()]
13270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13271 
 
13272 
  def __eq__(self, other):
13273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13274 
 
13275 
  def __ne__(self, other):
13276 
    return not (self == other)
13277 
 
2981 rajveer 13278 
class getMyResearchItems_args:
559 chandransh 13279 
  """
13280 
  Attributes:
772 rajveer 13281 
   - userId
559 chandransh 13282 
  """
13283 
 
13284 
  thrift_spec = (
13285 
    None, # 0
772 rajveer 13286 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13287 
  )
13288 
 
772 rajveer 13289 
  def __init__(self, userId=None,):
13290 
    self.userId = userId
559 chandransh 13291 
 
13292 
  def read(self, iprot):
13293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13295 
      return
13296 
    iprot.readStructBegin()
13297 
    while True:
13298 
      (fname, ftype, fid) = iprot.readFieldBegin()
13299 
      if ftype == TType.STOP:
13300 
        break
13301 
      if fid == 1:
13302 
        if ftype == TType.I64:
772 rajveer 13303 
          self.userId = iprot.readI64();
559 chandransh 13304 
        else:
13305 
          iprot.skip(ftype)
13306 
      else:
13307 
        iprot.skip(ftype)
13308 
      iprot.readFieldEnd()
13309 
    iprot.readStructEnd()
13310 
 
13311 
  def write(self, oprot):
13312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13314 
      return
2981 rajveer 13315 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13316 
    if self.userId is not None:
772 rajveer 13317 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13318 
      oprot.writeI64(self.userId)
559 chandransh 13319 
      oprot.writeFieldEnd()
13320 
    oprot.writeFieldStop()
13321 
    oprot.writeStructEnd()
13322 
 
3431 rajveer 13323 
  def validate(self):
13324 
    return
13325 
 
13326 
 
559 chandransh 13327 
  def __repr__(self):
13328 
    L = ['%s=%r' % (key, value)
13329 
      for key, value in self.__dict__.iteritems()]
13330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13331 
 
13332 
  def __eq__(self, other):
13333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13334 
 
13335 
  def __ne__(self, other):
13336 
    return not (self == other)
13337 
 
2981 rajveer 13338 
class getMyResearchItems_result:
559 chandransh 13339 
  """
13340 
  Attributes:
130 ashish 13341 
   - success
559 chandransh 13342 
   - scx
130 ashish 13343 
  """
13344 
 
13345 
  thrift_spec = (
2981 rajveer 13346 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13347 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13348 
  )
13349 
 
559 chandransh 13350 
  def __init__(self, success=None, scx=None,):
130 ashish 13351 
    self.success = success
559 chandransh 13352 
    self.scx = scx
130 ashish 13353 
 
13354 
  def read(self, iprot):
13355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13357 
      return
13358 
    iprot.readStructBegin()
13359 
    while True:
13360 
      (fname, ftype, fid) = iprot.readFieldBegin()
13361 
      if ftype == TType.STOP:
13362 
        break
13363 
      if fid == 0:
2981 rajveer 13364 
        if ftype == TType.LIST:
13365 
          self.success = []
11980 amit.gupta 13366 
          (_etype200, _size197) = iprot.readListBegin()
13367 
          for _i201 in xrange(_size197):
13368 
            _elem202 = iprot.readI64();
13369 
            self.success.append(_elem202)
2981 rajveer 13370 
          iprot.readListEnd()
130 ashish 13371 
        else:
13372 
          iprot.skip(ftype)
13373 
      elif fid == 1:
13374 
        if ftype == TType.STRUCT:
559 chandransh 13375 
          self.scx = WidgetException()
13376 
          self.scx.read(iprot)
130 ashish 13377 
        else:
13378 
          iprot.skip(ftype)
13379 
      else:
13380 
        iprot.skip(ftype)
13381 
      iprot.readFieldEnd()
13382 
    iprot.readStructEnd()
13383 
 
13384 
  def write(self, oprot):
13385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13387 
      return
2981 rajveer 13388 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13389 
    if self.success is not None:
2981 rajveer 13390 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13391 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13392 
      for iter203 in self.success:
13393 
        oprot.writeI64(iter203)
2981 rajveer 13394 
      oprot.writeListEnd()
130 ashish 13395 
      oprot.writeFieldEnd()
3431 rajveer 13396 
    if self.scx is not None:
559 chandransh 13397 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13398 
      self.scx.write(oprot)
130 ashish 13399 
      oprot.writeFieldEnd()
13400 
    oprot.writeFieldStop()
13401 
    oprot.writeStructEnd()
13402 
 
3431 rajveer 13403 
  def validate(self):
13404 
    return
13405 
 
13406 
 
130 ashish 13407 
  def __repr__(self):
13408 
    L = ['%s=%r' % (key, value)
13409 
      for key, value in self.__dict__.iteritems()]
13410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13411 
 
13412 
  def __eq__(self, other):
13413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13414 
 
13415 
  def __ne__(self, other):
13416 
    return not (self == other)
13417 
 
2981 rajveer 13418 
class updateMyResearch_args:
130 ashish 13419 
  """
13420 
  Attributes:
2981 rajveer 13421 
   - userId
13422 
   - itemId
130 ashish 13423 
  """
13424 
 
13425 
  thrift_spec = (
13426 
    None, # 0
2981 rajveer 13427 
    (1, TType.I64, 'userId', None, None, ), # 1
13428 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13429 
  )
13430 
 
2981 rajveer 13431 
  def __init__(self, userId=None, itemId=None,):
13432 
    self.userId = userId
13433 
    self.itemId = itemId
130 ashish 13434 
 
13435 
  def read(self, iprot):
13436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13438 
      return
13439 
    iprot.readStructBegin()
13440 
    while True:
13441 
      (fname, ftype, fid) = iprot.readFieldBegin()
13442 
      if ftype == TType.STOP:
13443 
        break
13444 
      if fid == 1:
559 chandransh 13445 
        if ftype == TType.I64:
2981 rajveer 13446 
          self.userId = iprot.readI64();
130 ashish 13447 
        else:
13448 
          iprot.skip(ftype)
13449 
      elif fid == 2:
559 chandransh 13450 
        if ftype == TType.I64:
2981 rajveer 13451 
          self.itemId = iprot.readI64();
559 chandransh 13452 
        else:
13453 
          iprot.skip(ftype)
130 ashish 13454 
      else:
13455 
        iprot.skip(ftype)
13456 
      iprot.readFieldEnd()
13457 
    iprot.readStructEnd()
13458 
 
13459 
  def write(self, oprot):
13460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13462 
      return
2981 rajveer 13463 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13464 
    if self.userId is not None:
2981 rajveer 13465 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13466 
      oprot.writeI64(self.userId)
130 ashish 13467 
      oprot.writeFieldEnd()
3431 rajveer 13468 
    if self.itemId is not None:
2981 rajveer 13469 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13470 
      oprot.writeI64(self.itemId)
130 ashish 13471 
      oprot.writeFieldEnd()
13472 
    oprot.writeFieldStop()
13473 
    oprot.writeStructEnd()
13474 
 
3431 rajveer 13475 
  def validate(self):
13476 
    return
13477 
 
13478 
 
130 ashish 13479 
  def __repr__(self):
13480 
    L = ['%s=%r' % (key, value)
13481 
      for key, value in self.__dict__.iteritems()]
13482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13483 
 
13484 
  def __eq__(self, other):
13485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13486 
 
13487 
  def __ne__(self, other):
13488 
    return not (self == other)
13489 
 
2981 rajveer 13490 
class updateMyResearch_result:
13491 
  """
13492 
  Attributes:
13493 
   - success
13494 
   - scx
13495 
  """
559 chandransh 13496 
 
13497 
  thrift_spec = (
2981 rajveer 13498 
    (0, TType.BOOL, 'success', None, None, ), # 0
13499 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13500 
  )
13501 
 
2981 rajveer 13502 
  def __init__(self, success=None, scx=None,):
13503 
    self.success = success
13504 
    self.scx = scx
13505 
 
559 chandransh 13506 
  def read(self, iprot):
13507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13509 
      return
13510 
    iprot.readStructBegin()
13511 
    while True:
13512 
      (fname, ftype, fid) = iprot.readFieldBegin()
13513 
      if ftype == TType.STOP:
13514 
        break
2981 rajveer 13515 
      if fid == 0:
13516 
        if ftype == TType.BOOL:
13517 
          self.success = iprot.readBool();
13518 
        else:
13519 
          iprot.skip(ftype)
13520 
      elif fid == 1:
13521 
        if ftype == TType.STRUCT:
13522 
          self.scx = WidgetException()
13523 
          self.scx.read(iprot)
13524 
        else:
13525 
          iprot.skip(ftype)
559 chandransh 13526 
      else:
13527 
        iprot.skip(ftype)
13528 
      iprot.readFieldEnd()
13529 
    iprot.readStructEnd()
13530 
 
13531 
  def write(self, oprot):
13532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13534 
      return
2981 rajveer 13535 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13536 
    if self.success is not None:
2981 rajveer 13537 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13538 
      oprot.writeBool(self.success)
13539 
      oprot.writeFieldEnd()
3431 rajveer 13540 
    if self.scx is not None:
2981 rajveer 13541 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13542 
      self.scx.write(oprot)
13543 
      oprot.writeFieldEnd()
559 chandransh 13544 
    oprot.writeFieldStop()
13545 
    oprot.writeStructEnd()
13546 
 
3431 rajveer 13547 
  def validate(self):
13548 
    return
13549 
 
13550 
 
559 chandransh 13551 
  def __repr__(self):
13552 
    L = ['%s=%r' % (key, value)
13553 
      for key, value in self.__dict__.iteritems()]
13554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13555 
 
13556 
  def __eq__(self, other):
13557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13558 
 
13559 
  def __ne__(self, other):
13560 
    return not (self == other)
13561 
 
2981 rajveer 13562 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13563 
  """
13564 
  Attributes:
2981 rajveer 13565 
   - userId
13566 
   - itemId
1596 ankur.sing 13567 
  """
559 chandransh 13568 
 
1596 ankur.sing 13569 
  thrift_spec = (
13570 
    None, # 0
2981 rajveer 13571 
    (1, TType.I64, 'userId', None, None, ), # 1
13572 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13573 
  )
13574 
 
2981 rajveer 13575 
  def __init__(self, userId=None, itemId=None,):
13576 
    self.userId = userId
13577 
    self.itemId = itemId
1596 ankur.sing 13578 
 
13579 
  def read(self, iprot):
13580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13582 
      return
13583 
    iprot.readStructBegin()
13584 
    while True:
13585 
      (fname, ftype, fid) = iprot.readFieldBegin()
13586 
      if ftype == TType.STOP:
13587 
        break
13588 
      if fid == 1:
2981 rajveer 13589 
        if ftype == TType.I64:
13590 
          self.userId = iprot.readI64();
1596 ankur.sing 13591 
        else:
13592 
          iprot.skip(ftype)
2981 rajveer 13593 
      elif fid == 2:
13594 
        if ftype == TType.I64:
13595 
          self.itemId = iprot.readI64();
13596 
        else:
13597 
          iprot.skip(ftype)
1596 ankur.sing 13598 
      else:
13599 
        iprot.skip(ftype)
13600 
      iprot.readFieldEnd()
13601 
    iprot.readStructEnd()
13602 
 
13603 
  def write(self, oprot):
13604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13606 
      return
2981 rajveer 13607 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13608 
    if self.userId is not None:
2981 rajveer 13609 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13610 
      oprot.writeI64(self.userId)
1596 ankur.sing 13611 
      oprot.writeFieldEnd()
3431 rajveer 13612 
    if self.itemId is not None:
2981 rajveer 13613 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13614 
      oprot.writeI64(self.itemId)
13615 
      oprot.writeFieldEnd()
1596 ankur.sing 13616 
    oprot.writeFieldStop()
13617 
    oprot.writeStructEnd()
13618 
 
3431 rajveer 13619 
  def validate(self):
13620 
    return
13621 
 
13622 
 
1596 ankur.sing 13623 
  def __repr__(self):
13624 
    L = ['%s=%r' % (key, value)
13625 
      for key, value in self.__dict__.iteritems()]
13626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13627 
 
13628 
  def __eq__(self, other):
13629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13630 
 
13631 
  def __ne__(self, other):
13632 
    return not (self == other)
13633 
 
2981 rajveer 13634 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13635 
  """
13636 
  Attributes:
2981 rajveer 13637 
   - scx
1596 ankur.sing 13638 
  """
13639 
 
13640 
  thrift_spec = (
2981 rajveer 13641 
    None, # 0
13642 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13643 
  )
13644 
 
2981 rajveer 13645 
  def __init__(self, scx=None,):
13646 
    self.scx = scx
1596 ankur.sing 13647 
 
13648 
  def read(self, iprot):
13649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13651 
      return
13652 
    iprot.readStructBegin()
13653 
    while True:
13654 
      (fname, ftype, fid) = iprot.readFieldBegin()
13655 
      if ftype == TType.STOP:
13656 
        break
2981 rajveer 13657 
      if fid == 1:
13658 
        if ftype == TType.STRUCT:
13659 
          self.scx = WidgetException()
13660 
          self.scx.read(iprot)
1596 ankur.sing 13661 
        else:
13662 
          iprot.skip(ftype)
13663 
      else:
13664 
        iprot.skip(ftype)
13665 
      iprot.readFieldEnd()
13666 
    iprot.readStructEnd()
13667 
 
13668 
  def write(self, oprot):
13669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13671 
      return
2981 rajveer 13672 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13673 
    if self.scx is not None:
2981 rajveer 13674 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13675 
      self.scx.write(oprot)
1596 ankur.sing 13676 
      oprot.writeFieldEnd()
13677 
    oprot.writeFieldStop()
13678 
    oprot.writeStructEnd()
13679 
 
3431 rajveer 13680 
  def validate(self):
13681 
    return
13682 
 
13683 
 
1596 ankur.sing 13684 
  def __repr__(self):
13685 
    L = ['%s=%r' % (key, value)
13686 
      for key, value in self.__dict__.iteritems()]
13687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13688 
 
13689 
  def __eq__(self, other):
13690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13691 
 
13692 
  def __ne__(self, other):
13693 
    return not (self == other)
13694 
 
2981 rajveer 13695 
class getBrowseHistoryItems_args:
1673 ankur.sing 13696 
  """
13697 
  Attributes:
2981 rajveer 13698 
   - userId
1673 ankur.sing 13699 
  """
1596 ankur.sing 13700 
 
1673 ankur.sing 13701 
  thrift_spec = (
13702 
    None, # 0
2981 rajveer 13703 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13704 
  )
13705 
 
2981 rajveer 13706 
  def __init__(self, userId=None,):
13707 
    self.userId = userId
1673 ankur.sing 13708 
 
13709 
  def read(self, iprot):
13710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13712 
      return
13713 
    iprot.readStructBegin()
13714 
    while True:
13715 
      (fname, ftype, fid) = iprot.readFieldBegin()
13716 
      if ftype == TType.STOP:
13717 
        break
13718 
      if fid == 1:
1891 ankur.sing 13719 
        if ftype == TType.I64:
2981 rajveer 13720 
          self.userId = iprot.readI64();
1891 ankur.sing 13721 
        else:
13722 
          iprot.skip(ftype)
1673 ankur.sing 13723 
      else:
13724 
        iprot.skip(ftype)
13725 
      iprot.readFieldEnd()
13726 
    iprot.readStructEnd()
13727 
 
13728 
  def write(self, oprot):
13729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13731 
      return
2981 rajveer 13732 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13733 
    if self.userId is not None:
2981 rajveer 13734 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13735 
      oprot.writeI64(self.userId)
1673 ankur.sing 13736 
      oprot.writeFieldEnd()
13737 
    oprot.writeFieldStop()
13738 
    oprot.writeStructEnd()
13739 
 
3431 rajveer 13740 
  def validate(self):
13741 
    return
13742 
 
13743 
 
1673 ankur.sing 13744 
  def __repr__(self):
13745 
    L = ['%s=%r' % (key, value)
13746 
      for key, value in self.__dict__.iteritems()]
13747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13748 
 
13749 
  def __eq__(self, other):
13750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13751 
 
13752 
  def __ne__(self, other):
13753 
    return not (self == other)
13754 
 
2981 rajveer 13755 
class getBrowseHistoryItems_result:
1673 ankur.sing 13756 
  """
13757 
  Attributes:
13758 
   - success
2981 rajveer 13759 
   - scx
1673 ankur.sing 13760 
  """
13761 
 
13762 
  thrift_spec = (
2981 rajveer 13763 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13764 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13765 
  )
13766 
 
2981 rajveer 13767 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13768 
    self.success = success
2981 rajveer 13769 
    self.scx = scx
1673 ankur.sing 13770 
 
13771 
  def read(self, iprot):
13772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13774 
      return
13775 
    iprot.readStructBegin()
13776 
    while True:
13777 
      (fname, ftype, fid) = iprot.readFieldBegin()
13778 
      if ftype == TType.STOP:
13779 
        break
13780 
      if fid == 0:
13781 
        if ftype == TType.LIST:
13782 
          self.success = []
11980 amit.gupta 13783 
          (_etype207, _size204) = iprot.readListBegin()
13784 
          for _i208 in xrange(_size204):
13785 
            _elem209 = iprot.readI64();
13786 
            self.success.append(_elem209)
1673 ankur.sing 13787 
          iprot.readListEnd()
13788 
        else:
13789 
          iprot.skip(ftype)
2981 rajveer 13790 
      elif fid == 1:
13791 
        if ftype == TType.STRUCT:
13792 
          self.scx = WidgetException()
13793 
          self.scx.read(iprot)
13794 
        else:
13795 
          iprot.skip(ftype)
1673 ankur.sing 13796 
      else:
13797 
        iprot.skip(ftype)
13798 
      iprot.readFieldEnd()
13799 
    iprot.readStructEnd()
13800 
 
13801 
  def write(self, oprot):
13802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13804 
      return
2981 rajveer 13805 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13806 
    if self.success is not None:
1673 ankur.sing 13807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13808 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13809 
      for iter210 in self.success:
13810 
        oprot.writeI64(iter210)
1673 ankur.sing 13811 
      oprot.writeListEnd()
13812 
      oprot.writeFieldEnd()
3431 rajveer 13813 
    if self.scx is not None:
2981 rajveer 13814 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13815 
      self.scx.write(oprot)
2642 varun.gupt 13816 
      oprot.writeFieldEnd()
13817 
    oprot.writeFieldStop()
13818 
    oprot.writeStructEnd()
13819 
 
3431 rajveer 13820 
  def validate(self):
13821 
    return
13822 
 
13823 
 
2642 varun.gupt 13824 
  def __repr__(self):
13825 
    L = ['%s=%r' % (key, value)
13826 
      for key, value in self.__dict__.iteritems()]
13827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13828 
 
13829 
  def __eq__(self, other):
13830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13831 
 
13832 
  def __ne__(self, other):
13833 
    return not (self == other)
13834 
 
2981 rajveer 13835 
class updateBrowseHistory_args:
2642 varun.gupt 13836 
  """
13837 
  Attributes:
2981 rajveer 13838 
   - userId
13839 
   - itemId
2642 varun.gupt 13840 
  """
13841 
 
13842 
  thrift_spec = (
13843 
    None, # 0
2981 rajveer 13844 
    (1, TType.I64, 'userId', None, None, ), # 1
13845 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13846 
  )
13847 
 
2981 rajveer 13848 
  def __init__(self, userId=None, itemId=None,):
13849 
    self.userId = userId
13850 
    self.itemId = itemId
2642 varun.gupt 13851 
 
13852 
  def read(self, iprot):
13853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13855 
      return
13856 
    iprot.readStructBegin()
13857 
    while True:
13858 
      (fname, ftype, fid) = iprot.readFieldBegin()
13859 
      if ftype == TType.STOP:
13860 
        break
13861 
      if fid == 1:
13862 
        if ftype == TType.I64:
2981 rajveer 13863 
          self.userId = iprot.readI64();
2642 varun.gupt 13864 
        else:
13865 
          iprot.skip(ftype)
13866 
      elif fid == 2:
13867 
        if ftype == TType.I64:
2981 rajveer 13868 
          self.itemId = iprot.readI64();
2642 varun.gupt 13869 
        else:
13870 
          iprot.skip(ftype)
13871 
      else:
13872 
        iprot.skip(ftype)
13873 
      iprot.readFieldEnd()
13874 
    iprot.readStructEnd()
13875 
 
13876 
  def write(self, oprot):
13877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13879 
      return
2981 rajveer 13880 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13881 
    if self.userId is not None:
2981 rajveer 13882 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13883 
      oprot.writeI64(self.userId)
2642 varun.gupt 13884 
      oprot.writeFieldEnd()
3431 rajveer 13885 
    if self.itemId is not None:
2981 rajveer 13886 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13887 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13888 
      oprot.writeFieldEnd()
13889 
    oprot.writeFieldStop()
13890 
    oprot.writeStructEnd()
13891 
 
3431 rajveer 13892 
  def validate(self):
13893 
    return
13894 
 
13895 
 
2642 varun.gupt 13896 
  def __repr__(self):
13897 
    L = ['%s=%r' % (key, value)
13898 
      for key, value in self.__dict__.iteritems()]
13899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13900 
 
13901 
  def __eq__(self, other):
13902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13903 
 
13904 
  def __ne__(self, other):
13905 
    return not (self == other)
13906 
 
2981 rajveer 13907 
class updateBrowseHistory_result:
2642 varun.gupt 13908 
 
13909 
  thrift_spec = (
13910 
  )
13911 
 
13912 
  def read(self, iprot):
13913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13915 
      return
13916 
    iprot.readStructBegin()
13917 
    while True:
13918 
      (fname, ftype, fid) = iprot.readFieldBegin()
13919 
      if ftype == TType.STOP:
13920 
        break
13921 
      else:
13922 
        iprot.skip(ftype)
13923 
      iprot.readFieldEnd()
13924 
    iprot.readStructEnd()
13925 
 
13926 
  def write(self, oprot):
13927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13929 
      return
2981 rajveer 13930 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13931 
    oprot.writeFieldStop()
13932 
    oprot.writeStructEnd()
13933 
 
3431 rajveer 13934 
  def validate(self):
13935 
    return
13936 
 
13937 
 
2642 varun.gupt 13938 
  def __repr__(self):
13939 
    L = ['%s=%r' % (key, value)
13940 
      for key, value in self.__dict__.iteritems()]
13941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13942 
 
13943 
  def __eq__(self, other):
13944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13945 
 
13946 
  def __ne__(self, other):
13947 
    return not (self == other)
13948 
 
3385 varun.gupt 13949 
class getCartsWithCouponCount_args:
13950 
  """
13951 
  Attributes:
13952 
   - couponCode
13953 
  """
2642 varun.gupt 13954 
 
3385 varun.gupt 13955 
  thrift_spec = (
13956 
    None, # 0
13957 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13958 
  )
13959 
 
13960 
  def __init__(self, couponCode=None,):
13961 
    self.couponCode = couponCode
13962 
 
13963 
  def read(self, iprot):
13964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13966 
      return
13967 
    iprot.readStructBegin()
13968 
    while True:
13969 
      (fname, ftype, fid) = iprot.readFieldBegin()
13970 
      if ftype == TType.STOP:
13971 
        break
13972 
      if fid == 1:
13973 
        if ftype == TType.STRING:
13974 
          self.couponCode = iprot.readString();
13975 
        else:
13976 
          iprot.skip(ftype)
13977 
      else:
13978 
        iprot.skip(ftype)
13979 
      iprot.readFieldEnd()
13980 
    iprot.readStructEnd()
13981 
 
13982 
  def write(self, oprot):
13983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13985 
      return
13986 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13987 
    if self.couponCode is not None:
3385 varun.gupt 13988 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13989 
      oprot.writeString(self.couponCode)
13990 
      oprot.writeFieldEnd()
13991 
    oprot.writeFieldStop()
13992 
    oprot.writeStructEnd()
13993 
 
3431 rajveer 13994 
  def validate(self):
13995 
    return
13996 
 
13997 
 
3385 varun.gupt 13998 
  def __repr__(self):
13999 
    L = ['%s=%r' % (key, value)
14000 
      for key, value in self.__dict__.iteritems()]
14001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14002 
 
14003 
  def __eq__(self, other):
14004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14005 
 
14006 
  def __ne__(self, other):
14007 
    return not (self == other)
14008 
 
14009 
class getCartsWithCouponCount_result:
14010 
  """
14011 
  Attributes:
14012 
   - success
14013 
  """
14014 
 
14015 
  thrift_spec = (
14016 
    (0, TType.I64, 'success', None, None, ), # 0
14017 
  )
14018 
 
14019 
  def __init__(self, success=None,):
14020 
    self.success = success
14021 
 
14022 
  def read(self, iprot):
14023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14025 
      return
14026 
    iprot.readStructBegin()
14027 
    while True:
14028 
      (fname, ftype, fid) = iprot.readFieldBegin()
14029 
      if ftype == TType.STOP:
14030 
        break
14031 
      if fid == 0:
14032 
        if ftype == TType.I64:
14033 
          self.success = iprot.readI64();
14034 
        else:
14035 
          iprot.skip(ftype)
14036 
      else:
14037 
        iprot.skip(ftype)
14038 
      iprot.readFieldEnd()
14039 
    iprot.readStructEnd()
14040 
 
14041 
  def write(self, oprot):
14042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14044 
      return
14045 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14046 
    if self.success is not None:
3385 varun.gupt 14047 
      oprot.writeFieldBegin('success', TType.I64, 0)
14048 
      oprot.writeI64(self.success)
14049 
      oprot.writeFieldEnd()
14050 
    oprot.writeFieldStop()
14051 
    oprot.writeStructEnd()
14052 
 
3431 rajveer 14053 
  def validate(self):
14054 
    return
14055 
 
14056 
 
3385 varun.gupt 14057 
  def __repr__(self):
14058 
    L = ['%s=%r' % (key, value)
14059 
      for key, value in self.__dict__.iteritems()]
14060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14061 
 
14062 
  def __eq__(self, other):
14063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14064 
 
14065 
  def __ne__(self, other):
14066 
    return not (self == other)
3499 mandeep.dh 14067 
 
14068 
class increaseTrustLevel_args:
14069 
  """
14070 
  Attributes:
14071 
   - userId
14072 
   - trustLevelDelta
14073 
  """
14074 
 
14075 
  thrift_spec = (
14076 
    None, # 0
14077 
    (1, TType.I64, 'userId', None, None, ), # 1
14078 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14079 
  )
14080 
 
14081 
  def __init__(self, userId=None, trustLevelDelta=None,):
14082 
    self.userId = userId
14083 
    self.trustLevelDelta = trustLevelDelta
14084 
 
14085 
  def read(self, iprot):
14086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14088 
      return
14089 
    iprot.readStructBegin()
14090 
    while True:
14091 
      (fname, ftype, fid) = iprot.readFieldBegin()
14092 
      if ftype == TType.STOP:
14093 
        break
14094 
      if fid == 1:
14095 
        if ftype == TType.I64:
14096 
          self.userId = iprot.readI64();
14097 
        else:
14098 
          iprot.skip(ftype)
14099 
      elif fid == 2:
14100 
        if ftype == TType.DOUBLE:
14101 
          self.trustLevelDelta = iprot.readDouble();
14102 
        else:
14103 
          iprot.skip(ftype)
14104 
      else:
14105 
        iprot.skip(ftype)
14106 
      iprot.readFieldEnd()
14107 
    iprot.readStructEnd()
14108 
 
14109 
  def write(self, oprot):
14110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14112 
      return
14113 
    oprot.writeStructBegin('increaseTrustLevel_args')
14114 
    if self.userId is not None:
14115 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14116 
      oprot.writeI64(self.userId)
14117 
      oprot.writeFieldEnd()
14118 
    if self.trustLevelDelta is not None:
14119 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14120 
      oprot.writeDouble(self.trustLevelDelta)
14121 
      oprot.writeFieldEnd()
14122 
    oprot.writeFieldStop()
14123 
    oprot.writeStructEnd()
14124 
 
14125 
  def validate(self):
14126 
    return
14127 
 
14128 
 
14129 
  def __repr__(self):
14130 
    L = ['%s=%r' % (key, value)
14131 
      for key, value in self.__dict__.iteritems()]
14132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14133 
 
14134 
  def __eq__(self, other):
14135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14136 
 
14137 
  def __ne__(self, other):
14138 
    return not (self == other)
4668 varun.gupt 14139 
 
5407 amar.kumar 14140 
class getTrustLevel_args:
14141 
  """
14142 
  Attributes:
14143 
   - userId
14144 
  """
14145 
 
14146 
  thrift_spec = (
14147 
    None, # 0
14148 
    (1, TType.I64, 'userId', None, None, ), # 1
14149 
  )
14150 
 
14151 
  def __init__(self, userId=None,):
14152 
    self.userId = userId
14153 
 
14154 
  def read(self, iprot):
14155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14157 
      return
14158 
    iprot.readStructBegin()
14159 
    while True:
14160 
      (fname, ftype, fid) = iprot.readFieldBegin()
14161 
      if ftype == TType.STOP:
14162 
        break
14163 
      if fid == 1:
14164 
        if ftype == TType.I64:
14165 
          self.userId = iprot.readI64();
14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
14177 
    oprot.writeStructBegin('getTrustLevel_args')
14178 
    if self.userId is not None:
14179 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14180 
      oprot.writeI64(self.userId)
14181 
      oprot.writeFieldEnd()
14182 
    oprot.writeFieldStop()
14183 
    oprot.writeStructEnd()
14184 
 
14185 
  def validate(self):
14186 
    return
14187 
 
14188 
 
14189 
  def __repr__(self):
14190 
    L = ['%s=%r' % (key, value)
14191 
      for key, value in self.__dict__.iteritems()]
14192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14193 
 
14194 
  def __eq__(self, other):
14195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14196 
 
14197 
  def __ne__(self, other):
14198 
    return not (self == other)
14199 
 
14200 
class getTrustLevel_result:
14201 
  """
14202 
  Attributes:
14203 
   - success
14204 
  """
14205 
 
14206 
  thrift_spec = (
14207 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14208 
  )
14209 
 
14210 
  def __init__(self, success=None,):
14211 
    self.success = success
14212 
 
14213 
  def read(self, iprot):
14214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14216 
      return
14217 
    iprot.readStructBegin()
14218 
    while True:
14219 
      (fname, ftype, fid) = iprot.readFieldBegin()
14220 
      if ftype == TType.STOP:
14221 
        break
14222 
      if fid == 0:
14223 
        if ftype == TType.DOUBLE:
14224 
          self.success = iprot.readDouble();
14225 
        else:
14226 
          iprot.skip(ftype)
14227 
      else:
14228 
        iprot.skip(ftype)
14229 
      iprot.readFieldEnd()
14230 
    iprot.readStructEnd()
14231 
 
14232 
  def write(self, oprot):
14233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14235 
      return
14236 
    oprot.writeStructBegin('getTrustLevel_result')
14237 
    if self.success is not None:
14238 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14239 
      oprot.writeDouble(self.success)
14240 
      oprot.writeFieldEnd()
14241 
    oprot.writeFieldStop()
14242 
    oprot.writeStructEnd()
14243 
 
14244 
  def validate(self):
14245 
    return
14246 
 
14247 
 
14248 
  def __repr__(self):
14249 
    L = ['%s=%r' % (key, value)
14250 
      for key, value in self.__dict__.iteritems()]
14251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14252 
 
14253 
  def __eq__(self, other):
14254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14255 
 
14256 
  def __ne__(self, other):
14257 
    return not (self == other)
14258 
 
4668 varun.gupt 14259 
class showCODOption_args:
14260 
  """
14261 
  Attributes:
14262 
   - cartId
14263 
   - sourceId
14264 
   - pincode
14265 
  """
14266 
 
14267 
  thrift_spec = (
14268 
    None, # 0
14269 
    (1, TType.I64, 'cartId', None, None, ), # 1
14270 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14271 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14272 
  )
14273 
 
14274 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14275 
    self.cartId = cartId
14276 
    self.sourceId = sourceId
14277 
    self.pincode = pincode
14278 
 
14279 
  def read(self, iprot):
14280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14282 
      return
14283 
    iprot.readStructBegin()
14284 
    while True:
14285 
      (fname, ftype, fid) = iprot.readFieldBegin()
14286 
      if ftype == TType.STOP:
14287 
        break
14288 
      if fid == 1:
14289 
        if ftype == TType.I64:
14290 
          self.cartId = iprot.readI64();
14291 
        else:
14292 
          iprot.skip(ftype)
14293 
      elif fid == 2:
14294 
        if ftype == TType.I64:
14295 
          self.sourceId = iprot.readI64();
14296 
        else:
14297 
          iprot.skip(ftype)
14298 
      elif fid == 3:
14299 
        if ftype == TType.STRING:
14300 
          self.pincode = iprot.readString();
14301 
        else:
14302 
          iprot.skip(ftype)
14303 
      else:
14304 
        iprot.skip(ftype)
14305 
      iprot.readFieldEnd()
14306 
    iprot.readStructEnd()
14307 
 
14308 
  def write(self, oprot):
14309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14311 
      return
14312 
    oprot.writeStructBegin('showCODOption_args')
14313 
    if self.cartId is not None:
14314 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14315 
      oprot.writeI64(self.cartId)
14316 
      oprot.writeFieldEnd()
14317 
    if self.sourceId is not None:
14318 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14319 
      oprot.writeI64(self.sourceId)
14320 
      oprot.writeFieldEnd()
14321 
    if self.pincode is not None:
14322 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14323 
      oprot.writeString(self.pincode)
14324 
      oprot.writeFieldEnd()
14325 
    oprot.writeFieldStop()
14326 
    oprot.writeStructEnd()
14327 
 
14328 
  def validate(self):
14329 
    return
14330 
 
14331 
 
14332 
  def __repr__(self):
14333 
    L = ['%s=%r' % (key, value)
14334 
      for key, value in self.__dict__.iteritems()]
14335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14336 
 
14337 
  def __eq__(self, other):
14338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14339 
 
14340 
  def __ne__(self, other):
14341 
    return not (self == other)
14342 
 
14343 
class showCODOption_result:
14344 
  """
14345 
  Attributes:
14346 
   - success
14347 
  """
14348 
 
14349 
  thrift_spec = (
14350 
    (0, TType.BOOL, 'success', None, None, ), # 0
14351 
  )
14352 
 
14353 
  def __init__(self, success=None,):
14354 
    self.success = success
14355 
 
14356 
  def read(self, iprot):
14357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14359 
      return
14360 
    iprot.readStructBegin()
14361 
    while True:
14362 
      (fname, ftype, fid) = iprot.readFieldBegin()
14363 
      if ftype == TType.STOP:
14364 
        break
14365 
      if fid == 0:
14366 
        if ftype == TType.BOOL:
14367 
          self.success = iprot.readBool();
14368 
        else:
14369 
          iprot.skip(ftype)
14370 
      else:
14371 
        iprot.skip(ftype)
14372 
      iprot.readFieldEnd()
14373 
    iprot.readStructEnd()
14374 
 
14375 
  def write(self, oprot):
14376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14378 
      return
14379 
    oprot.writeStructBegin('showCODOption_result')
14380 
    if self.success is not None:
14381 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14382 
      oprot.writeBool(self.success)
14383 
      oprot.writeFieldEnd()
14384 
    oprot.writeFieldStop()
14385 
    oprot.writeStructEnd()
14386 
 
14387 
  def validate(self):
14388 
    return
14389 
 
14390 
 
14391 
  def __repr__(self):
14392 
    L = ['%s=%r' % (key, value)
14393 
      for key, value in self.__dict__.iteritems()]
14394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14395 
 
14396 
  def __eq__(self, other):
14397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14398 
 
14399 
  def __ne__(self, other):
14400 
    return not (self == other)
5623 anupam.sin 14401 
 
14402 
class getUserEmails_args:
14403 
  """
14404 
  Attributes:
14405 
   - startDate
14406 
   - endDate
14407 
  """
14408 
 
14409 
  thrift_spec = (
14410 
    None, # 0
14411 
    (1, TType.I64, 'startDate', None, None, ), # 1
14412 
    (2, TType.I64, 'endDate', None, None, ), # 2
14413 
  )
14414 
 
14415 
  def __init__(self, startDate=None, endDate=None,):
14416 
    self.startDate = startDate
14417 
    self.endDate = endDate
14418 
 
14419 
  def read(self, iprot):
14420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14422 
      return
14423 
    iprot.readStructBegin()
14424 
    while True:
14425 
      (fname, ftype, fid) = iprot.readFieldBegin()
14426 
      if ftype == TType.STOP:
14427 
        break
14428 
      if fid == 1:
14429 
        if ftype == TType.I64:
14430 
          self.startDate = iprot.readI64();
14431 
        else:
14432 
          iprot.skip(ftype)
14433 
      elif fid == 2:
14434 
        if ftype == TType.I64:
14435 
          self.endDate = iprot.readI64();
14436 
        else:
14437 
          iprot.skip(ftype)
14438 
      else:
14439 
        iprot.skip(ftype)
14440 
      iprot.readFieldEnd()
14441 
    iprot.readStructEnd()
14442 
 
14443 
  def write(self, oprot):
14444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14446 
      return
14447 
    oprot.writeStructBegin('getUserEmails_args')
14448 
    if self.startDate is not None:
14449 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14450 
      oprot.writeI64(self.startDate)
14451 
      oprot.writeFieldEnd()
14452 
    if self.endDate is not None:
14453 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14454 
      oprot.writeI64(self.endDate)
14455 
      oprot.writeFieldEnd()
14456 
    oprot.writeFieldStop()
14457 
    oprot.writeStructEnd()
14458 
 
14459 
  def validate(self):
14460 
    return
14461 
 
14462 
 
14463 
  def __repr__(self):
14464 
    L = ['%s=%r' % (key, value)
14465 
      for key, value in self.__dict__.iteritems()]
14466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14467 
 
14468 
  def __eq__(self, other):
14469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14470 
 
14471 
  def __ne__(self, other):
14472 
    return not (self == other)
14473 
 
14474 
class getUserEmails_result:
14475 
  """
14476 
  Attributes:
14477 
   - success
14478 
  """
14479 
 
14480 
  thrift_spec = (
14481 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14482 
  )
14483 
 
14484 
  def __init__(self, success=None,):
14485 
    self.success = success
14486 
 
14487 
  def read(self, iprot):
14488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14490 
      return
14491 
    iprot.readStructBegin()
14492 
    while True:
14493 
      (fname, ftype, fid) = iprot.readFieldBegin()
14494 
      if ftype == TType.STOP:
14495 
        break
14496 
      if fid == 0:
14497 
        if ftype == TType.LIST:
14498 
          self.success = []
11980 amit.gupta 14499 
          (_etype214, _size211) = iprot.readListBegin()
14500 
          for _i215 in xrange(_size211):
14501 
            _elem216 = iprot.readString();
14502 
            self.success.append(_elem216)
5623 anupam.sin 14503 
          iprot.readListEnd()
14504 
        else:
14505 
          iprot.skip(ftype)
14506 
      else:
14507 
        iprot.skip(ftype)
14508 
      iprot.readFieldEnd()
14509 
    iprot.readStructEnd()
14510 
 
14511 
  def write(self, oprot):
14512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14514 
      return
14515 
    oprot.writeStructBegin('getUserEmails_result')
14516 
    if self.success is not None:
14517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14518 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14519 
      for iter217 in self.success:
14520 
        oprot.writeString(iter217)
5623 anupam.sin 14521 
      oprot.writeListEnd()
14522 
      oprot.writeFieldEnd()
14523 
    oprot.writeFieldStop()
14524 
    oprot.writeStructEnd()
14525 
 
14526 
  def validate(self):
14527 
    return
14528 
 
14529 
 
14530 
  def __repr__(self):
14531 
    L = ['%s=%r' % (key, value)
14532 
      for key, value in self.__dict__.iteritems()]
14533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14534 
 
14535 
  def __eq__(self, other):
14536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14537 
 
14538 
  def __ne__(self, other):
14539 
    return not (self == other)
6821 amar.kumar 14540 
 
6903 anupam.sin 14541 
class insureItem_args:
14542 
  """
14543 
  Attributes:
14544 
   - itemId
14545 
   - cartId
14546 
   - toInsure
9299 kshitij.so 14547 
   - insurerType
6903 anupam.sin 14548 
  """
14549 
 
14550 
  thrift_spec = (
14551 
    None, # 0
14552 
    (1, TType.I64, 'itemId', None, None, ), # 1
14553 
    (2, TType.I64, 'cartId', None, None, ), # 2
14554 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14555 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14556 
  )
14557 
 
9299 kshitij.so 14558 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14559 
    self.itemId = itemId
14560 
    self.cartId = cartId
14561 
    self.toInsure = toInsure
9299 kshitij.so 14562 
    self.insurerType = insurerType
6903 anupam.sin 14563 
 
14564 
  def read(self, iprot):
14565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14567 
      return
14568 
    iprot.readStructBegin()
14569 
    while True:
14570 
      (fname, ftype, fid) = iprot.readFieldBegin()
14571 
      if ftype == TType.STOP:
14572 
        break
14573 
      if fid == 1:
14574 
        if ftype == TType.I64:
14575 
          self.itemId = iprot.readI64();
14576 
        else:
14577 
          iprot.skip(ftype)
14578 
      elif fid == 2:
14579 
        if ftype == TType.I64:
14580 
          self.cartId = iprot.readI64();
14581 
        else:
14582 
          iprot.skip(ftype)
14583 
      elif fid == 3:
14584 
        if ftype == TType.BOOL:
14585 
          self.toInsure = iprot.readBool();
14586 
        else:
14587 
          iprot.skip(ftype)
9299 kshitij.so 14588 
      elif fid == 4:
14589 
        if ftype == TType.I32:
14590 
          self.insurerType = iprot.readI32();
14591 
        else:
14592 
          iprot.skip(ftype)
6903 anupam.sin 14593 
      else:
14594 
        iprot.skip(ftype)
14595 
      iprot.readFieldEnd()
14596 
    iprot.readStructEnd()
14597 
 
14598 
  def write(self, oprot):
14599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14601 
      return
14602 
    oprot.writeStructBegin('insureItem_args')
14603 
    if self.itemId is not None:
14604 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14605 
      oprot.writeI64(self.itemId)
14606 
      oprot.writeFieldEnd()
14607 
    if self.cartId is not None:
14608 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14609 
      oprot.writeI64(self.cartId)
14610 
      oprot.writeFieldEnd()
14611 
    if self.toInsure is not None:
14612 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14613 
      oprot.writeBool(self.toInsure)
14614 
      oprot.writeFieldEnd()
9299 kshitij.so 14615 
    if self.insurerType is not None:
14616 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14617 
      oprot.writeI32(self.insurerType)
14618 
      oprot.writeFieldEnd()
6903 anupam.sin 14619 
    oprot.writeFieldStop()
14620 
    oprot.writeStructEnd()
14621 
 
14622 
  def validate(self):
14623 
    return
14624 
 
14625 
 
14626 
  def __repr__(self):
14627 
    L = ['%s=%r' % (key, value)
14628 
      for key, value in self.__dict__.iteritems()]
14629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14630 
 
14631 
  def __eq__(self, other):
14632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14633 
 
14634 
  def __ne__(self, other):
14635 
    return not (self == other)
14636 
 
14637 
class insureItem_result:
14638 
  """
14639 
  Attributes:
14640 
   - success
14641 
  """
14642 
 
14643 
  thrift_spec = (
14644 
    (0, TType.BOOL, 'success', None, None, ), # 0
14645 
  )
14646 
 
14647 
  def __init__(self, success=None,):
14648 
    self.success = success
14649 
 
14650 
  def read(self, iprot):
14651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14653 
      return
14654 
    iprot.readStructBegin()
14655 
    while True:
14656 
      (fname, ftype, fid) = iprot.readFieldBegin()
14657 
      if ftype == TType.STOP:
14658 
        break
14659 
      if fid == 0:
14660 
        if ftype == TType.BOOL:
14661 
          self.success = iprot.readBool();
14662 
        else:
14663 
          iprot.skip(ftype)
14664 
      else:
14665 
        iprot.skip(ftype)
14666 
      iprot.readFieldEnd()
14667 
    iprot.readStructEnd()
14668 
 
14669 
  def write(self, oprot):
14670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14672 
      return
14673 
    oprot.writeStructBegin('insureItem_result')
14674 
    if self.success is not None:
14675 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14676 
      oprot.writeBool(self.success)
14677 
      oprot.writeFieldEnd()
14678 
    oprot.writeFieldStop()
14679 
    oprot.writeStructEnd()
14680 
 
14681 
  def validate(self):
14682 
    return
14683 
 
14684 
 
14685 
  def __repr__(self):
14686 
    L = ['%s=%r' % (key, value)
14687 
      for key, value in self.__dict__.iteritems()]
14688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14689 
 
14690 
  def __eq__(self, other):
14691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14692 
 
14693 
  def __ne__(self, other):
14694 
    return not (self == other)
14695 
 
14696 
class cancelInsurance_args:
14697 
  """
14698 
  Attributes:
14699 
   - cartId
14700 
  """
14701 
 
14702 
  thrift_spec = (
14703 
    None, # 0
14704 
    (1, TType.I64, 'cartId', None, None, ), # 1
14705 
  )
14706 
 
14707 
  def __init__(self, cartId=None,):
14708 
    self.cartId = cartId
14709 
 
14710 
  def read(self, iprot):
14711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14713 
      return
14714 
    iprot.readStructBegin()
14715 
    while True:
14716 
      (fname, ftype, fid) = iprot.readFieldBegin()
14717 
      if ftype == TType.STOP:
14718 
        break
14719 
      if fid == 1:
14720 
        if ftype == TType.I64:
14721 
          self.cartId = iprot.readI64();
14722 
        else:
14723 
          iprot.skip(ftype)
14724 
      else:
14725 
        iprot.skip(ftype)
14726 
      iprot.readFieldEnd()
14727 
    iprot.readStructEnd()
14728 
 
14729 
  def write(self, oprot):
14730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14732 
      return
14733 
    oprot.writeStructBegin('cancelInsurance_args')
14734 
    if self.cartId is not None:
14735 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14736 
      oprot.writeI64(self.cartId)
14737 
      oprot.writeFieldEnd()
14738 
    oprot.writeFieldStop()
14739 
    oprot.writeStructEnd()
14740 
 
14741 
  def validate(self):
14742 
    return
14743 
 
14744 
 
14745 
  def __repr__(self):
14746 
    L = ['%s=%r' % (key, value)
14747 
      for key, value in self.__dict__.iteritems()]
14748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14749 
 
14750 
  def __eq__(self, other):
14751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14752 
 
14753 
  def __ne__(self, other):
14754 
    return not (self == other)
14755 
 
14756 
class cancelInsurance_result:
14757 
  """
14758 
  Attributes:
14759 
   - success
14760 
  """
14761 
 
14762 
  thrift_spec = (
14763 
    (0, TType.BOOL, 'success', None, None, ), # 0
14764 
  )
14765 
 
14766 
  def __init__(self, success=None,):
14767 
    self.success = success
14768 
 
14769 
  def read(self, iprot):
14770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14772 
      return
14773 
    iprot.readStructBegin()
14774 
    while True:
14775 
      (fname, ftype, fid) = iprot.readFieldBegin()
14776 
      if ftype == TType.STOP:
14777 
        break
14778 
      if fid == 0:
14779 
        if ftype == TType.BOOL:
14780 
          self.success = iprot.readBool();
14781 
        else:
14782 
          iprot.skip(ftype)
14783 
      else:
14784 
        iprot.skip(ftype)
14785 
      iprot.readFieldEnd()
14786 
    iprot.readStructEnd()
14787 
 
14788 
  def write(self, oprot):
14789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14791 
      return
14792 
    oprot.writeStructBegin('cancelInsurance_result')
14793 
    if self.success is not None:
14794 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14795 
      oprot.writeBool(self.success)
14796 
      oprot.writeFieldEnd()
14797 
    oprot.writeFieldStop()
14798 
    oprot.writeStructEnd()
14799 
 
14800 
  def validate(self):
14801 
    return
14802 
 
14803 
 
14804 
  def __repr__(self):
14805 
    L = ['%s=%r' % (key, value)
14806 
      for key, value in self.__dict__.iteritems()]
14807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14808 
 
14809 
  def __eq__(self, other):
14810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14811 
 
14812 
  def __ne__(self, other):
14813 
    return not (self == other)
14814 
 
14815 
class storeInsuranceSpecificDetails_args:
14816 
  """
14817 
  Attributes:
14818 
   - addressId
14819 
   - dob
14820 
   - guardianName
14821 
  """
14822 
 
14823 
  thrift_spec = (
14824 
    None, # 0
14825 
    (1, TType.I64, 'addressId', None, None, ), # 1
14826 
    (2, TType.STRING, 'dob', None, None, ), # 2
14827 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14828 
  )
14829 
 
14830 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14831 
    self.addressId = addressId
14832 
    self.dob = dob
14833 
    self.guardianName = guardianName
14834 
 
14835 
  def read(self, iprot):
14836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14838 
      return
14839 
    iprot.readStructBegin()
14840 
    while True:
14841 
      (fname, ftype, fid) = iprot.readFieldBegin()
14842 
      if ftype == TType.STOP:
14843 
        break
14844 
      if fid == 1:
14845 
        if ftype == TType.I64:
14846 
          self.addressId = iprot.readI64();
14847 
        else:
14848 
          iprot.skip(ftype)
14849 
      elif fid == 2:
14850 
        if ftype == TType.STRING:
14851 
          self.dob = iprot.readString();
14852 
        else:
14853 
          iprot.skip(ftype)
14854 
      elif fid == 3:
14855 
        if ftype == TType.STRING:
14856 
          self.guardianName = iprot.readString();
14857 
        else:
14858 
          iprot.skip(ftype)
14859 
      else:
14860 
        iprot.skip(ftype)
14861 
      iprot.readFieldEnd()
14862 
    iprot.readStructEnd()
14863 
 
14864 
  def write(self, oprot):
14865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14867 
      return
14868 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14869 
    if self.addressId is not None:
14870 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14871 
      oprot.writeI64(self.addressId)
14872 
      oprot.writeFieldEnd()
14873 
    if self.dob is not None:
14874 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14875 
      oprot.writeString(self.dob)
14876 
      oprot.writeFieldEnd()
14877 
    if self.guardianName is not None:
14878 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14879 
      oprot.writeString(self.guardianName)
14880 
      oprot.writeFieldEnd()
14881 
    oprot.writeFieldStop()
14882 
    oprot.writeStructEnd()
14883 
 
14884 
  def validate(self):
14885 
    return
14886 
 
14887 
 
14888 
  def __repr__(self):
14889 
    L = ['%s=%r' % (key, value)
14890 
      for key, value in self.__dict__.iteritems()]
14891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14892 
 
14893 
  def __eq__(self, other):
14894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14895 
 
14896 
  def __ne__(self, other):
14897 
    return not (self == other)
14898 
 
14899 
class storeInsuranceSpecificDetails_result:
14900 
  """
14901 
  Attributes:
14902 
   - success
14903 
  """
14904 
 
14905 
  thrift_spec = (
14906 
    (0, TType.BOOL, 'success', None, None, ), # 0
14907 
  )
14908 
 
14909 
  def __init__(self, success=None,):
14910 
    self.success = success
14911 
 
14912 
  def read(self, iprot):
14913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14915 
      return
14916 
    iprot.readStructBegin()
14917 
    while True:
14918 
      (fname, ftype, fid) = iprot.readFieldBegin()
14919 
      if ftype == TType.STOP:
14920 
        break
14921 
      if fid == 0:
14922 
        if ftype == TType.BOOL:
14923 
          self.success = iprot.readBool();
14924 
        else:
14925 
          iprot.skip(ftype)
14926 
      else:
14927 
        iprot.skip(ftype)
14928 
      iprot.readFieldEnd()
14929 
    iprot.readStructEnd()
14930 
 
14931 
  def write(self, oprot):
14932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14934 
      return
14935 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14936 
    if self.success is not None:
14937 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14938 
      oprot.writeBool(self.success)
14939 
      oprot.writeFieldEnd()
14940 
    oprot.writeFieldStop()
14941 
    oprot.writeStructEnd()
14942 
 
14943 
  def validate(self):
14944 
    return
14945 
 
14946 
 
14947 
  def __repr__(self):
14948 
    L = ['%s=%r' % (key, value)
14949 
      for key, value in self.__dict__.iteritems()]
14950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14951 
 
14952 
  def __eq__(self, other):
14953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14954 
 
14955 
  def __ne__(self, other):
14956 
    return not (self == other)
14957 
 
14958 
class isInsuranceDetailPresent_args:
14959 
  """
14960 
  Attributes:
14961 
   - addressId
14962 
  """
14963 
 
14964 
  thrift_spec = (
14965 
    None, # 0
14966 
    (1, TType.I64, 'addressId', None, None, ), # 1
14967 
  )
14968 
 
14969 
  def __init__(self, addressId=None,):
14970 
    self.addressId = addressId
14971 
 
14972 
  def read(self, iprot):
14973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14975 
      return
14976 
    iprot.readStructBegin()
14977 
    while True:
14978 
      (fname, ftype, fid) = iprot.readFieldBegin()
14979 
      if ftype == TType.STOP:
14980 
        break
14981 
      if fid == 1:
14982 
        if ftype == TType.I64:
14983 
          self.addressId = iprot.readI64();
14984 
        else:
14985 
          iprot.skip(ftype)
14986 
      else:
14987 
        iprot.skip(ftype)
14988 
      iprot.readFieldEnd()
14989 
    iprot.readStructEnd()
14990 
 
14991 
  def write(self, oprot):
14992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14994 
      return
14995 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14996 
    if self.addressId is not None:
14997 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14998 
      oprot.writeI64(self.addressId)
14999 
      oprot.writeFieldEnd()
15000 
    oprot.writeFieldStop()
15001 
    oprot.writeStructEnd()
15002 
 
15003 
  def validate(self):
15004 
    return
15005 
 
15006 
 
15007 
  def __repr__(self):
15008 
    L = ['%s=%r' % (key, value)
15009 
      for key, value in self.__dict__.iteritems()]
15010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15011 
 
15012 
  def __eq__(self, other):
15013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15014 
 
15015 
  def __ne__(self, other):
15016 
    return not (self == other)
15017 
 
15018 
class isInsuranceDetailPresent_result:
15019 
  """
15020 
  Attributes:
15021 
   - success
15022 
  """
15023 
 
15024 
  thrift_spec = (
15025 
    (0, TType.BOOL, 'success', None, None, ), # 0
15026 
  )
15027 
 
15028 
  def __init__(self, success=None,):
15029 
    self.success = success
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 == 0:
15041 
        if ftype == TType.BOOL:
15042 
          self.success = iprot.readBool();
15043 
        else:
15044 
          iprot.skip(ftype)
15045 
      else:
15046 
        iprot.skip(ftype)
15047 
      iprot.readFieldEnd()
15048 
    iprot.readStructEnd()
15049 
 
15050 
  def write(self, oprot):
15051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15053 
      return
15054 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15055 
    if self.success is not None:
15056 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15057 
      oprot.writeBool(self.success)
15058 
      oprot.writeFieldEnd()
15059 
    oprot.writeFieldStop()
15060 
    oprot.writeStructEnd()
15061 
 
15062 
  def validate(self):
15063 
    return
15064 
 
15065 
 
15066 
  def __repr__(self):
15067 
    L = ['%s=%r' % (key, value)
15068 
      for key, value in self.__dict__.iteritems()]
15069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15070 
 
15071 
  def __eq__(self, other):
15072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15073 
 
15074 
  def __ne__(self, other):
15075 
    return not (self == other)
15076 
 
9791 rajveer 15077 
class getProductsAddedToCart_args:
6821 amar.kumar 15078 
  """
15079 
  Attributes:
15080 
   - startDate
15081 
   - endDate
15082 
  """
15083 
 
15084 
  thrift_spec = (
15085 
    None, # 0
9791 rajveer 15086 
    (1, TType.I64, 'startDate', None, None, ), # 1
15087 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15088 
  )
15089 
 
9791 rajveer 15090 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15091 
    self.startDate = startDate
15092 
    self.endDate = endDate
15093 
 
15094 
  def read(self, iprot):
15095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15097 
      return
15098 
    iprot.readStructBegin()
15099 
    while True:
15100 
      (fname, ftype, fid) = iprot.readFieldBegin()
15101 
      if ftype == TType.STOP:
15102 
        break
15103 
      if fid == 1:
15104 
        if ftype == TType.I64:
9791 rajveer 15105 
          self.startDate = iprot.readI64();
6821 amar.kumar 15106 
        else:
15107 
          iprot.skip(ftype)
15108 
      elif fid == 2:
15109 
        if ftype == TType.I64:
15110 
          self.endDate = iprot.readI64();
15111 
        else:
15112 
          iprot.skip(ftype)
15113 
      else:
15114 
        iprot.skip(ftype)
15115 
      iprot.readFieldEnd()
15116 
    iprot.readStructEnd()
15117 
 
15118 
  def write(self, oprot):
15119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15121 
      return
9791 rajveer 15122 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15123 
    if self.startDate is not None:
9791 rajveer 15124 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15125 
      oprot.writeI64(self.startDate)
15126 
      oprot.writeFieldEnd()
15127 
    if self.endDate is not None:
9791 rajveer 15128 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15129 
      oprot.writeI64(self.endDate)
15130 
      oprot.writeFieldEnd()
15131 
    oprot.writeFieldStop()
15132 
    oprot.writeStructEnd()
15133 
 
15134 
  def validate(self):
15135 
    return
15136 
 
15137 
 
15138 
  def __repr__(self):
15139 
    L = ['%s=%r' % (key, value)
15140 
      for key, value in self.__dict__.iteritems()]
15141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15142 
 
15143 
  def __eq__(self, other):
15144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15145 
 
15146 
  def __ne__(self, other):
15147 
    return not (self == other)
15148 
 
9791 rajveer 15149 
class getProductsAddedToCart_result:
6821 amar.kumar 15150 
  """
15151 
  Attributes:
15152 
   - success
15153 
  """
15154 
 
15155 
  thrift_spec = (
9791 rajveer 15156 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15157 
  )
15158 
 
15159 
  def __init__(self, success=None,):
15160 
    self.success = success
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 0:
9791 rajveer 15172 
        if ftype == TType.LIST:
15173 
          self.success = []
11980 amit.gupta 15174 
          (_etype221, _size218) = iprot.readListBegin()
15175 
          for _i222 in xrange(_size218):
15176 
            _elem223 = iprot.readI64();
15177 
            self.success.append(_elem223)
9791 rajveer 15178 
          iprot.readListEnd()
6821 amar.kumar 15179 
        else:
15180 
          iprot.skip(ftype)
15181 
      else:
15182 
        iprot.skip(ftype)
15183 
      iprot.readFieldEnd()
15184 
    iprot.readStructEnd()
15185 
 
15186 
  def write(self, oprot):
15187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15189 
      return
9791 rajveer 15190 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15191 
    if self.success is not None:
9791 rajveer 15192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15193 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15194 
      for iter224 in self.success:
15195 
        oprot.writeI64(iter224)
9791 rajveer 15196 
      oprot.writeListEnd()
6821 amar.kumar 15197 
      oprot.writeFieldEnd()
15198 
    oprot.writeFieldStop()
15199 
    oprot.writeStructEnd()
15200 
 
15201 
  def validate(self):
15202 
    return
15203 
 
15204 
 
15205 
  def __repr__(self):
15206 
    L = ['%s=%r' % (key, value)
15207 
      for key, value in self.__dict__.iteritems()]
15208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15209 
 
15210 
  def __eq__(self, other):
15211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15212 
 
15213 
  def __ne__(self, other):
15214 
    return not (self == other)
11592 amit.gupta 15215 
 
15216 
class validateCartPlus_args:
15217 
  """
15218 
  Attributes:
15219 
   - cartId
15220 
   - sourceId
11980 amit.gupta 15221 
   - dealerCoupon
11592 amit.gupta 15222 
  """
15223 
 
15224 
  thrift_spec = (
15225 
    None, # 0
15226 
    (1, TType.I64, 'cartId', None, None, ), # 1
15227 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15228 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15229 
  )
15230 
 
11980 amit.gupta 15231 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15232 
    self.cartId = cartId
15233 
    self.sourceId = sourceId
11980 amit.gupta 15234 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15235 
 
15236 
  def read(self, iprot):
15237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15239 
      return
15240 
    iprot.readStructBegin()
15241 
    while True:
15242 
      (fname, ftype, fid) = iprot.readFieldBegin()
15243 
      if ftype == TType.STOP:
15244 
        break
15245 
      if fid == 1:
15246 
        if ftype == TType.I64:
15247 
          self.cartId = iprot.readI64();
15248 
        else:
15249 
          iprot.skip(ftype)
15250 
      elif fid == 2:
15251 
        if ftype == TType.I64:
15252 
          self.sourceId = iprot.readI64();
15253 
        else:
15254 
          iprot.skip(ftype)
11980 amit.gupta 15255 
      elif fid == 3:
15256 
        if ftype == TType.STRING:
15257 
          self.dealerCoupon = iprot.readString();
15258 
        else:
15259 
          iprot.skip(ftype)
11592 amit.gupta 15260 
      else:
15261 
        iprot.skip(ftype)
15262 
      iprot.readFieldEnd()
15263 
    iprot.readStructEnd()
15264 
 
15265 
  def write(self, oprot):
15266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15268 
      return
15269 
    oprot.writeStructBegin('validateCartPlus_args')
15270 
    if self.cartId is not None:
15271 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15272 
      oprot.writeI64(self.cartId)
15273 
      oprot.writeFieldEnd()
15274 
    if self.sourceId is not None:
15275 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15276 
      oprot.writeI64(self.sourceId)
15277 
      oprot.writeFieldEnd()
11980 amit.gupta 15278 
    if self.dealerCoupon is not None:
15279 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15280 
      oprot.writeString(self.dealerCoupon)
15281 
      oprot.writeFieldEnd()
11592 amit.gupta 15282 
    oprot.writeFieldStop()
15283 
    oprot.writeStructEnd()
15284 
 
15285 
  def validate(self):
15286 
    return
15287 
 
15288 
 
15289 
  def __repr__(self):
15290 
    L = ['%s=%r' % (key, value)
15291 
      for key, value in self.__dict__.iteritems()]
15292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15293 
 
15294 
  def __eq__(self, other):
15295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15296 
 
15297 
  def __ne__(self, other):
15298 
    return not (self == other)
15299 
 
15300 
class validateCartPlus_result:
15301 
  """
15302 
  Attributes:
15303 
   - success
15304 
   - scex
15305 
  """
15306 
 
15307 
  thrift_spec = (
15308 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15309 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15310 
  )
15311 
 
15312 
  def __init__(self, success=None, scex=None,):
15313 
    self.success = success
15314 
    self.scex = scex
15315 
 
15316 
  def read(self, iprot):
15317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15319 
      return
15320 
    iprot.readStructBegin()
15321 
    while True:
15322 
      (fname, ftype, fid) = iprot.readFieldBegin()
15323 
      if ftype == TType.STOP:
15324 
        break
15325 
      if fid == 0:
15326 
        if ftype == TType.STRUCT:
15327 
          self.success = CartPlus()
15328 
          self.success.read(iprot)
15329 
        else:
15330 
          iprot.skip(ftype)
15331 
      elif fid == 1:
15332 
        if ftype == TType.STRUCT:
15333 
          self.scex = ShoppingCartException()
15334 
          self.scex.read(iprot)
15335 
        else:
15336 
          iprot.skip(ftype)
15337 
      else:
15338 
        iprot.skip(ftype)
15339 
      iprot.readFieldEnd()
15340 
    iprot.readStructEnd()
15341 
 
15342 
  def write(self, oprot):
15343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15345 
      return
15346 
    oprot.writeStructBegin('validateCartPlus_result')
15347 
    if self.success is not None:
15348 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15349 
      self.success.write(oprot)
15350 
      oprot.writeFieldEnd()
15351 
    if self.scex is not None:
15352 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15353 
      self.scex.write(oprot)
15354 
      oprot.writeFieldEnd()
15355 
    oprot.writeFieldStop()
15356 
    oprot.writeStructEnd()
15357 
 
15358 
  def validate(self):
15359 
    return
15360 
 
15361 
 
15362 
  def __repr__(self):
15363 
    L = ['%s=%r' % (key, value)
15364 
      for key, value in self.__dict__.iteritems()]
15365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15366 
 
15367 
  def __eq__(self, other):
15368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15369 
 
15370 
  def __ne__(self, other):
15371 
    return not (self == other)
11679 vikram.rag 15372 
 
15373 
class isPrivateDealUser_args:
15374 
  """
15375 
  Attributes:
15376 
   - userId
15377 
  """
15378 
 
15379 
  thrift_spec = (
15380 
    None, # 0
15381 
    (1, TType.I64, 'userId', None, None, ), # 1
15382 
  )
15383 
 
15384 
  def __init__(self, userId=None,):
15385 
    self.userId = userId
15386 
 
15387 
  def read(self, iprot):
15388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15390 
      return
15391 
    iprot.readStructBegin()
15392 
    while True:
15393 
      (fname, ftype, fid) = iprot.readFieldBegin()
15394 
      if ftype == TType.STOP:
15395 
        break
15396 
      if fid == 1:
15397 
        if ftype == TType.I64:
15398 
          self.userId = iprot.readI64();
15399 
        else:
15400 
          iprot.skip(ftype)
15401 
      else:
15402 
        iprot.skip(ftype)
15403 
      iprot.readFieldEnd()
15404 
    iprot.readStructEnd()
15405 
 
15406 
  def write(self, oprot):
15407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15409 
      return
15410 
    oprot.writeStructBegin('isPrivateDealUser_args')
15411 
    if self.userId is not None:
15412 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15413 
      oprot.writeI64(self.userId)
15414 
      oprot.writeFieldEnd()
15415 
    oprot.writeFieldStop()
15416 
    oprot.writeStructEnd()
15417 
 
15418 
  def validate(self):
15419 
    return
15420 
 
15421 
 
15422 
  def __repr__(self):
15423 
    L = ['%s=%r' % (key, value)
15424 
      for key, value in self.__dict__.iteritems()]
15425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15426 
 
15427 
  def __eq__(self, other):
15428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15429 
 
15430 
  def __ne__(self, other):
15431 
    return not (self == other)
15432 
 
15433 
class isPrivateDealUser_result:
15434 
  """
15435 
  Attributes:
15436 
   - success
15437 
  """
15438 
 
15439 
  thrift_spec = (
15440 
    (0, TType.BOOL, 'success', None, None, ), # 0
15441 
  )
15442 
 
15443 
  def __init__(self, success=None,):
15444 
    self.success = success
15445 
 
15446 
  def read(self, iprot):
15447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15449 
      return
15450 
    iprot.readStructBegin()
15451 
    while True:
15452 
      (fname, ftype, fid) = iprot.readFieldBegin()
15453 
      if ftype == TType.STOP:
15454 
        break
15455 
      if fid == 0:
15456 
        if ftype == TType.BOOL:
15457 
          self.success = iprot.readBool();
15458 
        else:
15459 
          iprot.skip(ftype)
15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('isPrivateDealUser_result')
15470 
    if self.success is not None:
15471 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15472 
      oprot.writeBool(self.success)
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
11890 kshitij.so 15491 
 
15492 
class addPrivateDealUser_args:
15493 
  """
15494 
  Attributes:
15495 
   - userId
15496 
  """
15497 
 
15498 
  thrift_spec = (
15499 
    None, # 0
15500 
    (1, TType.I64, 'userId', None, None, ), # 1
15501 
  )
15502 
 
15503 
  def __init__(self, userId=None,):
15504 
    self.userId = userId
15505 
 
15506 
  def read(self, iprot):
15507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15509 
      return
15510 
    iprot.readStructBegin()
15511 
    while True:
15512 
      (fname, ftype, fid) = iprot.readFieldBegin()
15513 
      if ftype == TType.STOP:
15514 
        break
15515 
      if fid == 1:
15516 
        if ftype == TType.I64:
15517 
          self.userId = iprot.readI64();
15518 
        else:
15519 
          iprot.skip(ftype)
15520 
      else:
15521 
        iprot.skip(ftype)
15522 
      iprot.readFieldEnd()
15523 
    iprot.readStructEnd()
15524 
 
15525 
  def write(self, oprot):
15526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15528 
      return
15529 
    oprot.writeStructBegin('addPrivateDealUser_args')
15530 
    if self.userId is not None:
15531 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15532 
      oprot.writeI64(self.userId)
15533 
      oprot.writeFieldEnd()
15534 
    oprot.writeFieldStop()
15535 
    oprot.writeStructEnd()
15536 
 
15537 
  def validate(self):
15538 
    return
15539 
 
15540 
 
15541 
  def __repr__(self):
15542 
    L = ['%s=%r' % (key, value)
15543 
      for key, value in self.__dict__.iteritems()]
15544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15545 
 
15546 
  def __eq__(self, other):
15547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15548 
 
15549 
  def __ne__(self, other):
15550 
    return not (self == other)
15551 
 
15552 
class addPrivateDealUser_result:
15553 
  """
15554 
  Attributes:
15555 
   - success
15556 
  """
15557 
 
15558 
  thrift_spec = (
15559 
    (0, TType.BOOL, 'success', None, None, ), # 0
15560 
  )
15561 
 
15562 
  def __init__(self, success=None,):
15563 
    self.success = success
15564 
 
15565 
  def read(self, iprot):
15566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15568 
      return
15569 
    iprot.readStructBegin()
15570 
    while True:
15571 
      (fname, ftype, fid) = iprot.readFieldBegin()
15572 
      if ftype == TType.STOP:
15573 
        break
15574 
      if fid == 0:
15575 
        if ftype == TType.BOOL:
15576 
          self.success = iprot.readBool();
15577 
        else:
15578 
          iprot.skip(ftype)
15579 
      else:
15580 
        iprot.skip(ftype)
15581 
      iprot.readFieldEnd()
15582 
    iprot.readStructEnd()
15583 
 
15584 
  def write(self, oprot):
15585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15587 
      return
15588 
    oprot.writeStructBegin('addPrivateDealUser_result')
15589 
    if self.success is not None:
15590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15591 
      oprot.writeBool(self.success)
15592 
      oprot.writeFieldEnd()
15593 
    oprot.writeFieldStop()
15594 
    oprot.writeStructEnd()
15595 
 
15596 
  def validate(self):
15597 
    return
15598 
 
15599 
 
15600 
  def __repr__(self):
15601 
    L = ['%s=%r' % (key, value)
15602 
      for key, value in self.__dict__.iteritems()]
15603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15604 
 
15605 
  def __eq__(self, other):
15606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15607 
 
15608 
  def __ne__(self, other):
15609 
    return not (self == other)
15610 
 
15611 
class changePrivateDealUserStatus_args:
15612 
  """
15613 
  Attributes:
15614 
   - userId
15615 
   - isActive
15616 
  """
15617 
 
15618 
  thrift_spec = (
15619 
    None, # 0
15620 
    (1, TType.I64, 'userId', None, None, ), # 1
15621 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15622 
  )
15623 
 
15624 
  def __init__(self, userId=None, isActive=None,):
15625 
    self.userId = userId
15626 
    self.isActive = isActive
15627 
 
15628 
  def read(self, iprot):
15629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15631 
      return
15632 
    iprot.readStructBegin()
15633 
    while True:
15634 
      (fname, ftype, fid) = iprot.readFieldBegin()
15635 
      if ftype == TType.STOP:
15636 
        break
15637 
      if fid == 1:
15638 
        if ftype == TType.I64:
15639 
          self.userId = iprot.readI64();
15640 
        else:
15641 
          iprot.skip(ftype)
15642 
      elif fid == 2:
15643 
        if ftype == TType.BOOL:
15644 
          self.isActive = iprot.readBool();
15645 
        else:
15646 
          iprot.skip(ftype)
15647 
      else:
15648 
        iprot.skip(ftype)
15649 
      iprot.readFieldEnd()
15650 
    iprot.readStructEnd()
15651 
 
15652 
  def write(self, oprot):
15653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15655 
      return
15656 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15657 
    if self.userId is not None:
15658 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15659 
      oprot.writeI64(self.userId)
15660 
      oprot.writeFieldEnd()
15661 
    if self.isActive is not None:
15662 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15663 
      oprot.writeBool(self.isActive)
15664 
      oprot.writeFieldEnd()
15665 
    oprot.writeFieldStop()
15666 
    oprot.writeStructEnd()
15667 
 
15668 
  def validate(self):
15669 
    return
15670 
 
15671 
 
15672 
  def __repr__(self):
15673 
    L = ['%s=%r' % (key, value)
15674 
      for key, value in self.__dict__.iteritems()]
15675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15676 
 
15677 
  def __eq__(self, other):
15678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15679 
 
15680 
  def __ne__(self, other):
15681 
    return not (self == other)
15682 
 
15683 
class changePrivateDealUserStatus_result:
15684 
  """
15685 
  Attributes:
15686 
   - success
15687 
  """
15688 
 
15689 
  thrift_spec = (
15690 
    (0, TType.BOOL, 'success', None, None, ), # 0
15691 
  )
15692 
 
15693 
  def __init__(self, success=None,):
15694 
    self.success = success
15695 
 
15696 
  def read(self, iprot):
15697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15699 
      return
15700 
    iprot.readStructBegin()
15701 
    while True:
15702 
      (fname, ftype, fid) = iprot.readFieldBegin()
15703 
      if ftype == TType.STOP:
15704 
        break
15705 
      if fid == 0:
15706 
        if ftype == TType.BOOL:
15707 
          self.success = iprot.readBool();
15708 
        else:
15709 
          iprot.skip(ftype)
15710 
      else:
15711 
        iprot.skip(ftype)
15712 
      iprot.readFieldEnd()
15713 
    iprot.readStructEnd()
15714 
 
15715 
  def write(self, oprot):
15716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15718 
      return
15719 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15720 
    if self.success is not None:
15721 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15722 
      oprot.writeBool(self.success)
15723 
      oprot.writeFieldEnd()
15724 
    oprot.writeFieldStop()
15725 
    oprot.writeStructEnd()
15726 
 
15727 
  def validate(self):
15728 
    return
15729 
 
15730 
 
15731 
  def __repr__(self):
15732 
    L = ['%s=%r' % (key, value)
15733 
      for key, value in self.__dict__.iteritems()]
15734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15735 
 
15736 
  def __eq__(self, other):
15737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15738 
 
15739 
  def __ne__(self, other):
15740 
    return not (self == other)
15741 
 
15742 
class getPrivateDealUser_args:
15743 
  """
15744 
  Attributes:
15745 
   - userId
15746 
  """
15747 
 
15748 
  thrift_spec = (
15749 
    None, # 0
15750 
    (1, TType.I64, 'userId', None, None, ), # 1
15751 
  )
15752 
 
15753 
  def __init__(self, userId=None,):
15754 
    self.userId = userId
15755 
 
15756 
  def read(self, iprot):
15757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15759 
      return
15760 
    iprot.readStructBegin()
15761 
    while True:
15762 
      (fname, ftype, fid) = iprot.readFieldBegin()
15763 
      if ftype == TType.STOP:
15764 
        break
15765 
      if fid == 1:
15766 
        if ftype == TType.I64:
15767 
          self.userId = iprot.readI64();
15768 
        else:
15769 
          iprot.skip(ftype)
15770 
      else:
15771 
        iprot.skip(ftype)
15772 
      iprot.readFieldEnd()
15773 
    iprot.readStructEnd()
15774 
 
15775 
  def write(self, oprot):
15776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15778 
      return
15779 
    oprot.writeStructBegin('getPrivateDealUser_args')
15780 
    if self.userId is not None:
15781 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15782 
      oprot.writeI64(self.userId)
15783 
      oprot.writeFieldEnd()
15784 
    oprot.writeFieldStop()
15785 
    oprot.writeStructEnd()
15786 
 
15787 
  def validate(self):
15788 
    return
15789 
 
15790 
 
15791 
  def __repr__(self):
15792 
    L = ['%s=%r' % (key, value)
15793 
      for key, value in self.__dict__.iteritems()]
15794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15795 
 
15796 
  def __eq__(self, other):
15797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15798 
 
15799 
  def __ne__(self, other):
15800 
    return not (self == other)
15801 
 
15802 
class getPrivateDealUser_result:
15803 
  """
15804 
  Attributes:
15805 
   - success
15806 
  """
15807 
 
15808 
  thrift_spec = (
15809 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15810 
  )
15811 
 
15812 
  def __init__(self, success=None,):
15813 
    self.success = success
15814 
 
15815 
  def read(self, iprot):
15816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15818 
      return
15819 
    iprot.readStructBegin()
15820 
    while True:
15821 
      (fname, ftype, fid) = iprot.readFieldBegin()
15822 
      if ftype == TType.STOP:
15823 
        break
15824 
      if fid == 0:
15825 
        if ftype == TType.STRUCT:
15826 
          self.success = PrivateDealUser()
15827 
          self.success.read(iprot)
15828 
        else:
15829 
          iprot.skip(ftype)
15830 
      else:
15831 
        iprot.skip(ftype)
15832 
      iprot.readFieldEnd()
15833 
    iprot.readStructEnd()
15834 
 
15835 
  def write(self, oprot):
15836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15838 
      return
15839 
    oprot.writeStructBegin('getPrivateDealUser_result')
15840 
    if self.success is not None:
15841 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15842 
      self.success.write(oprot)
15843 
      oprot.writeFieldEnd()
15844 
    oprot.writeFieldStop()
15845 
    oprot.writeStructEnd()
15846 
 
15847 
  def validate(self):
15848 
    return
15849 
 
15850 
 
15851 
  def __repr__(self):
15852 
    L = ['%s=%r' % (key, value)
15853 
      for key, value in self.__dict__.iteritems()]
15854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15855 
 
15856 
  def __eq__(self, other):
15857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15858 
 
15859 
  def __ne__(self, other):
15860 
    return not (self == other)
12696 amit.gupta 15861 
 
15862 
class registerCounter_args:
15863 
  """
15864 
  Attributes:
15865 
   - counter
15866 
   - userId
15867 
  """
15868 
 
15869 
  thrift_spec = (
15870 
    None, # 0
15871 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15872 
    (2, TType.I64, 'userId', None, None, ), # 2
15873 
  )
15874 
 
15875 
  def __init__(self, counter=None, userId=None,):
15876 
    self.counter = counter
15877 
    self.userId = userId
15878 
 
15879 
  def read(self, iprot):
15880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15882 
      return
15883 
    iprot.readStructBegin()
15884 
    while True:
15885 
      (fname, ftype, fid) = iprot.readFieldBegin()
15886 
      if ftype == TType.STOP:
15887 
        break
15888 
      if fid == 1:
15889 
        if ftype == TType.STRUCT:
15890 
          self.counter = Counter()
15891 
          self.counter.read(iprot)
15892 
        else:
15893 
          iprot.skip(ftype)
15894 
      elif fid == 2:
15895 
        if ftype == TType.I64:
15896 
          self.userId = iprot.readI64();
15897 
        else:
15898 
          iprot.skip(ftype)
15899 
      else:
15900 
        iprot.skip(ftype)
15901 
      iprot.readFieldEnd()
15902 
    iprot.readStructEnd()
15903 
 
15904 
  def write(self, oprot):
15905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15907 
      return
15908 
    oprot.writeStructBegin('registerCounter_args')
15909 
    if self.counter is not None:
15910 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15911 
      self.counter.write(oprot)
15912 
      oprot.writeFieldEnd()
15913 
    if self.userId is not None:
15914 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15915 
      oprot.writeI64(self.userId)
15916 
      oprot.writeFieldEnd()
15917 
    oprot.writeFieldStop()
15918 
    oprot.writeStructEnd()
15919 
 
15920 
  def validate(self):
15921 
    return
15922 
 
15923 
 
15924 
  def __repr__(self):
15925 
    L = ['%s=%r' % (key, value)
15926 
      for key, value in self.__dict__.iteritems()]
15927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15928 
 
15929 
  def __eq__(self, other):
15930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15931 
 
15932 
  def __ne__(self, other):
15933 
    return not (self == other)
15934 
 
15935 
class registerCounter_result:
15936 
  """
15937 
  Attributes:
15938 
   - success
15939 
  """
15940 
 
15941 
  thrift_spec = (
15942 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15943 
  )
15944 
 
15945 
  def __init__(self, success=None,):
15946 
    self.success = success
15947 
 
15948 
  def read(self, iprot):
15949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15951 
      return
15952 
    iprot.readStructBegin()
15953 
    while True:
15954 
      (fname, ftype, fid) = iprot.readFieldBegin()
15955 
      if ftype == TType.STOP:
15956 
        break
15957 
      if fid == 0:
15958 
        if ftype == TType.MAP:
15959 
          self.success = {}
15960 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15961 
          for _i229 in xrange(_size225):
15962 
            _key230 = iprot.readString();
15963 
            _val231 = iprot.readString();
15964 
            self.success[_key230] = _val231
15965 
          iprot.readMapEnd()
15966 
        else:
15967 
          iprot.skip(ftype)
15968 
      else:
15969 
        iprot.skip(ftype)
15970 
      iprot.readFieldEnd()
15971 
    iprot.readStructEnd()
15972 
 
15973 
  def write(self, oprot):
15974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15976 
      return
15977 
    oprot.writeStructBegin('registerCounter_result')
15978 
    if self.success is not None:
15979 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15980 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15981 
      for kiter232,viter233 in self.success.items():
15982 
        oprot.writeString(kiter232)
15983 
        oprot.writeString(viter233)
15984 
      oprot.writeMapEnd()
15985 
      oprot.writeFieldEnd()
15986 
    oprot.writeFieldStop()
15987 
    oprot.writeStructEnd()
15988 
 
15989 
  def validate(self):
15990 
    return
15991 
 
15992 
 
15993 
  def __repr__(self):
15994 
    L = ['%s=%r' % (key, value)
15995 
      for key, value in self.__dict__.iteritems()]
15996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15997 
 
15998 
  def __eq__(self, other):
15999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16000 
 
16001 
  def __ne__(self, other):
16002 
    return not (self == other)
12722 amit.gupta 16003 
 
16004 
class searchCounter_args:
16005 
  """
16006 
  Attributes:
16007 
   - type1
16008 
   - searchString
16009 
  """
16010 
 
16011 
  thrift_spec = (
16012 
    None, # 0
16013 
    (1, TType.STRING, 'type1', None, None, ), # 1
16014 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16015 
  )
16016 
 
16017 
  def __init__(self, type1=None, searchString=None,):
16018 
    self.type1 = type1
16019 
    self.searchString = searchString
16020 
 
16021 
  def read(self, iprot):
16022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16024 
      return
16025 
    iprot.readStructBegin()
16026 
    while True:
16027 
      (fname, ftype, fid) = iprot.readFieldBegin()
16028 
      if ftype == TType.STOP:
16029 
        break
16030 
      if fid == 1:
16031 
        if ftype == TType.STRING:
16032 
          self.type1 = iprot.readString();
16033 
        else:
16034 
          iprot.skip(ftype)
16035 
      elif fid == 2:
16036 
        if ftype == TType.STRING:
16037 
          self.searchString = iprot.readString();
16038 
        else:
16039 
          iprot.skip(ftype)
16040 
      else:
16041 
        iprot.skip(ftype)
16042 
      iprot.readFieldEnd()
16043 
    iprot.readStructEnd()
16044 
 
16045 
  def write(self, oprot):
16046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16048 
      return
16049 
    oprot.writeStructBegin('searchCounter_args')
16050 
    if self.type1 is not None:
16051 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16052 
      oprot.writeString(self.type1)
16053 
      oprot.writeFieldEnd()
16054 
    if self.searchString is not None:
16055 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16056 
      oprot.writeString(self.searchString)
16057 
      oprot.writeFieldEnd()
16058 
    oprot.writeFieldStop()
16059 
    oprot.writeStructEnd()
16060 
 
16061 
  def validate(self):
16062 
    return
16063 
 
16064 
 
16065 
  def __repr__(self):
16066 
    L = ['%s=%r' % (key, value)
16067 
      for key, value in self.__dict__.iteritems()]
16068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16069 
 
16070 
  def __eq__(self, other):
16071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16072 
 
16073 
  def __ne__(self, other):
16074 
    return not (self == other)
16075 
 
16076 
class searchCounter_result:
16077 
  """
16078 
  Attributes:
16079 
   - success
16080 
  """
16081 
 
16082 
  thrift_spec = (
16083 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16084 
  )
16085 
 
16086 
  def __init__(self, success=None,):
16087 
    self.success = success
16088 
 
16089 
  def read(self, iprot):
16090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16092 
      return
16093 
    iprot.readStructBegin()
16094 
    while True:
16095 
      (fname, ftype, fid) = iprot.readFieldBegin()
16096 
      if ftype == TType.STOP:
16097 
        break
16098 
      if fid == 0:
16099 
        if ftype == TType.LIST:
16100 
          self.success = []
16101 
          (_etype237, _size234) = iprot.readListBegin()
16102 
          for _i238 in xrange(_size234):
16103 
            _elem239 = Counter()
16104 
            _elem239.read(iprot)
16105 
            self.success.append(_elem239)
16106 
          iprot.readListEnd()
16107 
        else:
16108 
          iprot.skip(ftype)
16109 
      else:
16110 
        iprot.skip(ftype)
16111 
      iprot.readFieldEnd()
16112 
    iprot.readStructEnd()
16113 
 
16114 
  def write(self, oprot):
16115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16117 
      return
16118 
    oprot.writeStructBegin('searchCounter_result')
16119 
    if self.success is not None:
16120 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16121 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16122 
      for iter240 in self.success:
16123 
        iter240.write(oprot)
16124 
      oprot.writeListEnd()
16125 
      oprot.writeFieldEnd()
16126 
    oprot.writeFieldStop()
16127 
    oprot.writeStructEnd()
16128 
 
16129 
  def validate(self):
16130 
    return
16131 
 
16132 
 
16133 
  def __repr__(self):
16134 
    L = ['%s=%r' % (key, value)
16135 
      for key, value in self.__dict__.iteritems()]
16136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16137 
 
16138 
  def __eq__(self, other):
16139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16140 
 
16141 
  def __ne__(self, other):
16142 
    return not (self == other)
16143 
 
16144 
class getAllUsersByCounter_args:
16145 
  """
16146 
  Attributes:
16147 
   - counterId
16148 
  """
16149 
 
16150 
  thrift_spec = (
16151 
    None, # 0
16152 
    (1, TType.I64, 'counterId', None, None, ), # 1
16153 
  )
16154 
 
16155 
  def __init__(self, counterId=None,):
16156 
    self.counterId = counterId
16157 
 
16158 
  def read(self, iprot):
16159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16161 
      return
16162 
    iprot.readStructBegin()
16163 
    while True:
16164 
      (fname, ftype, fid) = iprot.readFieldBegin()
16165 
      if ftype == TType.STOP:
16166 
        break
16167 
      if fid == 1:
16168 
        if ftype == TType.I64:
16169 
          self.counterId = iprot.readI64();
16170 
        else:
16171 
          iprot.skip(ftype)
16172 
      else:
16173 
        iprot.skip(ftype)
16174 
      iprot.readFieldEnd()
16175 
    iprot.readStructEnd()
16176 
 
16177 
  def write(self, oprot):
16178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16180 
      return
16181 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16182 
    if self.counterId is not None:
16183 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16184 
      oprot.writeI64(self.counterId)
16185 
      oprot.writeFieldEnd()
16186 
    oprot.writeFieldStop()
16187 
    oprot.writeStructEnd()
16188 
 
16189 
  def validate(self):
16190 
    return
16191 
 
16192 
 
16193 
  def __repr__(self):
16194 
    L = ['%s=%r' % (key, value)
16195 
      for key, value in self.__dict__.iteritems()]
16196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16197 
 
16198 
  def __eq__(self, other):
16199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16200 
 
16201 
  def __ne__(self, other):
16202 
    return not (self == other)
16203 
 
16204 
class getAllUsersByCounter_result:
16205 
  """
16206 
  Attributes:
16207 
   - success
16208 
  """
16209 
 
16210 
  thrift_spec = (
16211 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16212 
  )
16213 
 
16214 
  def __init__(self, success=None,):
16215 
    self.success = success
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 == 0:
16227 
        if ftype == TType.LIST:
16228 
          self.success = []
16229 
          (_etype244, _size241) = iprot.readListBegin()
16230 
          for _i245 in xrange(_size241):
16231 
            _elem246 = User()
16232 
            _elem246.read(iprot)
16233 
            self.success.append(_elem246)
16234 
          iprot.readListEnd()
16235 
        else:
16236 
          iprot.skip(ftype)
16237 
      else:
16238 
        iprot.skip(ftype)
16239 
      iprot.readFieldEnd()
16240 
    iprot.readStructEnd()
16241 
 
16242 
  def write(self, oprot):
16243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16245 
      return
16246 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16247 
    if self.success is not None:
16248 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16249 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16250 
      for iter247 in self.success:
16251 
        iter247.write(oprot)
16252 
      oprot.writeListEnd()
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)
15251 manish.sha 16271 
 
16272 
class getActiveAccessTokenForUser_args:
16273 
  """
16274 
  Attributes:
16275 
   - userId
16276 
   - source
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    None, # 0
16281 
    (1, TType.I64, 'userId', None, None, ), # 1
16282 
    (2, TType.STRING, 'source', None, None, ), # 2
16283 
  )
16284 
 
16285 
  def __init__(self, userId=None, source=None,):
16286 
    self.userId = userId
16287 
    self.source = source
16288 
 
16289 
  def read(self, iprot):
16290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16292 
      return
16293 
    iprot.readStructBegin()
16294 
    while True:
16295 
      (fname, ftype, fid) = iprot.readFieldBegin()
16296 
      if ftype == TType.STOP:
16297 
        break
16298 
      if fid == 1:
16299 
        if ftype == TType.I64:
16300 
          self.userId = iprot.readI64();
16301 
        else:
16302 
          iprot.skip(ftype)
16303 
      elif fid == 2:
16304 
        if ftype == TType.STRING:
16305 
          self.source = iprot.readString();
16306 
        else:
16307 
          iprot.skip(ftype)
16308 
      else:
16309 
        iprot.skip(ftype)
16310 
      iprot.readFieldEnd()
16311 
    iprot.readStructEnd()
16312 
 
16313 
  def write(self, oprot):
16314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16316 
      return
16317 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16318 
    if self.userId is not None:
16319 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16320 
      oprot.writeI64(self.userId)
16321 
      oprot.writeFieldEnd()
16322 
    if self.source is not None:
16323 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16324 
      oprot.writeString(self.source)
16325 
      oprot.writeFieldEnd()
16326 
    oprot.writeFieldStop()
16327 
    oprot.writeStructEnd()
16328 
 
16329 
  def validate(self):
16330 
    return
16331 
 
16332 
 
16333 
  def __repr__(self):
16334 
    L = ['%s=%r' % (key, value)
16335 
      for key, value in self.__dict__.iteritems()]
16336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16337 
 
16338 
  def __eq__(self, other):
16339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16340 
 
16341 
  def __ne__(self, other):
16342 
    return not (self == other)
16343 
 
16344 
class getActiveAccessTokenForUser_result:
16345 
  """
16346 
  Attributes:
16347 
   - success
16348 
  """
16349 
 
16350 
  thrift_spec = (
16351 
    (0, TType.STRING, 'success', None, None, ), # 0
16352 
  )
16353 
 
16354 
  def __init__(self, success=None,):
16355 
    self.success = success
16356 
 
16357 
  def read(self, iprot):
16358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16360 
      return
16361 
    iprot.readStructBegin()
16362 
    while True:
16363 
      (fname, ftype, fid) = iprot.readFieldBegin()
16364 
      if ftype == TType.STOP:
16365 
        break
16366 
      if fid == 0:
16367 
        if ftype == TType.STRING:
16368 
          self.success = iprot.readString();
16369 
        else:
16370 
          iprot.skip(ftype)
16371 
      else:
16372 
        iprot.skip(ftype)
16373 
      iprot.readFieldEnd()
16374 
    iprot.readStructEnd()
16375 
 
16376 
  def write(self, oprot):
16377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16379 
      return
16380 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16381 
    if self.success is not None:
16382 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16383 
      oprot.writeString(self.success)
16384 
      oprot.writeFieldEnd()
16385 
    oprot.writeFieldStop()
16386 
    oprot.writeStructEnd()
16387 
 
16388 
  def validate(self):
16389 
    return
16390 
 
16391 
 
16392 
  def __repr__(self):
16393 
    L = ['%s=%r' % (key, value)
16394 
      for key, value in self.__dict__.iteritems()]
16395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16396 
 
16397 
  def __eq__(self, other):
16398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16399 
 
16400 
  def __ne__(self, other):
16401 
    return not (self == other)
16402 
 
16403 
class validateAccessToken_args:
16404 
  """
16405 
  Attributes:
16406 
   - accessToken
16407 
  """
16408 
 
16409 
  thrift_spec = (
16410 
    None, # 0
16411 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16412 
  )
16413 
 
16414 
  def __init__(self, accessToken=None,):
16415 
    self.accessToken = accessToken
16416 
 
16417 
  def read(self, iprot):
16418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16420 
      return
16421 
    iprot.readStructBegin()
16422 
    while True:
16423 
      (fname, ftype, fid) = iprot.readFieldBegin()
16424 
      if ftype == TType.STOP:
16425 
        break
16426 
      if fid == 1:
16427 
        if ftype == TType.STRING:
16428 
          self.accessToken = iprot.readString();
16429 
        else:
16430 
          iprot.skip(ftype)
16431 
      else:
16432 
        iprot.skip(ftype)
16433 
      iprot.readFieldEnd()
16434 
    iprot.readStructEnd()
16435 
 
16436 
  def write(self, oprot):
16437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16439 
      return
16440 
    oprot.writeStructBegin('validateAccessToken_args')
16441 
    if self.accessToken is not None:
16442 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16443 
      oprot.writeString(self.accessToken)
16444 
      oprot.writeFieldEnd()
16445 
    oprot.writeFieldStop()
16446 
    oprot.writeStructEnd()
16447 
 
16448 
  def validate(self):
16449 
    return
16450 
 
16451 
 
16452 
  def __repr__(self):
16453 
    L = ['%s=%r' % (key, value)
16454 
      for key, value in self.__dict__.iteritems()]
16455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16456 
 
16457 
  def __eq__(self, other):
16458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16459 
 
16460 
  def __ne__(self, other):
16461 
    return not (self == other)
16462 
 
16463 
class validateAccessToken_result:
16464 
  """
16465 
  Attributes:
16466 
   - success
16467 
  """
16468 
 
16469 
  thrift_spec = (
16470 
    (0, TType.BOOL, 'success', None, None, ), # 0
16471 
  )
16472 
 
16473 
  def __init__(self, success=None,):
16474 
    self.success = success
16475 
 
16476 
  def read(self, iprot):
16477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16479 
      return
16480 
    iprot.readStructBegin()
16481 
    while True:
16482 
      (fname, ftype, fid) = iprot.readFieldBegin()
16483 
      if ftype == TType.STOP:
16484 
        break
16485 
      if fid == 0:
16486 
        if ftype == TType.BOOL:
16487 
          self.success = iprot.readBool();
16488 
        else:
16489 
          iprot.skip(ftype)
16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('validateAccessToken_result')
16500 
    if self.success is not None:
16501 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16502 
      oprot.writeBool(self.success)
16503 
      oprot.writeFieldEnd()
16504 
    oprot.writeFieldStop()
16505 
    oprot.writeStructEnd()
16506 
 
16507 
  def validate(self):
16508 
    return
16509 
 
16510 
 
16511 
  def __repr__(self):
16512 
    L = ['%s=%r' % (key, value)
16513 
      for key, value in self.__dict__.iteritems()]
16514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16515 
 
16516 
  def __eq__(self, other):
16517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16518 
 
16519 
  def __ne__(self, other):
16520 
    return not (self == other)
17782 amit.gupta 16521 
 
16522 
class addItemsToCart_args:
16523 
  """
16524 
  Attributes:
16525 
   - cartId
16526 
   - itemQty
16527 
   - couponCode
16528 
  """
16529 
 
16530 
  thrift_spec = (
16531 
    None, # 0
16532 
    (1, TType.I64, 'cartId', None, None, ), # 1
16533 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16534 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16535 
  )
16536 
 
16537 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16538 
    self.cartId = cartId
16539 
    self.itemQty = itemQty
16540 
    self.couponCode = couponCode
16541 
 
16542 
  def read(self, iprot):
16543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16545 
      return
16546 
    iprot.readStructBegin()
16547 
    while True:
16548 
      (fname, ftype, fid) = iprot.readFieldBegin()
16549 
      if ftype == TType.STOP:
16550 
        break
16551 
      if fid == 1:
16552 
        if ftype == TType.I64:
16553 
          self.cartId = iprot.readI64();
16554 
        else:
16555 
          iprot.skip(ftype)
16556 
      elif fid == 2:
16557 
        if ftype == TType.LIST:
16558 
          self.itemQty = []
16559 
          (_etype251, _size248) = iprot.readListBegin()
16560 
          for _i252 in xrange(_size248):
16561 
            _elem253 = ItemQuantity()
16562 
            _elem253.read(iprot)
16563 
            self.itemQty.append(_elem253)
16564 
          iprot.readListEnd()
16565 
        else:
16566 
          iprot.skip(ftype)
16567 
      elif fid == 3:
16568 
        if ftype == TType.STRING:
16569 
          self.couponCode = iprot.readString();
16570 
        else:
16571 
          iprot.skip(ftype)
16572 
      else:
16573 
        iprot.skip(ftype)
16574 
      iprot.readFieldEnd()
16575 
    iprot.readStructEnd()
16576 
 
16577 
  def write(self, oprot):
16578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16580 
      return
16581 
    oprot.writeStructBegin('addItemsToCart_args')
16582 
    if self.cartId is not None:
16583 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16584 
      oprot.writeI64(self.cartId)
16585 
      oprot.writeFieldEnd()
16586 
    if self.itemQty is not None:
16587 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16588 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16589 
      for iter254 in self.itemQty:
16590 
        iter254.write(oprot)
16591 
      oprot.writeListEnd()
16592 
      oprot.writeFieldEnd()
16593 
    if self.couponCode is not None:
16594 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16595 
      oprot.writeString(self.couponCode)
16596 
      oprot.writeFieldEnd()
16597 
    oprot.writeFieldStop()
16598 
    oprot.writeStructEnd()
16599 
 
16600 
  def validate(self):
16601 
    return
16602 
 
16603 
 
16604 
  def __repr__(self):
16605 
    L = ['%s=%r' % (key, value)
16606 
      for key, value in self.__dict__.iteritems()]
16607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16608 
 
16609 
  def __eq__(self, other):
16610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16611 
 
16612 
  def __ne__(self, other):
16613 
    return not (self == other)
16614 
 
16615 
class addItemsToCart_result:
16616 
  """
16617 
  Attributes:
16618 
   - success
16619 
  """
16620 
 
16621 
  thrift_spec = (
16622 
    (0, TType.BOOL, 'success', None, None, ), # 0
16623 
  )
16624 
 
16625 
  def __init__(self, success=None,):
16626 
    self.success = success
16627 
 
16628 
  def read(self, iprot):
16629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16631 
      return
16632 
    iprot.readStructBegin()
16633 
    while True:
16634 
      (fname, ftype, fid) = iprot.readFieldBegin()
16635 
      if ftype == TType.STOP:
16636 
        break
16637 
      if fid == 0:
16638 
        if ftype == TType.BOOL:
16639 
          self.success = iprot.readBool();
16640 
        else:
16641 
          iprot.skip(ftype)
16642 
      else:
16643 
        iprot.skip(ftype)
16644 
      iprot.readFieldEnd()
16645 
    iprot.readStructEnd()
16646 
 
16647 
  def write(self, oprot):
16648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16650 
      return
16651 
    oprot.writeStructBegin('addItemsToCart_result')
16652 
    if self.success is not None:
16653 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16654 
      oprot.writeBool(self.success)
16655 
      oprot.writeFieldEnd()
16656 
    oprot.writeFieldStop()
16657 
    oprot.writeStructEnd()
16658 
 
16659 
  def validate(self):
16660 
    return
16661 
 
16662 
 
16663 
  def __repr__(self):
16664 
    L = ['%s=%r' % (key, value)
16665 
      for key, value in self.__dict__.iteritems()]
16666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16667 
 
16668 
  def __eq__(self, other):
16669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16670 
 
16671 
  def __ne__(self, other):
16672 
    return not (self == other)
16673 
 
16674 
class validateCartNew_args:
16675 
  """
16676 
  Attributes:
16677 
   - cartId
16678 
   - pinCode
16679 
   - sourceId
16680 
  """
16681 
 
16682 
  thrift_spec = (
16683 
    None, # 0
16684 
    (1, TType.I64, 'cartId', None, None, ), # 1
16685 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16686 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16687 
  )
16688 
 
16689 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16690 
    self.cartId = cartId
16691 
    self.pinCode = pinCode
16692 
    self.sourceId = sourceId
16693 
 
16694 
  def read(self, iprot):
16695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16697 
      return
16698 
    iprot.readStructBegin()
16699 
    while True:
16700 
      (fname, ftype, fid) = iprot.readFieldBegin()
16701 
      if ftype == TType.STOP:
16702 
        break
16703 
      if fid == 1:
16704 
        if ftype == TType.I64:
16705 
          self.cartId = iprot.readI64();
16706 
        else:
16707 
          iprot.skip(ftype)
16708 
      elif fid == 2:
16709 
        if ftype == TType.STRING:
16710 
          self.pinCode = iprot.readString();
16711 
        else:
16712 
          iprot.skip(ftype)
16713 
      elif fid == 3:
16714 
        if ftype == TType.I64:
16715 
          self.sourceId = iprot.readI64();
16716 
        else:
16717 
          iprot.skip(ftype)
16718 
      else:
16719 
        iprot.skip(ftype)
16720 
      iprot.readFieldEnd()
16721 
    iprot.readStructEnd()
16722 
 
16723 
  def write(self, oprot):
16724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16726 
      return
16727 
    oprot.writeStructBegin('validateCartNew_args')
16728 
    if self.cartId is not None:
16729 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16730 
      oprot.writeI64(self.cartId)
16731 
      oprot.writeFieldEnd()
16732 
    if self.pinCode is not None:
16733 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
16734 
      oprot.writeString(self.pinCode)
16735 
      oprot.writeFieldEnd()
16736 
    if self.sourceId is not None:
16737 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
16738 
      oprot.writeI64(self.sourceId)
16739 
      oprot.writeFieldEnd()
16740 
    oprot.writeFieldStop()
16741 
    oprot.writeStructEnd()
16742 
 
16743 
  def validate(self):
16744 
    return
16745 
 
16746 
 
16747 
  def __repr__(self):
16748 
    L = ['%s=%r' % (key, value)
16749 
      for key, value in self.__dict__.iteritems()]
16750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16751 
 
16752 
  def __eq__(self, other):
16753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16754 
 
16755 
  def __ne__(self, other):
16756 
    return not (self == other)
16757 
 
16758 
class validateCartNew_result:
16759 
  """
16760 
  Attributes:
16761 
   - success
16762 
  """
16763 
 
16764 
  thrift_spec = (
16765 
    (0, TType.STRING, 'success', None, None, ), # 0
16766 
  )
16767 
 
16768 
  def __init__(self, success=None,):
16769 
    self.success = success
16770 
 
16771 
  def read(self, iprot):
16772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16774 
      return
16775 
    iprot.readStructBegin()
16776 
    while True:
16777 
      (fname, ftype, fid) = iprot.readFieldBegin()
16778 
      if ftype == TType.STOP:
16779 
        break
16780 
      if fid == 0:
16781 
        if ftype == TType.STRING:
16782 
          self.success = iprot.readString();
16783 
        else:
16784 
          iprot.skip(ftype)
16785 
      else:
16786 
        iprot.skip(ftype)
16787 
      iprot.readFieldEnd()
16788 
    iprot.readStructEnd()
16789 
 
16790 
  def write(self, oprot):
16791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16793 
      return
16794 
    oprot.writeStructBegin('validateCartNew_result')
16795 
    if self.success is not None:
16796 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16797 
      oprot.writeString(self.success)
16798 
      oprot.writeFieldEnd()
16799 
    oprot.writeFieldStop()
16800 
    oprot.writeStructEnd()
16801 
 
16802 
  def validate(self):
16803 
    return
16804 
 
16805 
 
16806 
  def __repr__(self):
16807 
    L = ['%s=%r' % (key, value)
16808 
      for key, value in self.__dict__.iteritems()]
16809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16810 
 
16811 
  def __eq__(self, other):
16812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16813 
 
16814 
  def __ne__(self, other):
16815 
    return not (self == other)
18530 manish.sha 16816 
 
18644 manish.sha 16817 
class isAddressEditableForCounter_args:
18530 manish.sha 16818 
  """
16819 
  Attributes:
16820 
   - userId
16821 
  """
16822 
 
16823 
  thrift_spec = (
16824 
    None, # 0
16825 
    (1, TType.I64, 'userId', None, None, ), # 1
16826 
  )
16827 
 
16828 
  def __init__(self, userId=None,):
16829 
    self.userId = userId
16830 
 
16831 
  def read(self, iprot):
16832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16834 
      return
16835 
    iprot.readStructBegin()
16836 
    while True:
16837 
      (fname, ftype, fid) = iprot.readFieldBegin()
16838 
      if ftype == TType.STOP:
16839 
        break
16840 
      if fid == 1:
16841 
        if ftype == TType.I64:
16842 
          self.userId = iprot.readI64();
16843 
        else:
16844 
          iprot.skip(ftype)
16845 
      else:
16846 
        iprot.skip(ftype)
16847 
      iprot.readFieldEnd()
16848 
    iprot.readStructEnd()
16849 
 
16850 
  def write(self, oprot):
16851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16853 
      return
18644 manish.sha 16854 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 16855 
    if self.userId is not None:
16856 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16857 
      oprot.writeI64(self.userId)
16858 
      oprot.writeFieldEnd()
16859 
    oprot.writeFieldStop()
16860 
    oprot.writeStructEnd()
16861 
 
16862 
  def validate(self):
16863 
    return
16864 
 
16865 
 
16866 
  def __repr__(self):
16867 
    L = ['%s=%r' % (key, value)
16868 
      for key, value in self.__dict__.iteritems()]
16869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16870 
 
16871 
  def __eq__(self, other):
16872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16873 
 
16874 
  def __ne__(self, other):
16875 
    return not (self == other)
16876 
 
18644 manish.sha 16877 
class isAddressEditableForCounter_result:
18530 manish.sha 16878 
  """
16879 
  Attributes:
16880 
   - success
16881 
  """
16882 
 
16883 
  thrift_spec = (
16884 
    (0, TType.BOOL, 'success', None, None, ), # 0
16885 
  )
16886 
 
16887 
  def __init__(self, success=None,):
16888 
    self.success = success
16889 
 
16890 
  def read(self, iprot):
16891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16893 
      return
16894 
    iprot.readStructBegin()
16895 
    while True:
16896 
      (fname, ftype, fid) = iprot.readFieldBegin()
16897 
      if ftype == TType.STOP:
16898 
        break
16899 
      if fid == 0:
16900 
        if ftype == TType.BOOL:
16901 
          self.success = iprot.readBool();
16902 
        else:
16903 
          iprot.skip(ftype)
16904 
      else:
16905 
        iprot.skip(ftype)
16906 
      iprot.readFieldEnd()
16907 
    iprot.readStructEnd()
16908 
 
16909 
  def write(self, oprot):
16910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16912 
      return
18644 manish.sha 16913 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 16914 
    if self.success is not None:
16915 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16916 
      oprot.writeBool(self.success)
16917 
      oprot.writeFieldEnd()
16918 
    oprot.writeFieldStop()
16919 
    oprot.writeStructEnd()
16920 
 
16921 
  def validate(self):
16922 
    return
16923 
 
16924 
 
16925 
  def __repr__(self):
16926 
    L = ['%s=%r' % (key, value)
16927 
      for key, value in self.__dict__.iteritems()]
16928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16929 
 
16930 
  def __eq__(self, other):
16931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16932 
 
16933 
  def __ne__(self, other):
16934 
    return not (self == other)
16935 
 
16936 
class getBillingAddressForUser_args:
16937 
  """
16938 
  Attributes:
16939 
   - userId
16940 
  """
16941 
 
16942 
  thrift_spec = (
16943 
    None, # 0
16944 
    (1, TType.I64, 'userId', None, None, ), # 1
16945 
  )
16946 
 
16947 
  def __init__(self, userId=None,):
16948 
    self.userId = userId
16949 
 
16950 
  def read(self, iprot):
16951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16953 
      return
16954 
    iprot.readStructBegin()
16955 
    while True:
16956 
      (fname, ftype, fid) = iprot.readFieldBegin()
16957 
      if ftype == TType.STOP:
16958 
        break
16959 
      if fid == 1:
16960 
        if ftype == TType.I64:
16961 
          self.userId = iprot.readI64();
16962 
        else:
16963 
          iprot.skip(ftype)
16964 
      else:
16965 
        iprot.skip(ftype)
16966 
      iprot.readFieldEnd()
16967 
    iprot.readStructEnd()
16968 
 
16969 
  def write(self, oprot):
16970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16972 
      return
16973 
    oprot.writeStructBegin('getBillingAddressForUser_args')
16974 
    if self.userId is not None:
16975 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16976 
      oprot.writeI64(self.userId)
16977 
      oprot.writeFieldEnd()
16978 
    oprot.writeFieldStop()
16979 
    oprot.writeStructEnd()
16980 
 
16981 
  def validate(self):
16982 
    return
16983 
 
16984 
 
16985 
  def __repr__(self):
16986 
    L = ['%s=%r' % (key, value)
16987 
      for key, value in self.__dict__.iteritems()]
16988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16989 
 
16990 
  def __eq__(self, other):
16991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16992 
 
16993 
  def __ne__(self, other):
16994 
    return not (self == other)
16995 
 
16996 
class getBillingAddressForUser_result:
16997 
  """
16998 
  Attributes:
16999 
   - success
17000 
  """
17001 
 
17002 
  thrift_spec = (
17003 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17004 
  )
17005 
 
17006 
  def __init__(self, success=None,):
17007 
    self.success = success
17008 
 
17009 
  def read(self, iprot):
17010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17012 
      return
17013 
    iprot.readStructBegin()
17014 
    while True:
17015 
      (fname, ftype, fid) = iprot.readFieldBegin()
17016 
      if ftype == TType.STOP:
17017 
        break
17018 
      if fid == 0:
17019 
        if ftype == TType.STRUCT:
17020 
          self.success = Address()
17021 
          self.success.read(iprot)
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      else:
17025 
        iprot.skip(ftype)
17026 
      iprot.readFieldEnd()
17027 
    iprot.readStructEnd()
17028 
 
17029 
  def write(self, oprot):
17030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17032 
      return
17033 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17034 
    if self.success is not None:
17035 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17036 
      self.success.write(oprot)
17037 
      oprot.writeFieldEnd()
17038 
    oprot.writeFieldStop()
17039 
    oprot.writeStructEnd()
17040 
 
17041 
  def validate(self):
17042 
    return
17043 
 
17044 
 
17045 
  def __repr__(self):
17046 
    L = ['%s=%r' % (key, value)
17047 
      for key, value in self.__dict__.iteritems()]
17048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17049 
 
17050 
  def __eq__(self, other):
17051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17052 
 
17053 
  def __ne__(self, other):
17054 
    return not (self == other)
18590 manish.sha 17055 
 
17056 
class isCreditorAssigned_args:
17057 
  """
17058 
  Attributes:
17059 
   - userId
17060 
  """
17061 
 
17062 
  thrift_spec = (
17063 
    None, # 0
17064 
    (1, TType.I64, 'userId', None, None, ), # 1
17065 
  )
17066 
 
17067 
  def __init__(self, userId=None,):
17068 
    self.userId = userId
17069 
 
17070 
  def read(self, iprot):
17071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17073 
      return
17074 
    iprot.readStructBegin()
17075 
    while True:
17076 
      (fname, ftype, fid) = iprot.readFieldBegin()
17077 
      if ftype == TType.STOP:
17078 
        break
17079 
      if fid == 1:
17080 
        if ftype == TType.I64:
17081 
          self.userId = iprot.readI64();
17082 
        else:
17083 
          iprot.skip(ftype)
17084 
      else:
17085 
        iprot.skip(ftype)
17086 
      iprot.readFieldEnd()
17087 
    iprot.readStructEnd()
17088 
 
17089 
  def write(self, oprot):
17090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17092 
      return
17093 
    oprot.writeStructBegin('isCreditorAssigned_args')
17094 
    if self.userId is not None:
17095 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17096 
      oprot.writeI64(self.userId)
17097 
      oprot.writeFieldEnd()
17098 
    oprot.writeFieldStop()
17099 
    oprot.writeStructEnd()
17100 
 
17101 
  def validate(self):
17102 
    return
17103 
 
17104 
 
17105 
  def __repr__(self):
17106 
    L = ['%s=%r' % (key, value)
17107 
      for key, value in self.__dict__.iteritems()]
17108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17109 
 
17110 
  def __eq__(self, other):
17111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17112 
 
17113 
  def __ne__(self, other):
17114 
    return not (self == other)
17115 
 
17116 
class isCreditorAssigned_result:
17117 
  """
17118 
  Attributes:
17119 
   - success
17120 
  """
17121 
 
17122 
  thrift_spec = (
17123 
    (0, TType.BOOL, 'success', None, None, ), # 0
17124 
  )
17125 
 
17126 
  def __init__(self, success=None,):
17127 
    self.success = success
17128 
 
17129 
  def read(self, iprot):
17130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17132 
      return
17133 
    iprot.readStructBegin()
17134 
    while True:
17135 
      (fname, ftype, fid) = iprot.readFieldBegin()
17136 
      if ftype == TType.STOP:
17137 
        break
17138 
      if fid == 0:
17139 
        if ftype == TType.BOOL:
17140 
          self.success = iprot.readBool();
17141 
        else:
17142 
          iprot.skip(ftype)
17143 
      else:
17144 
        iprot.skip(ftype)
17145 
      iprot.readFieldEnd()
17146 
    iprot.readStructEnd()
17147 
 
17148 
  def write(self, oprot):
17149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17151 
      return
17152 
    oprot.writeStructBegin('isCreditorAssigned_result')
17153 
    if self.success is not None:
17154 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17155 
      oprot.writeBool(self.success)
17156 
      oprot.writeFieldEnd()
17157 
    oprot.writeFieldStop()
17158 
    oprot.writeStructEnd()
17159 
 
17160 
  def validate(self):
17161 
    return
17162 
 
17163 
 
17164 
  def __repr__(self):
17165 
    L = ['%s=%r' % (key, value)
17166 
      for key, value in self.__dict__.iteritems()]
17167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17168 
 
17169 
  def __eq__(self, other):
17170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17171 
 
17172 
  def __ne__(self, other):
17173 
    return not (self == other)
18735 manish.sha 17174 
 
17175 
class isTaxInvoiceEnabledUser_args:
17176 
  """
17177 
  Attributes:
17178 
   - userId
17179 
  """
17180 
 
17181 
  thrift_spec = (
17182 
    None, # 0
17183 
    (1, TType.I64, 'userId', None, None, ), # 1
17184 
  )
17185 
 
17186 
  def __init__(self, userId=None,):
17187 
    self.userId = userId
17188 
 
17189 
  def read(self, iprot):
17190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17192 
      return
17193 
    iprot.readStructBegin()
17194 
    while True:
17195 
      (fname, ftype, fid) = iprot.readFieldBegin()
17196 
      if ftype == TType.STOP:
17197 
        break
17198 
      if fid == 1:
17199 
        if ftype == TType.I64:
17200 
          self.userId = iprot.readI64();
17201 
        else:
17202 
          iprot.skip(ftype)
17203 
      else:
17204 
        iprot.skip(ftype)
17205 
      iprot.readFieldEnd()
17206 
    iprot.readStructEnd()
17207 
 
17208 
  def write(self, oprot):
17209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17211 
      return
17212 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17213 
    if self.userId is not None:
17214 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17215 
      oprot.writeI64(self.userId)
17216 
      oprot.writeFieldEnd()
17217 
    oprot.writeFieldStop()
17218 
    oprot.writeStructEnd()
17219 
 
17220 
  def validate(self):
17221 
    return
17222 
 
17223 
 
17224 
  def __repr__(self):
17225 
    L = ['%s=%r' % (key, value)
17226 
      for key, value in self.__dict__.iteritems()]
17227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17228 
 
17229 
  def __eq__(self, other):
17230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17231 
 
17232 
  def __ne__(self, other):
17233 
    return not (self == other)
17234 
 
17235 
class isTaxInvoiceEnabledUser_result:
17236 
  """
17237 
  Attributes:
17238 
   - success
17239 
  """
17240 
 
17241 
  thrift_spec = (
17242 
    (0, TType.BOOL, 'success', None, None, ), # 0
17243 
  )
17244 
 
17245 
  def __init__(self, success=None,):
17246 
    self.success = success
17247 
 
17248 
  def read(self, iprot):
17249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17251 
      return
17252 
    iprot.readStructBegin()
17253 
    while True:
17254 
      (fname, ftype, fid) = iprot.readFieldBegin()
17255 
      if ftype == TType.STOP:
17256 
        break
17257 
      if fid == 0:
17258 
        if ftype == TType.BOOL:
17259 
          self.success = iprot.readBool();
17260 
        else:
17261 
          iprot.skip(ftype)
17262 
      else:
17263 
        iprot.skip(ftype)
17264 
      iprot.readFieldEnd()
17265 
    iprot.readStructEnd()
17266 
 
17267 
  def write(self, oprot):
17268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17270 
      return
17271 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17272 
    if self.success is not None:
17273 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17274 
      oprot.writeBool(self.success)
17275 
      oprot.writeFieldEnd()
17276 
    oprot.writeFieldStop()
17277 
    oprot.writeStructEnd()
17278 
 
17279 
  def validate(self):
17280 
    return
17281 
 
17282 
 
17283 
  def __repr__(self):
17284 
    L = ['%s=%r' % (key, value)
17285 
      for key, value in self.__dict__.iteritems()]
17286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17287 
 
17288 
  def __eq__(self, other):
17289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17290 
 
17291 
  def __ne__(self, other):
17292 
    return not (self == other)