Subversion Repositories SmartDukaan

Rev

Rev 18590 | Rev 18735 | 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 
 
18590 manish.sha 774 
 
3376 rajveer 775 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 776 
  """
777 
  service
778 
  """
779 
  def __init__(self, iprot, oprot=None):
3376 rajveer 780 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 781 
 
559 chandransh 782 
  def createAnonymousUser(self, jsessionId):
94 ashish 783 
    """
784 
    Parameters:
559 chandransh 785 
     - jsessionId
94 ashish 786 
    """
559 chandransh 787 
    self.send_createAnonymousUser(jsessionId)
788 
    return self.recv_createAnonymousUser()
94 ashish 789 
 
559 chandransh 790 
  def send_createAnonymousUser(self, jsessionId):
791 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
792 
    args = createAnonymousUser_args()
793 
    args.jsessionId = jsessionId
94 ashish 794 
    args.write(self._oprot)
795 
    self._oprot.writeMessageEnd()
796 
    self._oprot.trans.flush()
797 
 
559 chandransh 798 
  def recv_createAnonymousUser(self, ):
94 ashish 799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
800 
    if mtype == TMessageType.EXCEPTION:
801 
      x = TApplicationException()
802 
      x.read(self._iprot)
803 
      self._iprot.readMessageEnd()
804 
      raise x
559 chandransh 805 
    result = createAnonymousUser_result()
94 ashish 806 
    result.read(self._iprot)
807 
    self._iprot.readMessageEnd()
3431 rajveer 808 
    if result.success is not None:
94 ashish 809 
      return result.success
3431 rajveer 810 
    if result.ucex is not None:
559 chandransh 811 
      raise result.ucex
812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 813 
 
559 chandransh 814 
  def getUserById(self, userId):
94 ashish 815 
    """
816 
    Parameters:
817 
     - userId
818 
    """
559 chandransh 819 
    self.send_getUserById(userId)
820 
    return self.recv_getUserById()
94 ashish 821 
 
559 chandransh 822 
  def send_getUserById(self, userId):
823 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
824 
    args = getUserById_args()
94 ashish 825 
    args.userId = userId
826 
    args.write(self._oprot)
827 
    self._oprot.writeMessageEnd()
828 
    self._oprot.trans.flush()
829 
 
559 chandransh 830 
  def recv_getUserById(self, ):
94 ashish 831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
832 
    if mtype == TMessageType.EXCEPTION:
833 
      x = TApplicationException()
834 
      x.read(self._iprot)
835 
      self._iprot.readMessageEnd()
836 
      raise x
559 chandransh 837 
    result = getUserById_result()
94 ashish 838 
    result.read(self._iprot)
839 
    self._iprot.readMessageEnd()
3431 rajveer 840 
    if result.success is not None:
94 ashish 841 
      return result.success
3431 rajveer 842 
    if result.ucex is not None:
559 chandransh 843 
      raise result.ucex
844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 845 
 
5326 rajveer 846 
  def getUserByCartId(self, cartId):
847 
    """
848 
    Parameters:
849 
     - cartId
850 
    """
851 
    self.send_getUserByCartId(cartId)
852 
    return self.recv_getUserByCartId()
853 
 
854 
  def send_getUserByCartId(self, cartId):
855 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
856 
    args = getUserByCartId_args()
857 
    args.cartId = cartId
858 
    args.write(self._oprot)
859 
    self._oprot.writeMessageEnd()
860 
    self._oprot.trans.flush()
861 
 
862 
  def recv_getUserByCartId(self, ):
863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
864 
    if mtype == TMessageType.EXCEPTION:
865 
      x = TApplicationException()
866 
      x.read(self._iprot)
867 
      self._iprot.readMessageEnd()
868 
      raise x
869 
    result = getUserByCartId_result()
870 
    result.read(self._iprot)
871 
    self._iprot.readMessageEnd()
872 
    if result.success is not None:
873 
      return result.success
874 
    if result.ucex is not None:
875 
      raise result.ucex
876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
877 
 
1491 vikas 878 
  def getUserByEmail(self, email):
879 
    """
880 
    Parameters:
881 
     - email
882 
    """
883 
    self.send_getUserByEmail(email)
884 
    return self.recv_getUserByEmail()
885 
 
886 
  def send_getUserByEmail(self, email):
887 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
888 
    args = getUserByEmail_args()
889 
    args.email = email
890 
    args.write(self._oprot)
891 
    self._oprot.writeMessageEnd()
892 
    self._oprot.trans.flush()
893 
 
894 
  def recv_getUserByEmail(self, ):
895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
896 
    if mtype == TMessageType.EXCEPTION:
897 
      x = TApplicationException()
898 
      x.read(self._iprot)
899 
      self._iprot.readMessageEnd()
900 
      raise x
901 
    result = getUserByEmail_result()
902 
    result.read(self._iprot)
903 
    self._iprot.readMessageEnd()
3431 rajveer 904 
    if result.success is not None:
1491 vikas 905 
      return result.success
3431 rajveer 906 
    if result.ucex is not None:
1491 vikas 907 
      raise result.ucex
908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
909 
 
3032 mandeep.dh 910 
  def getUserByMobileNumber(self, mobileNumber):
911 
    """
912 
    Parameters:
913 
     - mobileNumber
914 
    """
915 
    self.send_getUserByMobileNumber(mobileNumber)
916 
    return self.recv_getUserByMobileNumber()
917 
 
918 
  def send_getUserByMobileNumber(self, mobileNumber):
919 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
920 
    args = getUserByMobileNumber_args()
921 
    args.mobileNumber = mobileNumber
922 
    args.write(self._oprot)
923 
    self._oprot.writeMessageEnd()
924 
    self._oprot.trans.flush()
925 
 
926 
  def recv_getUserByMobileNumber(self, ):
927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
928 
    if mtype == TMessageType.EXCEPTION:
929 
      x = TApplicationException()
930 
      x.read(self._iprot)
931 
      self._iprot.readMessageEnd()
932 
      raise x
933 
    result = getUserByMobileNumber_result()
934 
    result.read(self._iprot)
935 
    self._iprot.readMessageEnd()
3431 rajveer 936 
    if result.success is not None:
3032 mandeep.dh 937 
      return result.success
3431 rajveer 938 
    if result.ucex is not None:
3032 mandeep.dh 939 
      raise result.ucex
940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
941 
 
559 chandransh 942 
  def createUser(self, user):
94 ashish 943 
    """
944 
    Parameters:
559 chandransh 945 
     - user
94 ashish 946 
    """
559 chandransh 947 
    self.send_createUser(user)
948 
    return self.recv_createUser()
94 ashish 949 
 
559 chandransh 950 
  def send_createUser(self, user):
951 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
952 
    args = createUser_args()
953 
    args.user = user
94 ashish 954 
    args.write(self._oprot)
955 
    self._oprot.writeMessageEnd()
956 
    self._oprot.trans.flush()
957 
 
559 chandransh 958 
  def recv_createUser(self, ):
94 ashish 959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
960 
    if mtype == TMessageType.EXCEPTION:
961 
      x = TApplicationException()
962 
      x.read(self._iprot)
963 
      self._iprot.readMessageEnd()
964 
      raise x
559 chandransh 965 
    result = createUser_result()
94 ashish 966 
    result.read(self._iprot)
967 
    self._iprot.readMessageEnd()
3431 rajveer 968 
    if result.success is not None:
94 ashish 969 
      return result.success
3431 rajveer 970 
    if result.ucex is not None:
559 chandransh 971 
      raise result.ucex
972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 973 
 
559 chandransh 974 
  def updateUser(self, user):
94 ashish 975 
    """
976 
    Parameters:
559 chandransh 977 
     - user
94 ashish 978 
    """
559 chandransh 979 
    self.send_updateUser(user)
980 
    return self.recv_updateUser()
94 ashish 981 
 
559 chandransh 982 
  def send_updateUser(self, user):
983 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
984 
    args = updateUser_args()
985 
    args.user = user
94 ashish 986 
    args.write(self._oprot)
987 
    self._oprot.writeMessageEnd()
988 
    self._oprot.trans.flush()
989 
 
559 chandransh 990 
  def recv_updateUser(self, ):
94 ashish 991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
992 
    if mtype == TMessageType.EXCEPTION:
993 
      x = TApplicationException()
994 
      x.read(self._iprot)
995 
      self._iprot.readMessageEnd()
996 
      raise x
559 chandransh 997 
    result = updateUser_result()
94 ashish 998 
    result.read(self._iprot)
999 
    self._iprot.readMessageEnd()
3431 rajveer 1000 
    if result.success is not None:
94 ashish 1001 
      return result.success
3431 rajveer 1002 
    if result.ucex is not None:
559 chandransh 1003 
      raise result.ucex
1004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1005 
 
559 chandransh 1006 
  def authenticateUser(self, email, password):
94 ashish 1007 
    """
1008 
    Parameters:
1009 
     - email
1010 
     - password
1011 
    """
559 chandransh 1012 
    self.send_authenticateUser(email, password)
122 ashish 1013 
    return self.recv_authenticateUser()
1014 
 
559 chandransh 1015 
  def send_authenticateUser(self, email, password):
122 ashish 1016 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1017 
    args = authenticateUser_args()
559 chandransh 1018 
    args.email = email
122 ashish 1019 
    args.password = password
1020 
    args.write(self._oprot)
1021 
    self._oprot.writeMessageEnd()
1022 
    self._oprot.trans.flush()
1023 
 
1024 
  def recv_authenticateUser(self, ):
1025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1026 
    if mtype == TMessageType.EXCEPTION:
1027 
      x = TApplicationException()
1028 
      x.read(self._iprot)
1029 
      self._iprot.readMessageEnd()
1030 
      raise x
1031 
    result = authenticateUser_result()
1032 
    result.read(self._iprot)
1033 
    self._iprot.readMessageEnd()
3431 rajveer 1034 
    if result.success is not None:
122 ashish 1035 
      return result.success
3431 rajveer 1036 
    if result.auex is not None:
559 chandransh 1037 
      raise result.auex
122 ashish 1038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1039 
 
94 ashish 1040 
  def userExists(self, email):
1041 
    """
1042 
    Parameters:
1043 
     - email
1044 
    """
1045 
    self.send_userExists(email)
1046 
    return self.recv_userExists()
1047 
 
1048 
  def send_userExists(self, email):
1049 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1050 
    args = userExists_args()
1051 
    args.email = email
1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
1056 
  def recv_userExists(self, ):
1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
1063 
    result = userExists_result()
1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
3431 rajveer 1066 
    if result.success is not None:
94 ashish 1067 
      return result.success
3431 rajveer 1068 
    if result.ucx is not None:
94 ashish 1069 
      raise result.ucx
1070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1071 
 
567 rajveer 1072 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1073 
    """
1074 
    Parameters:
1075 
     - userId
1076 
     - address
513 rajveer 1077 
     - setDefault
94 ashish 1078 
    """
567 rajveer 1079 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1080 
    return self.recv_addAddressForUser()
1081 
 
567 rajveer 1082 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1083 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1084 
    args = addAddressForUser_args()
559 chandransh 1085 
    args.userId = userId
94 ashish 1086 
    args.address = address
513 rajveer 1087 
    args.setDefault = setDefault
94 ashish 1088 
    args.write(self._oprot)
1089 
    self._oprot.writeMessageEnd()
1090 
    self._oprot.trans.flush()
1091 
 
1092 
  def recv_addAddressForUser(self, ):
1093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1094 
    if mtype == TMessageType.EXCEPTION:
1095 
      x = TApplicationException()
1096 
      x.read(self._iprot)
1097 
      self._iprot.readMessageEnd()
1098 
      raise x
1099 
    result = addAddressForUser_result()
1100 
    result.read(self._iprot)
1101 
    self._iprot.readMessageEnd()
3431 rajveer 1102 
    if result.success is not None:
94 ashish 1103 
      return result.success
3431 rajveer 1104 
    if result.ucx is not None:
94 ashish 1105 
      raise result.ucx
1106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1107 
 
1108 
  def removeAddressForUser(self, userid, addressId):
1109 
    """
1110 
    Parameters:
1111 
     - userid
1112 
     - addressId
1113 
    """
1114 
    self.send_removeAddressForUser(userid, addressId)
1115 
    return self.recv_removeAddressForUser()
1116 
 
1117 
  def send_removeAddressForUser(self, userid, addressId):
1118 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1119 
    args = removeAddressForUser_args()
1120 
    args.userid = userid
1121 
    args.addressId = addressId
1122 
    args.write(self._oprot)
1123 
    self._oprot.writeMessageEnd()
1124 
    self._oprot.trans.flush()
1125 
 
1126 
  def recv_removeAddressForUser(self, ):
1127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1128 
    if mtype == TMessageType.EXCEPTION:
1129 
      x = TApplicationException()
1130 
      x.read(self._iprot)
1131 
      self._iprot.readMessageEnd()
1132 
      raise x
1133 
    result = removeAddressForUser_result()
1134 
    result.read(self._iprot)
1135 
    self._iprot.readMessageEnd()
3431 rajveer 1136 
    if result.success is not None:
94 ashish 1137 
      return result.success
3431 rajveer 1138 
    if result.ucx is not None:
94 ashish 1139 
      raise result.ucx
1140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1141 
 
1142 
  def setUserAsLoggedIn(self, userId, timestamp):
1143 
    """
1144 
    Parameters:
1145 
     - userId
1146 
     - timestamp
1147 
    """
1148 
    self.send_setUserAsLoggedIn(userId, timestamp)
1149 
    return self.recv_setUserAsLoggedIn()
1150 
 
1151 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1152 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1153 
    args = setUserAsLoggedIn_args()
1154 
    args.userId = userId
1155 
    args.timestamp = timestamp
1156 
    args.write(self._oprot)
1157 
    self._oprot.writeMessageEnd()
1158 
    self._oprot.trans.flush()
1159 
 
1160 
  def recv_setUserAsLoggedIn(self, ):
1161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1162 
    if mtype == TMessageType.EXCEPTION:
1163 
      x = TApplicationException()
1164 
      x.read(self._iprot)
1165 
      self._iprot.readMessageEnd()
1166 
      raise x
1167 
    result = setUserAsLoggedIn_result()
1168 
    result.read(self._iprot)
1169 
    self._iprot.readMessageEnd()
3431 rajveer 1170 
    if result.success is not None:
94 ashish 1171 
      return result.success
3431 rajveer 1172 
    if result.ucx is not None:
94 ashish 1173 
      raise result.ucx
1174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1175 
 
1176 
  def setUserAsLoggedOut(self, userid, timestamp):
1177 
    """
1178 
    Parameters:
1179 
     - userid
1180 
     - timestamp
1181 
    """
1182 
    self.send_setUserAsLoggedOut(userid, timestamp)
1183 
    return self.recv_setUserAsLoggedOut()
1184 
 
1185 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1186 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1187 
    args = setUserAsLoggedOut_args()
1188 
    args.userid = userid
1189 
    args.timestamp = timestamp
1190 
    args.write(self._oprot)
1191 
    self._oprot.writeMessageEnd()
1192 
    self._oprot.trans.flush()
1193 
 
1194 
  def recv_setUserAsLoggedOut(self, ):
1195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1196 
    if mtype == TMessageType.EXCEPTION:
1197 
      x = TApplicationException()
1198 
      x.read(self._iprot)
1199 
      self._iprot.readMessageEnd()
1200 
      raise x
1201 
    result = setUserAsLoggedOut_result()
1202 
    result.read(self._iprot)
1203 
    self._iprot.readMessageEnd()
3431 rajveer 1204 
    if result.success is not None:
94 ashish 1205 
      return result.success
3431 rajveer 1206 
    if result.ucx is not None:
94 ashish 1207 
      raise result.ucx
1208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1209 
 
504 rajveer 1210 
  def setDefaultAddress(self, userid, addressId):
1211 
    """
1212 
    Parameters:
1213 
     - userid
1214 
     - addressId
1215 
    """
1216 
    self.send_setDefaultAddress(userid, addressId)
1217 
    return self.recv_setDefaultAddress()
1218 
 
1219 
  def send_setDefaultAddress(self, userid, addressId):
1220 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1221 
    args = setDefaultAddress_args()
1222 
    args.userid = userid
1223 
    args.addressId = addressId
1224 
    args.write(self._oprot)
1225 
    self._oprot.writeMessageEnd()
1226 
    self._oprot.trans.flush()
1227 
 
1228 
  def recv_setDefaultAddress(self, ):
1229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1230 
    if mtype == TMessageType.EXCEPTION:
1231 
      x = TApplicationException()
1232 
      x.read(self._iprot)
1233 
      self._iprot.readMessageEnd()
1234 
      raise x
1235 
    result = setDefaultAddress_result()
1236 
    result.read(self._iprot)
1237 
    self._iprot.readMessageEnd()
3431 rajveer 1238 
    if result.success is not None:
504 rajveer 1239 
      return result.success
3431 rajveer 1240 
    if result.ucx is not None:
504 rajveer 1241 
      raise result.ucx
1242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1243 
 
594 rajveer 1244 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1245 
    """
1246 
    Parameters:
1247 
     - userid
594 rajveer 1248 
     - oldPassword
1249 
     - newPassword
94 ashish 1250 
    """
594 rajveer 1251 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1252 
    return self.recv_updatePassword()
1253 
 
594 rajveer 1254 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1255 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1256 
    args = updatePassword_args()
1257 
    args.userid = userid
594 rajveer 1258 
    args.oldPassword = oldPassword
1259 
    args.newPassword = newPassword
94 ashish 1260 
    args.write(self._oprot)
1261 
    self._oprot.writeMessageEnd()
1262 
    self._oprot.trans.flush()
1263 
 
1264 
  def recv_updatePassword(self, ):
1265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1266 
    if mtype == TMessageType.EXCEPTION:
1267 
      x = TApplicationException()
1268 
      x.read(self._iprot)
1269 
      self._iprot.readMessageEnd()
1270 
      raise x
1271 
    result = updatePassword_result()
1272 
    result.read(self._iprot)
1273 
    self._iprot.readMessageEnd()
3431 rajveer 1274 
    if result.success is not None:
94 ashish 1275 
      return result.success
3431 rajveer 1276 
    if result.ucx is not None:
94 ashish 1277 
      raise result.ucx
1278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1279 
 
884 rajveer 1280 
  def forgotPassword(self, email, newPassword):
581 rajveer 1281 
    """
1282 
    Parameters:
1283 
     - email
884 rajveer 1284 
     - newPassword
581 rajveer 1285 
    """
884 rajveer 1286 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1287 
    return self.recv_forgotPassword()
1288 
 
884 rajveer 1289 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1290 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1291 
    args = forgotPassword_args()
1292 
    args.email = email
884 rajveer 1293 
    args.newPassword = newPassword
581 rajveer 1294 
    args.write(self._oprot)
1295 
    self._oprot.writeMessageEnd()
1296 
    self._oprot.trans.flush()
1297 
 
1298 
  def recv_forgotPassword(self, ):
1299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1300 
    if mtype == TMessageType.EXCEPTION:
1301 
      x = TApplicationException()
1302 
      x.read(self._iprot)
1303 
      self._iprot.readMessageEnd()
1304 
      raise x
1305 
    result = forgotPassword_result()
1306 
    result.read(self._iprot)
1307 
    self._iprot.readMessageEnd()
3431 rajveer 1308 
    if result.success is not None:
581 rajveer 1309 
      return result.success
3431 rajveer 1310 
    if result.ucx is not None:
581 rajveer 1311 
      raise result.ucx
1312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1313 
 
594 rajveer 1314 
  def getAllAddressesForUser(self, userId):
1315 
    """
1316 
    Parameters:
1317 
     - userId
1318 
    """
1319 
    self.send_getAllAddressesForUser(userId)
1320 
    return self.recv_getAllAddressesForUser()
1321 
 
1322 
  def send_getAllAddressesForUser(self, userId):
1323 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1324 
    args = getAllAddressesForUser_args()
1325 
    args.userId = userId
1326 
    args.write(self._oprot)
1327 
    self._oprot.writeMessageEnd()
1328 
    self._oprot.trans.flush()
1329 
 
1330 
  def recv_getAllAddressesForUser(self, ):
1331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1332 
    if mtype == TMessageType.EXCEPTION:
1333 
      x = TApplicationException()
1334 
      x.read(self._iprot)
1335 
      self._iprot.readMessageEnd()
1336 
      raise x
1337 
    result = getAllAddressesForUser_result()
1338 
    result.read(self._iprot)
1339 
    self._iprot.readMessageEnd()
3431 rajveer 1340 
    if result.success is not None:
594 rajveer 1341 
      return result.success
3431 rajveer 1342 
    if result.ucx is not None:
594 rajveer 1343 
      raise result.ucx
1344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1345 
 
1894 vikas 1346 
  def getAddressById(self, addressId):
1347 
    """
1348 
    Parameters:
1349 
     - addressId
1350 
    """
1351 
    self.send_getAddressById(addressId)
1352 
    return self.recv_getAddressById()
1353 
 
1354 
  def send_getAddressById(self, addressId):
1355 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1356 
    args = getAddressById_args()
1357 
    args.addressId = addressId
1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
1362 
  def recv_getAddressById(self, ):
1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
1369 
    result = getAddressById_result()
1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
3431 rajveer 1372 
    if result.success is not None:
1894 vikas 1373 
      return result.success
3431 rajveer 1374 
    if result.ucx is not None:
1894 vikas 1375 
      raise result.ucx
1376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1377 
 
594 rajveer 1378 
  def getDefaultAddressId(self, userId):
1379 
    """
1380 
    Parameters:
1381 
     - userId
1382 
    """
1383 
    self.send_getDefaultAddressId(userId)
1384 
    return self.recv_getDefaultAddressId()
1385 
 
1386 
  def send_getDefaultAddressId(self, userId):
1387 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1388 
    args = getDefaultAddressId_args()
1389 
    args.userId = userId
1390 
    args.write(self._oprot)
1391 
    self._oprot.writeMessageEnd()
1392 
    self._oprot.trans.flush()
1393 
 
1394 
  def recv_getDefaultAddressId(self, ):
1395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1396 
    if mtype == TMessageType.EXCEPTION:
1397 
      x = TApplicationException()
1398 
      x.read(self._iprot)
1399 
      self._iprot.readMessageEnd()
1400 
      raise x
1401 
    result = getDefaultAddressId_result()
1402 
    result.read(self._iprot)
1403 
    self._iprot.readMessageEnd()
3431 rajveer 1404 
    if result.success is not None:
594 rajveer 1405 
      return result.success
3431 rajveer 1406 
    if result.ucx is not None:
594 rajveer 1407 
      raise result.ucx
1408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1409 
 
785 rajveer 1410 
  def getDefaultPincode(self, userId):
1411 
    """
1412 
    Parameters:
1413 
     - userId
1414 
    """
1415 
    self.send_getDefaultPincode(userId)
1416 
    return self.recv_getDefaultPincode()
1417 
 
1418 
  def send_getDefaultPincode(self, userId):
1419 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1420 
    args = getDefaultPincode_args()
1421 
    args.userId = userId
1422 
    args.write(self._oprot)
1423 
    self._oprot.writeMessageEnd()
1424 
    self._oprot.trans.flush()
1425 
 
1426 
  def recv_getDefaultPincode(self, ):
1427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1428 
    if mtype == TMessageType.EXCEPTION:
1429 
      x = TApplicationException()
1430 
      x.read(self._iprot)
1431 
      self._iprot.readMessageEnd()
1432 
      raise x
1433 
    result = getDefaultPincode_result()
1434 
    result.read(self._iprot)
1435 
    self._iprot.readMessageEnd()
3431 rajveer 1436 
    if result.success is not None:
785 rajveer 1437 
      return result.success
3431 rajveer 1438 
    if result.ucx is not None:
785 rajveer 1439 
      raise result.ucx
1440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1441 
 
1274 varun.gupt 1442 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1443 
    """
1444 
    Parameters:
1445 
     - userId
1446 
     - replyTo
1447 
     - communicationType
1448 
     - orderId
1449 
     - airwaybillNo
1450 
     - productName
1451 
     - subject
1452 
     - message
1453 
    """
1454 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1455 
    return self.recv_saveUserCommunication()
1456 
 
1457 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1458 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1459 
    args = saveUserCommunication_args()
1460 
    args.userId = userId
1461 
    args.replyTo = replyTo
1462 
    args.communicationType = communicationType
1463 
    args.orderId = orderId
1464 
    args.airwaybillNo = airwaybillNo
1465 
    args.productName = productName
1466 
    args.subject = subject
1467 
    args.message = message
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_saveUserCommunication(self, ):
1473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1474 
    if mtype == TMessageType.EXCEPTION:
1475 
      x = TApplicationException()
1476 
      x.read(self._iprot)
1477 
      self._iprot.readMessageEnd()
1478 
      raise x
1479 
    result = saveUserCommunication_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
3431 rajveer 1482 
    if result.success is not None:
1274 varun.gupt 1483 
      return result.success
3431 rajveer 1484 
    if result.ucx is not None:
1274 varun.gupt 1485 
      raise result.ucx
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1487 
 
1590 varun.gupt 1488 
  def getUserCommunicationById(self, id):
1489 
    """
1490 
    Parameters:
1491 
     - id
1492 
    """
1493 
    self.send_getUserCommunicationById(id)
1494 
    return self.recv_getUserCommunicationById()
1495 
 
1496 
  def send_getUserCommunicationById(self, id):
1497 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1498 
    args = getUserCommunicationById_args()
1499 
    args.id = id
1500 
    args.write(self._oprot)
1501 
    self._oprot.writeMessageEnd()
1502 
    self._oprot.trans.flush()
1503 
 
1504 
  def recv_getUserCommunicationById(self, ):
1505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1506 
    if mtype == TMessageType.EXCEPTION:
1507 
      x = TApplicationException()
1508 
      x.read(self._iprot)
1509 
      self._iprot.readMessageEnd()
1510 
      raise x
1511 
    result = getUserCommunicationById_result()
1512 
    result.read(self._iprot)
1513 
    self._iprot.readMessageEnd()
3431 rajveer 1514 
    if result.success is not None:
1590 varun.gupt 1515 
      return result.success
3431 rajveer 1516 
    if result.ucx is not None:
1590 varun.gupt 1517 
      raise result.ucx
1518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1519 
 
1520 
  def getUserCommunicationByUser(self, userId):
1521 
    """
1522 
    Parameters:
1523 
     - userId
1524 
    """
1525 
    self.send_getUserCommunicationByUser(userId)
1526 
    return self.recv_getUserCommunicationByUser()
1527 
 
1528 
  def send_getUserCommunicationByUser(self, userId):
1529 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1530 
    args = getUserCommunicationByUser_args()
1531 
    args.userId = userId
1532 
    args.write(self._oprot)
1533 
    self._oprot.writeMessageEnd()
1534 
    self._oprot.trans.flush()
1535 
 
1536 
  def recv_getUserCommunicationByUser(self, ):
1537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1538 
    if mtype == TMessageType.EXCEPTION:
1539 
      x = TApplicationException()
1540 
      x.read(self._iprot)
1541 
      self._iprot.readMessageEnd()
1542 
      raise x
1543 
    result = getUserCommunicationByUser_result()
1544 
    result.read(self._iprot)
1545 
    self._iprot.readMessageEnd()
3431 rajveer 1546 
    if result.success is not None:
1590 varun.gupt 1547 
      return result.success
3431 rajveer 1548 
    if result.ucx is not None:
1590 varun.gupt 1549 
      raise result.ucx
1550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1551 
 
1552 
  def getAllUserCommunications(self, ):
1553 
    self.send_getAllUserCommunications()
1554 
    return self.recv_getAllUserCommunications()
1555 
 
1556 
  def send_getAllUserCommunications(self, ):
1557 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1558 
    args = getAllUserCommunications_args()
1559 
    args.write(self._oprot)
1560 
    self._oprot.writeMessageEnd()
1561 
    self._oprot.trans.flush()
1562 
 
1563 
  def recv_getAllUserCommunications(self, ):
1564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1565 
    if mtype == TMessageType.EXCEPTION:
1566 
      x = TApplicationException()
1567 
      x.read(self._iprot)
1568 
      self._iprot.readMessageEnd()
1569 
      raise x
1570 
    result = getAllUserCommunications_result()
1571 
    result.read(self._iprot)
1572 
    self._iprot.readMessageEnd()
3431 rajveer 1573 
    if result.success is not None:
1590 varun.gupt 1574 
      return result.success
3431 rajveer 1575 
    if result.ucx is not None:
1590 varun.gupt 1576 
      raise result.ucx
1577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1578 
 
5407 amar.kumar 1579 
  def removeUserCommunication(self, id):
1580 
    """
1581 
    Parameters:
1582 
     - id
1583 
    """
1584 
    self.send_removeUserCommunication(id)
1585 
    self.recv_removeUserCommunication()
1586 
 
1587 
  def send_removeUserCommunication(self, id):
1588 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1589 
    args = removeUserCommunication_args()
1590 
    args.id = id
1591 
    args.write(self._oprot)
1592 
    self._oprot.writeMessageEnd()
1593 
    self._oprot.trans.flush()
1594 
 
1595 
  def recv_removeUserCommunication(self, ):
1596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1597 
    if mtype == TMessageType.EXCEPTION:
1598 
      x = TApplicationException()
1599 
      x.read(self._iprot)
1600 
      self._iprot.readMessageEnd()
1601 
      raise x
1602 
    result = removeUserCommunication_result()
1603 
    result.read(self._iprot)
1604 
    self._iprot.readMessageEnd()
1605 
    if result.ucx is not None:
1606 
      raise result.ucx
1607 
    return
1608 
 
1859 vikas 1609 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1610 
    """
1611 
    Parameters:
1612 
     - name
1859 vikas 1613 
     - addedOn
1845 vikas 1614 
    """
1859 vikas 1615 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1616 
    return self.recv_createMasterAffiliate()
1617 
 
1859 vikas 1618 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1619 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1620 
    args = createMasterAffiliate_args()
1621 
    args.name = name
1859 vikas 1622 
    args.addedOn = addedOn
1845 vikas 1623 
    args.write(self._oprot)
1624 
    self._oprot.writeMessageEnd()
1625 
    self._oprot.trans.flush()
1626 
 
1627 
  def recv_createMasterAffiliate(self, ):
1628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1629 
    if mtype == TMessageType.EXCEPTION:
1630 
      x = TApplicationException()
1631 
      x.read(self._iprot)
1632 
      self._iprot.readMessageEnd()
1633 
      raise x
1634 
    result = createMasterAffiliate_result()
1635 
    result.read(self._iprot)
1636 
    self._iprot.readMessageEnd()
3431 rajveer 1637 
    if result.success is not None:
1845 vikas 1638 
      return result.success
3431 rajveer 1639 
    if result.utx is not None:
1845 vikas 1640 
      raise result.utx
1641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1642 
 
1899 vikas 1643 
  def getAllMasterAffiliates(self, ):
1644 
    self.send_getAllMasterAffiliates()
1645 
    return self.recv_getAllMasterAffiliates()
1646 
 
1647 
  def send_getAllMasterAffiliates(self, ):
1648 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1649 
    args = getAllMasterAffiliates_args()
1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
1654 
  def recv_getAllMasterAffiliates(self, ):
1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
1661 
    result = getAllMasterAffiliates_result()
1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
3431 rajveer 1664 
    if result.success is not None:
1899 vikas 1665 
      return result.success
3431 rajveer 1666 
    if result.utx is not None:
1899 vikas 1667 
      raise result.utx
1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1669 
 
1845 vikas 1670 
  def getMasterAffiliateById(self, id):
1671 
    """
1672 
    Parameters:
1673 
     - id
1674 
    """
1675 
    self.send_getMasterAffiliateById(id)
1676 
    return self.recv_getMasterAffiliateById()
1677 
 
1678 
  def send_getMasterAffiliateById(self, id):
1679 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1680 
    args = getMasterAffiliateById_args()
1681 
    args.id = id
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_getMasterAffiliateById(self, ):
1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
1693 
    result = getMasterAffiliateById_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
3431 rajveer 1696 
    if result.success is not None:
1845 vikas 1697 
      return result.success
3431 rajveer 1698 
    if result.utx is not None:
1845 vikas 1699 
      raise result.utx
1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1701 
 
1702 
  def getMasterAffiliateByName(self, name):
1703 
    """
1704 
    Parameters:
1705 
     - name
1706 
    """
1707 
    self.send_getMasterAffiliateByName(name)
1708 
    return self.recv_getMasterAffiliateByName()
1709 
 
1710 
  def send_getMasterAffiliateByName(self, name):
1711 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1712 
    args = getMasterAffiliateByName_args()
1713 
    args.name = name
1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
1718 
  def recv_getMasterAffiliateByName(self, ):
1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
1725 
    result = getMasterAffiliateByName_result()
1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
3431 rajveer 1728 
    if result.success is not None:
1845 vikas 1729 
      return result.success
3431 rajveer 1730 
    if result.utx is not None:
1845 vikas 1731 
      raise result.utx
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1733 
 
1859 vikas 1734 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1735 
    """
1736 
    Parameters:
1737 
     - name
1738 
     - url
1739 
     - masterAffiliateId
1859 vikas 1740 
     - addedOn
1845 vikas 1741 
    """
1859 vikas 1742 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1743 
    return self.recv_createAffiliate()
1744 
 
1859 vikas 1745 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1746 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1747 
    args = createAffiliate_args()
1748 
    args.name = name
1749 
    args.url = url
1750 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1751 
    args.addedOn = addedOn
1845 vikas 1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_createAffiliate(self, ):
1757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1758 
    if mtype == TMessageType.EXCEPTION:
1759 
      x = TApplicationException()
1760 
      x.read(self._iprot)
1761 
      self._iprot.readMessageEnd()
1762 
      raise x
1763 
    result = createAffiliate_result()
1764 
    result.read(self._iprot)
1765 
    self._iprot.readMessageEnd()
3431 rajveer 1766 
    if result.success is not None:
1845 vikas 1767 
      return result.success
3431 rajveer 1768 
    if result.utx is not None:
1845 vikas 1769 
      raise result.utx
1770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1771 
 
1772 
  def getAffiliateById(self, id):
1773 
    """
1774 
    Parameters:
1775 
     - id
1776 
    """
1777 
    self.send_getAffiliateById(id)
1778 
    return self.recv_getAffiliateById()
1779 
 
1780 
  def send_getAffiliateById(self, id):
1781 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1782 
    args = getAffiliateById_args()
1783 
    args.id = id
1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
1788 
  def recv_getAffiliateById(self, ):
1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
1795 
    result = getAffiliateById_result()
1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
3431 rajveer 1798 
    if result.success is not None:
1845 vikas 1799 
      return result.success
3431 rajveer 1800 
    if result.utx is not None:
1845 vikas 1801 
      raise result.utx
1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1803 
 
1804 
  def getAffiliateByName(self, name):
1805 
    """
1806 
    Parameters:
1807 
     - name
1808 
    """
1809 
    self.send_getAffiliateByName(name)
1810 
    return self.recv_getAffiliateByName()
1811 
 
1812 
  def send_getAffiliateByName(self, name):
1813 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1814 
    args = getAffiliateByName_args()
1815 
    args.name = name
1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getAffiliateByName(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getAffiliateByName_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
3431 rajveer 1830 
    if result.success is not None:
1845 vikas 1831 
      return result.success
3431 rajveer 1832 
    if result.utx is not None:
1845 vikas 1833 
      raise result.utx
1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1835 
 
1996 vikas 1836 
  def getTrackerById(self, id):
1845 vikas 1837 
    """
1838 
    Parameters:
1839 
     - id
1840 
    """
1996 vikas 1841 
    self.send_getTrackerById(id)
1845 vikas 1842 
    return self.recv_getTrackerById()
1843 
 
1996 vikas 1844 
  def send_getTrackerById(self, id):
1845 vikas 1845 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1846 
    args = getTrackerById_args()
1996 vikas 1847 
    args.id = id
1845 vikas 1848 
    args.write(self._oprot)
1849 
    self._oprot.writeMessageEnd()
1850 
    self._oprot.trans.flush()
1851 
 
1852 
  def recv_getTrackerById(self, ):
1853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1854 
    if mtype == TMessageType.EXCEPTION:
1855 
      x = TApplicationException()
1856 
      x.read(self._iprot)
1857 
      self._iprot.readMessageEnd()
1858 
      raise x
1859 
    result = getTrackerById_result()
1860 
    result.read(self._iprot)
1861 
    self._iprot.readMessageEnd()
3431 rajveer 1862 
    if result.success is not None:
1845 vikas 1863 
      return result.success
3431 rajveer 1864 
    if result.utx is not None:
1845 vikas 1865 
      raise result.utx
1866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1867 
 
1996 vikas 1868 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1869 
    """
1870 
    Parameters:
1996 vikas 1871 
     - id
1845 vikas 1872 
    """
1996 vikas 1873 
    self.send_getAffiliatesByMasterAffiliate(id)
1874 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1875 
 
1996 vikas 1876 
  def send_getAffiliatesByMasterAffiliate(self, id):
1877 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1878 
    args = getAffiliatesByMasterAffiliate_args()
1879 
    args.id = id
1845 vikas 1880 
    args.write(self._oprot)
1881 
    self._oprot.writeMessageEnd()
1882 
    self._oprot.trans.flush()
1883 
 
1996 vikas 1884 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1886 
    if mtype == TMessageType.EXCEPTION:
1887 
      x = TApplicationException()
1888 
      x.read(self._iprot)
1889 
      self._iprot.readMessageEnd()
1890 
      raise x
1996 vikas 1891 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1892 
    result.read(self._iprot)
1893 
    self._iprot.readMessageEnd()
3431 rajveer 1894 
    if result.success is not None:
1845 vikas 1895 
      return result.success
3431 rajveer 1896 
    if result.utx is not None:
1845 vikas 1897 
      raise result.utx
1996 vikas 1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1899 
 
1996 vikas 1900 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1901 
    """
1902 
    Parameters:
1996 vikas 1903 
     - affiliateId
1845 vikas 1904 
     - userId
1905 
     - event
1906 
     - url
1907 
     - data
1859 vikas 1908 
     - addedOn
1845 vikas 1909 
    """
1996 vikas 1910 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1911 
    return self.recv_addTrackLog()
1912 
 
1996 vikas 1913 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1914 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1915 
    args = addTrackLog_args()
1996 vikas 1916 
    args.affiliateId = affiliateId
1845 vikas 1917 
    args.userId = userId
1918 
    args.event = event
1919 
    args.url = url
1920 
    args.data = data
1859 vikas 1921 
    args.addedOn = addedOn
1845 vikas 1922 
    args.write(self._oprot)
1923 
    self._oprot.writeMessageEnd()
1924 
    self._oprot.trans.flush()
1925 
 
1926 
  def recv_addTrackLog(self, ):
1927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1928 
    if mtype == TMessageType.EXCEPTION:
1929 
      x = TApplicationException()
1930 
      x.read(self._iprot)
1931 
      self._iprot.readMessageEnd()
1932 
      raise x
1933 
    result = addTrackLog_result()
1934 
    result.read(self._iprot)
1935 
    self._iprot.readMessageEnd()
3431 rajveer 1936 
    if result.success is not None:
1845 vikas 1937 
      return result.success
3431 rajveer 1938 
    if result.utx is not None:
1845 vikas 1939 
      raise result.utx
1940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1941 
 
1942 
  def getTrackLogById(self, id):
1943 
    """
1944 
    Parameters:
1945 
     - id
1946 
    """
1947 
    self.send_getTrackLogById(id)
1948 
    return self.recv_getTrackLogById()
1949 
 
1950 
  def send_getTrackLogById(self, id):
1951 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1952 
    args = getTrackLogById_args()
1953 
    args.id = id
1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
1958 
  def recv_getTrackLogById(self, ):
1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
1965 
    result = getTrackLogById_result()
1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
3431 rajveer 1968 
    if result.success is not None:
1845 vikas 1969 
      return result.success
3431 rajveer 1970 
    if result.utx is not None:
1845 vikas 1971 
      raise result.utx
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1973 
 
3293 vikas 1974 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1975 
    """
1976 
    Parameters:
1996 vikas 1977 
     - affiliateId
3293 vikas 1978 
     - startDate
1979 
     - endDate
1845 vikas 1980 
    """
3293 vikas 1981 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1982 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1983 
 
3293 vikas 1984 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1985 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1986 
    args = getTrackLogsByAffiliate_args()
1987 
    args.affiliateId = affiliateId
3293 vikas 1988 
    args.startDate = startDate
1989 
    args.endDate = endDate
1845 vikas 1990 
    args.write(self._oprot)
1991 
    self._oprot.writeMessageEnd()
1992 
    self._oprot.trans.flush()
1993 
 
1996 vikas 1994 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1996 
    if mtype == TMessageType.EXCEPTION:
1997 
      x = TApplicationException()
1998 
      x.read(self._iprot)
1999 
      self._iprot.readMessageEnd()
2000 
      raise x
1996 vikas 2001 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2002 
    result.read(self._iprot)
2003 
    self._iprot.readMessageEnd()
3431 rajveer 2004 
    if result.success is not None:
1845 vikas 2005 
      return result.success
3431 rajveer 2006 
    if result.utx is not None:
1845 vikas 2007 
      raise result.utx
1996 vikas 2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2009 
 
2010 
  def getTrackLogsByUser(self, userId):
2011 
    """
2012 
    Parameters:
2013 
     - userId
2014 
    """
2015 
    self.send_getTrackLogsByUser(userId)
2016 
    return self.recv_getTrackLogsByUser()
2017 
 
2018 
  def send_getTrackLogsByUser(self, userId):
2019 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2020 
    args = getTrackLogsByUser_args()
2021 
    args.userId = userId
2022 
    args.write(self._oprot)
2023 
    self._oprot.writeMessageEnd()
2024 
    self._oprot.trans.flush()
2025 
 
2026 
  def recv_getTrackLogsByUser(self, ):
2027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2028 
    if mtype == TMessageType.EXCEPTION:
2029 
      x = TApplicationException()
2030 
      x.read(self._iprot)
2031 
      self._iprot.readMessageEnd()
2032 
      raise x
2033 
    result = getTrackLogsByUser_result()
2034 
    result.read(self._iprot)
2035 
    self._iprot.readMessageEnd()
3431 rajveer 2036 
    if result.success is not None:
1845 vikas 2037 
      return result.success
3431 rajveer 2038 
    if result.utx is not None:
1845 vikas 2039 
      raise result.utx
2040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2041 
 
1996 vikas 2042 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2043 
    """
2044 
    Parameters:
2045 
     - userId
2046 
     - event
2047 
     - url
2048 
    """
1996 vikas 2049 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2050 
    return self.recv_getTrackLogs()
2051 
 
1996 vikas 2052 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2053 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2054 
    args = getTrackLogs_args()
2055 
    args.userId = userId
2056 
    args.event = event
2057 
    args.url = url
2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
2062 
  def recv_getTrackLogs(self, ):
2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
2069 
    result = getTrackLogs_result()
2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
3431 rajveer 2072 
    if result.success is not None:
1845 vikas 2073 
      return result.success
3431 rajveer 2074 
    if result.utx is not None:
1845 vikas 2075 
      raise result.utx
2076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2077 
 
559 chandransh 2078 
  def getCurrentCart(self, userId):
94 ashish 2079 
    """
2080 
    Parameters:
559 chandransh 2081 
     - userId
94 ashish 2082 
    """
559 chandransh 2083 
    self.send_getCurrentCart(userId)
2084 
    return self.recv_getCurrentCart()
94 ashish 2085 
 
559 chandransh 2086 
  def send_getCurrentCart(self, userId):
2087 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2088 
    args = getCurrentCart_args()
2089 
    args.userId = userId
94 ashish 2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
559 chandransh 2094 
  def recv_getCurrentCart(self, ):
94 ashish 2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
559 chandransh 2101 
    result = getCurrentCart_result()
94 ashish 2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
3431 rajveer 2104 
    if result.success is not None:
94 ashish 2105 
      return result.success
3431 rajveer 2106 
    if result.scx is not None:
559 chandransh 2107 
      raise result.scx
2108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2109 
 
559 chandransh 2110 
  def getCart(self, cartId):
94 ashish 2111 
    """
2112 
    Parameters:
559 chandransh 2113 
     - cartId
94 ashish 2114 
    """
559 chandransh 2115 
    self.send_getCart(cartId)
2116 
    return self.recv_getCart()
94 ashish 2117 
 
559 chandransh 2118 
  def send_getCart(self, cartId):
2119 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2120 
    args = getCart_args()
2121 
    args.cartId = cartId
94 ashish 2122 
    args.write(self._oprot)
2123 
    self._oprot.writeMessageEnd()
2124 
    self._oprot.trans.flush()
2125 
 
559 chandransh 2126 
  def recv_getCart(self, ):
94 ashish 2127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2128 
    if mtype == TMessageType.EXCEPTION:
2129 
      x = TApplicationException()
2130 
      x.read(self._iprot)
2131 
      self._iprot.readMessageEnd()
2132 
      raise x
559 chandransh 2133 
    result = getCart_result()
94 ashish 2134 
    result.read(self._iprot)
2135 
    self._iprot.readMessageEnd()
3431 rajveer 2136 
    if result.success is not None:
94 ashish 2137 
      return result.success
3431 rajveer 2138 
    if result.scx is not None:
559 chandransh 2139 
      raise result.scx
2140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2141 
 
559 chandransh 2142 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2143 
    """
2144 
    Parameters:
559 chandransh 2145 
     - from_time
2146 
     - to_time
2147 
     - status
94 ashish 2148 
    """
559 chandransh 2149 
    self.send_getCartsByTime(from_time, to_time, status)
2150 
    return self.recv_getCartsByTime()
94 ashish 2151 
 
559 chandransh 2152 
  def send_getCartsByTime(self, from_time, to_time, status):
2153 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2154 
    args = getCartsByTime_args()
2155 
    args.from_time = from_time
2156 
    args.to_time = to_time
2157 
    args.status = status
94 ashish 2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
559 chandransh 2162 
  def recv_getCartsByTime(self, ):
94 ashish 2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
559 chandransh 2169 
    result = getCartsByTime_result()
94 ashish 2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
3431 rajveer 2172 
    if result.success is not None:
94 ashish 2173 
      return result.success
3431 rajveer 2174 
    if result.scx is not None:
559 chandransh 2175 
      raise result.scx
2176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2177 
 
3557 rajveer 2178 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2179 
    """
2180 
    Parameters:
2181 
     - cartId
2182 
     - itemId
2183 
     - quantity
3557 rajveer 2184 
     - sourceId
559 chandransh 2185 
    """
3557 rajveer 2186 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2187 
    return self.recv_addItemToCart()
559 chandransh 2188 
 
3557 rajveer 2189 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2190 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2191 
    args = addItemToCart_args()
2192 
    args.cartId = cartId
2193 
    args.itemId = itemId
2194 
    args.quantity = quantity
3557 rajveer 2195 
    args.sourceId = sourceId
559 chandransh 2196 
    args.write(self._oprot)
2197 
    self._oprot.writeMessageEnd()
2198 
    self._oprot.trans.flush()
2199 
 
2200 
  def recv_addItemToCart(self, ):
2201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2202 
    if mtype == TMessageType.EXCEPTION:
2203 
      x = TApplicationException()
2204 
      x.read(self._iprot)
2205 
      self._iprot.readMessageEnd()
2206 
      raise x
2207 
    result = addItemToCart_result()
2208 
    result.read(self._iprot)
2209 
    self._iprot.readMessageEnd()
3431 rajveer 2210 
    if result.success is not None:
2035 rajveer 2211 
      return result.success
3431 rajveer 2212 
    if result.scx is not None:
559 chandransh 2213 
      raise result.scx
2035 rajveer 2214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2215 
 
2216 
  def deleteItemFromCart(self, cartId, itemId):
2217 
    """
2218 
    Parameters:
2219 
     - cartId
2220 
     - itemId
2221 
    """
2222 
    self.send_deleteItemFromCart(cartId, itemId)
2223 
    self.recv_deleteItemFromCart()
2224 
 
2225 
  def send_deleteItemFromCart(self, cartId, itemId):
2226 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2227 
    args = deleteItemFromCart_args()
2228 
    args.cartId = cartId
2229 
    args.itemId = itemId
2230 
    args.write(self._oprot)
2231 
    self._oprot.writeMessageEnd()
2232 
    self._oprot.trans.flush()
2233 
 
2234 
  def recv_deleteItemFromCart(self, ):
2235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2236 
    if mtype == TMessageType.EXCEPTION:
2237 
      x = TApplicationException()
2238 
      x.read(self._iprot)
2239 
      self._iprot.readMessageEnd()
2240 
      raise x
2241 
    result = deleteItemFromCart_result()
2242 
    result.read(self._iprot)
2243 
    self._iprot.readMessageEnd()
3431 rajveer 2244 
    if result.scx is not None:
559 chandransh 2245 
      raise result.scx
2246 
    return
2247 
 
2248 
  def addAddressToCart(self, cartId, addressId):
2249 
    """
2250 
    Parameters:
2251 
     - cartId
2252 
     - addressId
2253 
    """
2254 
    self.send_addAddressToCart(cartId, addressId)
2255 
    self.recv_addAddressToCart()
2256 
 
2257 
  def send_addAddressToCart(self, cartId, addressId):
2258 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2259 
    args = addAddressToCart_args()
2260 
    args.cartId = cartId
2261 
    args.addressId = addressId
2262 
    args.write(self._oprot)
2263 
    self._oprot.writeMessageEnd()
2264 
    self._oprot.trans.flush()
2265 
 
2266 
  def recv_addAddressToCart(self, ):
2267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2268 
    if mtype == TMessageType.EXCEPTION:
2269 
      x = TApplicationException()
2270 
      x.read(self._iprot)
2271 
      self._iprot.readMessageEnd()
2272 
      raise x
2273 
    result = addAddressToCart_result()
2274 
    result.read(self._iprot)
2275 
    self._iprot.readMessageEnd()
3431 rajveer 2276 
    if result.scx is not None:
575 chandransh 2277 
      raise result.scx
559 chandransh 2278 
    return
2279 
 
5553 rajveer 2280 
  def addStoreToCart(self, cartId, storeId):
2281 
    """
2282 
    Parameters:
2283 
     - cartId
2284 
     - storeId
2285 
    """
2286 
    self.send_addStoreToCart(cartId, storeId)
2287 
    self.recv_addStoreToCart()
2288 
 
2289 
  def send_addStoreToCart(self, cartId, storeId):
2290 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2291 
    args = addStoreToCart_args()
2292 
    args.cartId = cartId
2293 
    args.storeId = storeId
2294 
    args.write(self._oprot)
2295 
    self._oprot.writeMessageEnd()
2296 
    self._oprot.trans.flush()
2297 
 
2298 
  def recv_addStoreToCart(self, ):
2299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2300 
    if mtype == TMessageType.EXCEPTION:
2301 
      x = TApplicationException()
2302 
      x.read(self._iprot)
2303 
      self._iprot.readMessageEnd()
2304 
      raise x
2305 
    result = addStoreToCart_result()
2306 
    result.read(self._iprot)
2307 
    self._iprot.readMessageEnd()
2308 
    if result.scx is not None:
2309 
      raise result.scx
2310 
    return
2311 
 
6922 anupam.sin 2312 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2313 
    """
2314 
    Parameters:
6922 anupam.sin 2315 
     - cart
1976 varun.gupt 2316 
     - couponCode
2317 
    """
6922 anupam.sin 2318 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2319 
    self.recv_applyCouponToCart()
2320 
 
6922 anupam.sin 2321 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2322 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2323 
    args = applyCouponToCart_args()
6922 anupam.sin 2324 
    args.cart = cart
1976 varun.gupt 2325 
    args.couponCode = couponCode
2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
2330 
  def recv_applyCouponToCart(self, ):
2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
2337 
    result = applyCouponToCart_result()
2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.scx is not None:
1976 varun.gupt 2341 
      raise result.scx
2342 
    return
2343 
 
2344 
  def removeCoupon(self, cartId):
2345 
    """
2346 
    Parameters:
2347 
     - cartId
2348 
    """
2349 
    self.send_removeCoupon(cartId)
2350 
    self.recv_removeCoupon()
2351 
 
2352 
  def send_removeCoupon(self, cartId):
2353 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2354 
    args = removeCoupon_args()
2355 
    args.cartId = cartId
2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
2360 
  def recv_removeCoupon(self, ):
2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
2367 
    result = removeCoupon_result()
2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
3431 rajveer 2370 
    if result.scx is not None:
1976 varun.gupt 2371 
      raise result.scx
2372 
    return
2373 
 
3554 varun.gupt 2374 
  def deleteDiscountsFromCart(self, cartId):
2375 
    """
2376 
    Deletes all the discounts associated with the cart
2377 
 
2378 
    Parameters:
2379 
     - cartId
2380 
    """
2381 
    self.send_deleteDiscountsFromCart(cartId)
2382 
    self.recv_deleteDiscountsFromCart()
2383 
 
2384 
  def send_deleteDiscountsFromCart(self, cartId):
2385 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2386 
    args = deleteDiscountsFromCart_args()
2387 
    args.cartId = cartId
2388 
    args.write(self._oprot)
2389 
    self._oprot.writeMessageEnd()
2390 
    self._oprot.trans.flush()
2391 
 
2392 
  def recv_deleteDiscountsFromCart(self, ):
2393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2394 
    if mtype == TMessageType.EXCEPTION:
2395 
      x = TApplicationException()
2396 
      x.read(self._iprot)
2397 
      self._iprot.readMessageEnd()
2398 
      raise x
2399 
    result = deleteDiscountsFromCart_result()
2400 
    result.read(self._iprot)
2401 
    self._iprot.readMessageEnd()
2402 
    if result.scx is not None:
2403 
      raise result.scx
2404 
    return
2405 
 
2406 
  def saveDiscounts(self, discounts):
2407 
    """
2408 
    Accepts a list of thrift objects of Discount type and saves them
2409 
 
2410 
    Parameters:
2411 
     - discounts
2412 
    """
2413 
    self.send_saveDiscounts(discounts)
2414 
    self.recv_saveDiscounts()
2415 
 
2416 
  def send_saveDiscounts(self, discounts):
2417 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2418 
    args = saveDiscounts_args()
2419 
    args.discounts = discounts
2420 
    args.write(self._oprot)
2421 
    self._oprot.writeMessageEnd()
2422 
    self._oprot.trans.flush()
2423 
 
2424 
  def recv_saveDiscounts(self, ):
2425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2426 
    if mtype == TMessageType.EXCEPTION:
2427 
      x = TApplicationException()
2428 
      x.read(self._iprot)
2429 
      self._iprot.readMessageEnd()
2430 
      raise x
2431 
    result = saveDiscounts_result()
2432 
    result.read(self._iprot)
2433 
    self._iprot.readMessageEnd()
2434 
    if result.scx is not None:
2435 
      raise result.scx
2436 
    return
2437 
 
11526 amit.gupta 2438 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2439 
    """
690 chandransh 2440 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2441 
 
559 chandransh 2442 
    Parameters:
2443 
     - cartId
2815 vikas 2444 
     - sessionSource
2445 
     - sessionStartTime
3858 vikas 2446 
     - firstSource
2447 
     - firstSourceTime
5326 rajveer 2448 
     - userId
6389 rajveer 2449 
     - schemeId
11526 amit.gupta 2450 
     - orderSource
559 chandransh 2451 
    """
11526 amit.gupta 2452 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2453 
    return self.recv_createOrders()
559 chandransh 2454 
 
11526 amit.gupta 2455 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2456 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2457 
    args = createOrders_args()
559 chandransh 2458 
    args.cartId = cartId
2815 vikas 2459 
    args.sessionSource = sessionSource
2460 
    args.sessionStartTime = sessionStartTime
3858 vikas 2461 
    args.firstSource = firstSource
2462 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2463 
    args.userId = userId
6389 rajveer 2464 
    args.schemeId = schemeId
11526 amit.gupta 2465 
    args.orderSource = orderSource
559 chandransh 2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
690 chandransh 2470 
  def recv_createOrders(self, ):
559 chandransh 2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
690 chandransh 2477 
    result = createOrders_result()
559 chandransh 2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
3431 rajveer 2480 
    if result.success is not None:
130 ashish 2481 
      return result.success
3431 rajveer 2482 
    if result.scx is not None:
559 chandransh 2483 
      raise result.scx
690 chandransh 2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2485 
 
3557 rajveer 2486 
  def validateCart(self, cartId, sourceId):
130 ashish 2487 
    """
690 chandransh 2488 
    Validates that:
2489 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2490 
    2. All of the lines in the cart are active items.
690 chandransh 2491 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2492 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2493 
 
130 ashish 2494 
    Parameters:
559 chandransh 2495 
     - cartId
3557 rajveer 2496 
     - sourceId
130 ashish 2497 
    """
3557 rajveer 2498 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2499 
    return self.recv_validateCart()
130 ashish 2500 
 
3557 rajveer 2501 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2502 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2503 
    args = validateCart_args()
2504 
    args.cartId = cartId
3557 rajveer 2505 
    args.sourceId = sourceId
130 ashish 2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
559 chandransh 2510 
  def recv_validateCart(self, ):
130 ashish 2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
559 chandransh 2517 
    result = validateCart_result()
130 ashish 2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
3431 rajveer 2520 
    if result.success is not None:
130 ashish 2521 
      return result.success
3431 rajveer 2522 
    if result.scex is not None:
575 chandransh 2523 
      raise result.scex
559 chandransh 2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2525 
 
11980 amit.gupta 2526 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2527 
    """
2528 
    Validates that:
2529 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2530 
    2. All of the lines in the cart are active items.
2531 
    3. The estimate for any of the lines in cart doesn't change.
2532 
    If all three are true, returns empty string; else returns appropriate message.
2533 
 
2534 
    Parameters:
2535 
     - cartId
2536 
     - sourceId
2537 
     - dealCoupon
2538 
    """
2539 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2540 
    return self.recv_validateCartWithDealerCoupon()
2541 
 
2542 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2543 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2544 
    args = validateCartWithDealerCoupon_args()
2545 
    args.cartId = cartId
2546 
    args.sourceId = sourceId
2547 
    args.dealCoupon = dealCoupon
2548 
    args.write(self._oprot)
2549 
    self._oprot.writeMessageEnd()
2550 
    self._oprot.trans.flush()
2551 
 
2552 
  def recv_validateCartWithDealerCoupon(self, ):
2553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2554 
    if mtype == TMessageType.EXCEPTION:
2555 
      x = TApplicationException()
2556 
      x.read(self._iprot)
2557 
      self._iprot.readMessageEnd()
2558 
      raise x
2559 
    result = validateCartWithDealerCoupon_result()
2560 
    result.read(self._iprot)
2561 
    self._iprot.readMessageEnd()
2562 
    if result.success is not None:
2563 
      return result.success
2564 
    if result.scex is not None:
2565 
      raise result.scex
2566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2567 
 
690 chandransh 2568 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2569 
    """
690 chandransh 2570 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2571 
 
575 chandransh 2572 
    Parameters:
690 chandransh 2573 
     - fromCartId
2574 
     - toCartId
2575 
    """
2576 
    self.send_mergeCart(fromCartId, toCartId)
2577 
    self.recv_mergeCart()
2578 
 
2579 
  def send_mergeCart(self, fromCartId, toCartId):
2580 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2581 
    args = mergeCart_args()
2582 
    args.fromCartId = fromCartId
2583 
    args.toCartId = toCartId
2584 
    args.write(self._oprot)
2585 
    self._oprot.writeMessageEnd()
2586 
    self._oprot.trans.flush()
2587 
 
2588 
  def recv_mergeCart(self, ):
2589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2590 
    if mtype == TMessageType.EXCEPTION:
2591 
      x = TApplicationException()
2592 
      x.read(self._iprot)
2593 
      self._iprot.readMessageEnd()
2594 
      raise x
2595 
    result = mergeCart_result()
2596 
    result.read(self._iprot)
2597 
    self._iprot.readMessageEnd()
2598 
    return
2599 
 
2600 
  def checkOut(self, cartId):
2601 
    """
2602 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2603 
 
690 chandransh 2604 
    Parameters:
575 chandransh 2605 
     - cartId
2606 
    """
690 chandransh 2607 
    self.send_checkOut(cartId)
2608 
    return self.recv_checkOut()
575 chandransh 2609 
 
690 chandransh 2610 
  def send_checkOut(self, cartId):
2611 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2612 
    args = checkOut_args()
575 chandransh 2613 
    args.cartId = cartId
2614 
    args.write(self._oprot)
2615 
    self._oprot.writeMessageEnd()
2616 
    self._oprot.trans.flush()
2617 
 
690 chandransh 2618 
  def recv_checkOut(self, ):
575 chandransh 2619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2620 
    if mtype == TMessageType.EXCEPTION:
2621 
      x = TApplicationException()
2622 
      x.read(self._iprot)
2623 
      self._iprot.readMessageEnd()
2624 
      raise x
690 chandransh 2625 
    result = checkOut_result()
575 chandransh 2626 
    result.read(self._iprot)
2627 
    self._iprot.readMessageEnd()
3431 rajveer 2628 
    if result.success is not None:
575 chandransh 2629 
      return result.success
3431 rajveer 2630 
    if result.scex is not None:
575 chandransh 2631 
      raise result.scex
690 chandransh 2632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2633 
 
690 chandransh 2634 
  def resetCart(self, cartId, items):
559 chandransh 2635 
    """
690 chandransh 2636 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2637 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2638 
 
559 chandransh 2639 
    Parameters:
690 chandransh 2640 
     - cartId
2641 
     - items
559 chandransh 2642 
    """
690 chandransh 2643 
    self.send_resetCart(cartId, items)
2644 
    return self.recv_resetCart()
130 ashish 2645 
 
690 chandransh 2646 
  def send_resetCart(self, cartId, items):
2647 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2648 
    args = resetCart_args()
2649 
    args.cartId = cartId
2650 
    args.items = items
559 chandransh 2651 
    args.write(self._oprot)
2652 
    self._oprot.writeMessageEnd()
2653 
    self._oprot.trans.flush()
2654 
 
690 chandransh 2655 
  def recv_resetCart(self, ):
559 chandransh 2656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2657 
    if mtype == TMessageType.EXCEPTION:
2658 
      x = TApplicationException()
2659 
      x.read(self._iprot)
2660 
      self._iprot.readMessageEnd()
2661 
      raise x
690 chandransh 2662 
    result = resetCart_result()
559 chandransh 2663 
    result.read(self._iprot)
2664 
    self._iprot.readMessageEnd()
3431 rajveer 2665 
    if result.success is not None:
690 chandransh 2666 
      return result.success
3431 rajveer 2667 
    if result.scex is not None:
690 chandransh 2668 
      raise result.scex
2669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2670 
 
2981 rajveer 2671 
  def getUserCount(self, userType):
559 chandransh 2672 
    """
2981 rajveer 2673 
    Returns number of registered users.
2674 
    If userType = null, then it returns count of all users, including anonymous
2675 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2676 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2677 
 
559 chandransh 2678 
    Parameters:
2981 rajveer 2679 
     - userType
559 chandransh 2680 
    """
2981 rajveer 2681 
    self.send_getUserCount(userType)
2682 
    return self.recv_getUserCount()
559 chandransh 2683 
 
2981 rajveer 2684 
  def send_getUserCount(self, userType):
2685 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2686 
    args = getUserCount_args()
2687 
    args.userType = userType
559 chandransh 2688 
    args.write(self._oprot)
2689 
    self._oprot.writeMessageEnd()
2690 
    self._oprot.trans.flush()
2691 
 
2981 rajveer 2692 
  def recv_getUserCount(self, ):
559 chandransh 2693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2694 
    if mtype == TMessageType.EXCEPTION:
2695 
      x = TApplicationException()
2696 
      x.read(self._iprot)
2697 
      self._iprot.readMessageEnd()
2698 
      raise x
2981 rajveer 2699 
    result = getUserCount_result()
559 chandransh 2700 
    result.read(self._iprot)
2701 
    self._iprot.readMessageEnd()
3431 rajveer 2702 
    if result.success is not None:
559 chandransh 2703 
      return result.success
2981 rajveer 2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2705 
 
2981 rajveer 2706 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2707 
    """
2981 rajveer 2708 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2709 
    If any of startDate or endDate is -1, then that filter is ignored.
2710 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2711 
 
2712 
 
559 chandransh 2713 
    Parameters:
2981 rajveer 2714 
     - userType
2715 
     - startDate
2716 
     - endDate
559 chandransh 2717 
    """
2981 rajveer 2718 
    self.send_getAllUsers(userType, startDate, endDate)
2719 
    return self.recv_getAllUsers()
559 chandransh 2720 
 
2981 rajveer 2721 
  def send_getAllUsers(self, userType, startDate, endDate):
2722 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2723 
    args = getAllUsers_args()
2724 
    args.userType = userType
2725 
    args.startDate = startDate
2726 
    args.endDate = endDate
559 chandransh 2727 
    args.write(self._oprot)
2728 
    self._oprot.writeMessageEnd()
2729 
    self._oprot.trans.flush()
2730 
 
2981 rajveer 2731 
  def recv_getAllUsers(self, ):
559 chandransh 2732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2733 
    if mtype == TMessageType.EXCEPTION:
2734 
      x = TApplicationException()
2735 
      x.read(self._iprot)
2736 
      self._iprot.readMessageEnd()
2737 
      raise x
2981 rajveer 2738 
    result = getAllUsers_result()
559 chandransh 2739 
    result.read(self._iprot)
2740 
    self._iprot.readMessageEnd()
3431 rajveer 2741 
    if result.success is not None:
559 chandransh 2742 
      return result.success
2981 rajveer 2743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2744 
 
2981 rajveer 2745 
  def getMyResearchItems(self, userId):
559 chandransh 2746 
    """
2981 rajveer 2747 
    Returns list of item ids in myresearch for the user
3431 rajveer 2748 
 
559 chandransh 2749 
    Parameters:
772 rajveer 2750 
     - userId
559 chandransh 2751 
    """
2981 rajveer 2752 
    self.send_getMyResearchItems(userId)
2753 
    return self.recv_getMyResearchItems()
559 chandransh 2754 
 
2981 rajveer 2755 
  def send_getMyResearchItems(self, userId):
2756 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2757 
    args = getMyResearchItems_args()
772 rajveer 2758 
    args.userId = userId
559 chandransh 2759 
    args.write(self._oprot)
2760 
    self._oprot.writeMessageEnd()
2761 
    self._oprot.trans.flush()
2762 
 
2981 rajveer 2763 
  def recv_getMyResearchItems(self, ):
559 chandransh 2764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2765 
    if mtype == TMessageType.EXCEPTION:
2766 
      x = TApplicationException()
2767 
      x.read(self._iprot)
2768 
      self._iprot.readMessageEnd()
2769 
      raise x
2981 rajveer 2770 
    result = getMyResearchItems_result()
559 chandransh 2771 
    result.read(self._iprot)
2772 
    self._iprot.readMessageEnd()
3431 rajveer 2773 
    if result.success is not None:
559 chandransh 2774 
      return result.success
3431 rajveer 2775 
    if result.scx is not None:
559 chandransh 2776 
      raise result.scx
2981 rajveer 2777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2778 
 
2981 rajveer 2779 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2780 
    """
2981 rajveer 2781 
    add item to my research for a user
3431 rajveer 2782 
 
559 chandransh 2783 
    Parameters:
2981 rajveer 2784 
     - userId
2785 
     - itemId
559 chandransh 2786 
    """
2981 rajveer 2787 
    self.send_updateMyResearch(userId, itemId)
2788 
    return self.recv_updateMyResearch()
559 chandransh 2789 
 
2981 rajveer 2790 
  def send_updateMyResearch(self, userId, itemId):
2791 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2792 
    args = updateMyResearch_args()
2793 
    args.userId = userId
2794 
    args.itemId = itemId
559 chandransh 2795 
    args.write(self._oprot)
2796 
    self._oprot.writeMessageEnd()
2797 
    self._oprot.trans.flush()
2798 
 
2981 rajveer 2799 
  def recv_updateMyResearch(self, ):
559 chandransh 2800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2801 
    if mtype == TMessageType.EXCEPTION:
2802 
      x = TApplicationException()
2803 
      x.read(self._iprot)
2804 
      self._iprot.readMessageEnd()
2805 
      raise x
2981 rajveer 2806 
    result = updateMyResearch_result()
559 chandransh 2807 
    result.read(self._iprot)
2808 
    self._iprot.readMessageEnd()
3431 rajveer 2809 
    if result.success is not None:
2981 rajveer 2810 
      return result.success
3431 rajveer 2811 
    if result.scx is not None:
2981 rajveer 2812 
      raise result.scx
2813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2814 
 
2981 rajveer 2815 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2816 
    """
2981 rajveer 2817 
    delete item from my research for a user
3431 rajveer 2818 
 
1596 ankur.sing 2819 
    Parameters:
2981 rajveer 2820 
     - userId
2821 
     - itemId
1596 ankur.sing 2822 
    """
2981 rajveer 2823 
    self.send_deleteItemFromMyResearch(userId, itemId)
2824 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2825 
 
2981 rajveer 2826 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2827 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2828 
    args = deleteItemFromMyResearch_args()
2829 
    args.userId = userId
2830 
    args.itemId = itemId
1596 ankur.sing 2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2981 rajveer 2835 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2981 rajveer 2842 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
3431 rajveer 2845 
    if result.scx is not None:
2981 rajveer 2846 
      raise result.scx
2847 
    return
1596 ankur.sing 2848 
 
2981 rajveer 2849 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2850 
    """
2981 rajveer 2851 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2852 
 
1673 ankur.sing 2853 
    Parameters:
2981 rajveer 2854 
     - userId
1673 ankur.sing 2855 
    """
2981 rajveer 2856 
    self.send_getBrowseHistoryItems(userId)
2857 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2858 
 
2981 rajveer 2859 
  def send_getBrowseHistoryItems(self, userId):
2860 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2861 
    args = getBrowseHistoryItems_args()
2862 
    args.userId = userId
1673 ankur.sing 2863 
    args.write(self._oprot)
2864 
    self._oprot.writeMessageEnd()
2865 
    self._oprot.trans.flush()
2866 
 
2981 rajveer 2867 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2869 
    if mtype == TMessageType.EXCEPTION:
2870 
      x = TApplicationException()
2871 
      x.read(self._iprot)
2872 
      self._iprot.readMessageEnd()
2873 
      raise x
2981 rajveer 2874 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2875 
    result.read(self._iprot)
2876 
    self._iprot.readMessageEnd()
3431 rajveer 2877 
    if result.success is not None:
1673 ankur.sing 2878 
      return result.success
3431 rajveer 2879 
    if result.scx is not None:
2981 rajveer 2880 
      raise result.scx
2881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2882 
 
2981 rajveer 2883 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2884 
    """
2981 rajveer 2885 
    add item to browse history for a user
3431 rajveer 2886 
 
2642 varun.gupt 2887 
    Parameters:
2981 rajveer 2888 
     - userId
2889 
     - itemId
2642 varun.gupt 2890 
    """
2981 rajveer 2891 
    self.send_updateBrowseHistory(userId, itemId)
2892 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2893 
 
2981 rajveer 2894 
  def send_updateBrowseHistory(self, userId, itemId):
2895 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2896 
    args = updateBrowseHistory_args()
2897 
    args.userId = userId
2898 
    args.itemId = itemId
2642 varun.gupt 2899 
    args.write(self._oprot)
2900 
    self._oprot.writeMessageEnd()
2901 
    self._oprot.trans.flush()
2902 
 
2981 rajveer 2903 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2905 
    if mtype == TMessageType.EXCEPTION:
2906 
      x = TApplicationException()
2907 
      x.read(self._iprot)
2908 
      self._iprot.readMessageEnd()
2909 
      raise x
2981 rajveer 2910 
    result = updateBrowseHistory_result()
2642 varun.gupt 2911 
    result.read(self._iprot)
2912 
    self._iprot.readMessageEnd()
2913 
    return
2914 
 
3385 varun.gupt 2915 
  def getCartsWithCouponCount(self, couponCode):
2916 
    """
2917 
    Returns count of Carts with given coupon applied
3431 rajveer 2918 
 
3385 varun.gupt 2919 
    Parameters:
2920 
     - couponCode
2921 
    """
2922 
    self.send_getCartsWithCouponCount(couponCode)
2923 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2924 
 
3385 varun.gupt 2925 
  def send_getCartsWithCouponCount(self, couponCode):
2926 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2927 
    args = getCartsWithCouponCount_args()
2928 
    args.couponCode = couponCode
2929 
    args.write(self._oprot)
2930 
    self._oprot.writeMessageEnd()
2931 
    self._oprot.trans.flush()
2932 
 
2933 
  def recv_getCartsWithCouponCount(self, ):
2934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2935 
    if mtype == TMessageType.EXCEPTION:
2936 
      x = TApplicationException()
2937 
      x.read(self._iprot)
2938 
      self._iprot.readMessageEnd()
2939 
      raise x
2940 
    result = getCartsWithCouponCount_result()
2941 
    result.read(self._iprot)
2942 
    self._iprot.readMessageEnd()
3431 rajveer 2943 
    if result.success is not None:
3385 varun.gupt 2944 
      return result.success
2945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2946 
 
3499 mandeep.dh 2947 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2948 
    """
2949 
    Updates COD trust level of a user
3385 varun.gupt 2950 
 
3499 mandeep.dh 2951 
    Parameters:
2952 
     - userId
2953 
     - trustLevelDelta
2954 
    """
2955 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2956 
 
2957 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2958 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2959 
    args = increaseTrustLevel_args()
2960 
    args.userId = userId
2961 
    args.trustLevelDelta = trustLevelDelta
2962 
    args.write(self._oprot)
2963 
    self._oprot.writeMessageEnd()
2964 
    self._oprot.trans.flush()
5407 amar.kumar 2965 
  def getTrustLevel(self, userId):
2966 
    """
2967 
    Get trust level of a user
2968 
 
2969 
    Parameters:
2970 
     - userId
2971 
    """
2972 
    self.send_getTrustLevel(userId)
2973 
    return self.recv_getTrustLevel()
2974 
 
2975 
  def send_getTrustLevel(self, userId):
2976 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2977 
    args = getTrustLevel_args()
2978 
    args.userId = userId
2979 
    args.write(self._oprot)
2980 
    self._oprot.writeMessageEnd()
2981 
    self._oprot.trans.flush()
2982 
 
2983 
  def recv_getTrustLevel(self, ):
2984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2985 
    if mtype == TMessageType.EXCEPTION:
2986 
      x = TApplicationException()
2987 
      x.read(self._iprot)
2988 
      self._iprot.readMessageEnd()
2989 
      raise x
2990 
    result = getTrustLevel_result()
2991 
    result.read(self._iprot)
2992 
    self._iprot.readMessageEnd()
2993 
    if result.success is not None:
2994 
      return result.success
2995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2996 
 
4668 varun.gupt 2997 
  def showCODOption(self, cartId, sourceId, pincode):
2998 
    """
2999 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3000 
 
4668 varun.gupt 3001 
    Parameters:
3002 
     - cartId
3003 
     - sourceId
3004 
     - pincode
3005 
    """
3006 
    self.send_showCODOption(cartId, sourceId, pincode)
3007 
    return self.recv_showCODOption()
3008 
 
3009 
  def send_showCODOption(self, cartId, sourceId, pincode):
3010 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3011 
    args = showCODOption_args()
3012 
    args.cartId = cartId
3013 
    args.sourceId = sourceId
3014 
    args.pincode = pincode
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_showCODOption(self, ):
3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3026 
    result = showCODOption_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3029 
    if result.success is not None:
3030 
      return result.success
3031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3032 
 
5623 anupam.sin 3033 
  def getUserEmails(self, startDate, endDate):
3034 
    """
3035 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3036 
 
5623 anupam.sin 3037 
    Parameters:
3038 
     - startDate
3039 
     - endDate
3040 
    """
3041 
    self.send_getUserEmails(startDate, endDate)
3042 
    return self.recv_getUserEmails()
3043 
 
3044 
  def send_getUserEmails(self, startDate, endDate):
3045 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3046 
    args = getUserEmails_args()
3047 
    args.startDate = startDate
3048 
    args.endDate = endDate
3049 
    args.write(self._oprot)
3050 
    self._oprot.writeMessageEnd()
3051 
    self._oprot.trans.flush()
3052 
 
3053 
  def recv_getUserEmails(self, ):
3054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3055 
    if mtype == TMessageType.EXCEPTION:
3056 
      x = TApplicationException()
3057 
      x.read(self._iprot)
3058 
      self._iprot.readMessageEnd()
3059 
      raise x
3060 
    result = getUserEmails_result()
3061 
    result.read(self._iprot)
3062 
    self._iprot.readMessageEnd()
3063 
    if result.success is not None:
3064 
      return result.success
3065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3066 
 
9299 kshitij.so 3067 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3068 
    """
3069 
    Mark a cart lineitem as insured. Returns true/false.
3070 
 
3071 
    Parameters:
3072 
     - itemId
3073 
     - cartId
3074 
     - toInsure
9299 kshitij.so 3075 
     - insurerType
6903 anupam.sin 3076 
    """
9299 kshitij.so 3077 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3078 
    return self.recv_insureItem()
3079 
 
9299 kshitij.so 3080 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3081 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3082 
    args = insureItem_args()
3083 
    args.itemId = itemId
3084 
    args.cartId = cartId
3085 
    args.toInsure = toInsure
9299 kshitij.so 3086 
    args.insurerType = insurerType
6903 anupam.sin 3087 
    args.write(self._oprot)
3088 
    self._oprot.writeMessageEnd()
3089 
    self._oprot.trans.flush()
3090 
 
3091 
  def recv_insureItem(self, ):
3092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3093 
    if mtype == TMessageType.EXCEPTION:
3094 
      x = TApplicationException()
3095 
      x.read(self._iprot)
3096 
      self._iprot.readMessageEnd()
3097 
      raise x
3098 
    result = insureItem_result()
3099 
    result.read(self._iprot)
3100 
    self._iprot.readMessageEnd()
3101 
    if result.success is not None:
3102 
      return result.success
3103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3104 
 
3105 
  def cancelInsurance(self, cartId):
3106 
    """
3107 
    Cancel insurance for all items in the cart
3108 
 
3109 
    Parameters:
3110 
     - cartId
3111 
    """
3112 
    self.send_cancelInsurance(cartId)
3113 
    return self.recv_cancelInsurance()
3114 
 
3115 
  def send_cancelInsurance(self, cartId):
3116 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3117 
    args = cancelInsurance_args()
3118 
    args.cartId = cartId
3119 
    args.write(self._oprot)
3120 
    self._oprot.writeMessageEnd()
3121 
    self._oprot.trans.flush()
3122 
 
3123 
  def recv_cancelInsurance(self, ):
3124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3125 
    if mtype == TMessageType.EXCEPTION:
3126 
      x = TApplicationException()
3127 
      x.read(self._iprot)
3128 
      self._iprot.readMessageEnd()
3129 
      raise x
3130 
    result = cancelInsurance_result()
3131 
    result.read(self._iprot)
3132 
    self._iprot.readMessageEnd()
3133 
    if result.success is not None:
3134 
      return result.success
3135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3136 
 
3137 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3138 
    """
3139 
    Stores insurance specific details like date of birth and guardianName
3140 
 
3141 
    Parameters:
3142 
     - addressId
3143 
     - dob
3144 
     - guardianName
3145 
    """
3146 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3147 
    return self.recv_storeInsuranceSpecificDetails()
3148 
 
3149 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3150 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3151 
    args = storeInsuranceSpecificDetails_args()
3152 
    args.addressId = addressId
3153 
    args.dob = dob
3154 
    args.guardianName = guardianName
3155 
    args.write(self._oprot)
3156 
    self._oprot.writeMessageEnd()
3157 
    self._oprot.trans.flush()
3158 
 
3159 
  def recv_storeInsuranceSpecificDetails(self, ):
3160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3161 
    if mtype == TMessageType.EXCEPTION:
3162 
      x = TApplicationException()
3163 
      x.read(self._iprot)
3164 
      self._iprot.readMessageEnd()
3165 
      raise x
3166 
    result = storeInsuranceSpecificDetails_result()
3167 
    result.read(self._iprot)
3168 
    self._iprot.readMessageEnd()
3169 
    if result.success is not None:
3170 
      return result.success
3171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3172 
 
3173 
  def isInsuranceDetailPresent(self, addressId):
3174 
    """
3175 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3176 
 
3177 
    Parameters:
3178 
     - addressId
3179 
    """
3180 
    self.send_isInsuranceDetailPresent(addressId)
3181 
    return self.recv_isInsuranceDetailPresent()
3182 
 
3183 
  def send_isInsuranceDetailPresent(self, addressId):
3184 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3185 
    args = isInsuranceDetailPresent_args()
3186 
    args.addressId = addressId
3187 
    args.write(self._oprot)
3188 
    self._oprot.writeMessageEnd()
3189 
    self._oprot.trans.flush()
3190 
 
3191 
  def recv_isInsuranceDetailPresent(self, ):
3192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3193 
    if mtype == TMessageType.EXCEPTION:
3194 
      x = TApplicationException()
3195 
      x.read(self._iprot)
3196 
      self._iprot.readMessageEnd()
3197 
      raise x
3198 
    result = isInsuranceDetailPresent_result()
3199 
    result.read(self._iprot)
3200 
    self._iprot.readMessageEnd()
3201 
    if result.success is not None:
3202 
      return result.success
3203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3204 
 
9791 rajveer 3205 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3206 
    """
9791 rajveer 3207 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3208 
 
6821 amar.kumar 3209 
    Parameters:
3210 
     - startDate
3211 
     - endDate
3212 
    """
9791 rajveer 3213 
    self.send_getProductsAddedToCart(startDate, endDate)
3214 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3215 
 
9791 rajveer 3216 
  def send_getProductsAddedToCart(self, startDate, endDate):
3217 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3218 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3219 
    args.startDate = startDate
3220 
    args.endDate = endDate
3221 
    args.write(self._oprot)
3222 
    self._oprot.writeMessageEnd()
3223 
    self._oprot.trans.flush()
3224 
 
9791 rajveer 3225 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3227 
    if mtype == TMessageType.EXCEPTION:
3228 
      x = TApplicationException()
3229 
      x.read(self._iprot)
3230 
      self._iprot.readMessageEnd()
3231 
      raise x
9791 rajveer 3232 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3233 
    result.read(self._iprot)
3234 
    self._iprot.readMessageEnd()
3235 
    if result.success is not None:
3236 
      return result.success
9791 rajveer 3237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3238 
 
11980 amit.gupta 3239 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3240 
    """
3241 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3242 
 
11592 amit.gupta 3243 
    Parameters:
3244 
     - cartId
3245 
     - sourceId
11980 amit.gupta 3246 
     - dealerCoupon
11592 amit.gupta 3247 
    """
11980 amit.gupta 3248 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3249 
    return self.recv_validateCartPlus()
3250 
 
11980 amit.gupta 3251 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3252 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3253 
    args = validateCartPlus_args()
3254 
    args.cartId = cartId
3255 
    args.sourceId = sourceId
11980 amit.gupta 3256 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3257 
    args.write(self._oprot)
3258 
    self._oprot.writeMessageEnd()
3259 
    self._oprot.trans.flush()
3260 
 
3261 
  def recv_validateCartPlus(self, ):
3262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3263 
    if mtype == TMessageType.EXCEPTION:
3264 
      x = TApplicationException()
3265 
      x.read(self._iprot)
3266 
      self._iprot.readMessageEnd()
3267 
      raise x
3268 
    result = validateCartPlus_result()
3269 
    result.read(self._iprot)
3270 
    self._iprot.readMessageEnd()
3271 
    if result.success is not None:
3272 
      return result.success
3273 
    if result.scex is not None:
3274 
      raise result.scex
3275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3276 
 
11679 vikram.rag 3277 
  def isPrivateDealUser(self, userId):
3278 
    """
3279 
    Parameters:
3280 
     - userId
3281 
    """
3282 
    self.send_isPrivateDealUser(userId)
3283 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3284 
 
11679 vikram.rag 3285 
  def send_isPrivateDealUser(self, userId):
3286 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3287 
    args = isPrivateDealUser_args()
3288 
    args.userId = userId
3289 
    args.write(self._oprot)
3290 
    self._oprot.writeMessageEnd()
3291 
    self._oprot.trans.flush()
3292 
 
3293 
  def recv_isPrivateDealUser(self, ):
3294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3295 
    if mtype == TMessageType.EXCEPTION:
3296 
      x = TApplicationException()
3297 
      x.read(self._iprot)
3298 
      self._iprot.readMessageEnd()
3299 
      raise x
3300 
    result = isPrivateDealUser_result()
3301 
    result.read(self._iprot)
3302 
    self._iprot.readMessageEnd()
3303 
    if result.success is not None:
3304 
      return result.success
3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3306 
 
11890 kshitij.so 3307 
  def addPrivateDealUser(self, userId):
3308 
    """
3309 
    Parameters:
3310 
     - userId
3311 
    """
3312 
    self.send_addPrivateDealUser(userId)
3313 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3314 
 
11890 kshitij.so 3315 
  def send_addPrivateDealUser(self, userId):
3316 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3317 
    args = addPrivateDealUser_args()
3318 
    args.userId = userId
3319 
    args.write(self._oprot)
3320 
    self._oprot.writeMessageEnd()
3321 
    self._oprot.trans.flush()
3322 
 
3323 
  def recv_addPrivateDealUser(self, ):
3324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3325 
    if mtype == TMessageType.EXCEPTION:
3326 
      x = TApplicationException()
3327 
      x.read(self._iprot)
3328 
      self._iprot.readMessageEnd()
3329 
      raise x
3330 
    result = addPrivateDealUser_result()
3331 
    result.read(self._iprot)
3332 
    self._iprot.readMessageEnd()
3333 
    if result.success is not None:
3334 
      return result.success
3335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3336 
 
3337 
  def changePrivateDealUserStatus(self, userId, isActive):
3338 
    """
3339 
    Parameters:
3340 
     - userId
3341 
     - isActive
3342 
    """
3343 
    self.send_changePrivateDealUserStatus(userId, isActive)
3344 
    return self.recv_changePrivateDealUserStatus()
3345 
 
3346 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3347 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3348 
    args = changePrivateDealUserStatus_args()
3349 
    args.userId = userId
3350 
    args.isActive = isActive
3351 
    args.write(self._oprot)
3352 
    self._oprot.writeMessageEnd()
3353 
    self._oprot.trans.flush()
3354 
 
3355 
  def recv_changePrivateDealUserStatus(self, ):
3356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3357 
    if mtype == TMessageType.EXCEPTION:
3358 
      x = TApplicationException()
3359 
      x.read(self._iprot)
3360 
      self._iprot.readMessageEnd()
3361 
      raise x
3362 
    result = changePrivateDealUserStatus_result()
3363 
    result.read(self._iprot)
3364 
    self._iprot.readMessageEnd()
3365 
    if result.success is not None:
3366 
      return result.success
3367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3368 
 
3369 
  def getPrivateDealUser(self, userId):
3370 
    """
3371 
    Parameters:
3372 
     - userId
3373 
    """
3374 
    self.send_getPrivateDealUser(userId)
3375 
    return self.recv_getPrivateDealUser()
3376 
 
3377 
  def send_getPrivateDealUser(self, userId):
3378 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3379 
    args = getPrivateDealUser_args()
3380 
    args.userId = userId
3381 
    args.write(self._oprot)
3382 
    self._oprot.writeMessageEnd()
3383 
    self._oprot.trans.flush()
3384 
 
3385 
  def recv_getPrivateDealUser(self, ):
3386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3387 
    if mtype == TMessageType.EXCEPTION:
3388 
      x = TApplicationException()
3389 
      x.read(self._iprot)
3390 
      self._iprot.readMessageEnd()
3391 
      raise x
3392 
    result = getPrivateDealUser_result()
3393 
    result.read(self._iprot)
3394 
    self._iprot.readMessageEnd()
3395 
    if result.success is not None:
3396 
      return result.success
3397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3398 
 
12696 amit.gupta 3399 
  def registerCounter(self, counter, userId):
3400 
    """
3401 
    Parameters:
3402 
     - counter
3403 
     - userId
3404 
    """
3405 
    self.send_registerCounter(counter, userId)
3406 
    return self.recv_registerCounter()
11890 kshitij.so 3407 
 
12696 amit.gupta 3408 
  def send_registerCounter(self, counter, userId):
3409 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3410 
    args = registerCounter_args()
3411 
    args.counter = counter
3412 
    args.userId = userId
3413 
    args.write(self._oprot)
3414 
    self._oprot.writeMessageEnd()
3415 
    self._oprot.trans.flush()
3416 
 
3417 
  def recv_registerCounter(self, ):
3418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3419 
    if mtype == TMessageType.EXCEPTION:
3420 
      x = TApplicationException()
3421 
      x.read(self._iprot)
3422 
      self._iprot.readMessageEnd()
3423 
      raise x
3424 
    result = registerCounter_result()
3425 
    result.read(self._iprot)
3426 
    self._iprot.readMessageEnd()
3427 
    if result.success is not None:
3428 
      return result.success
3429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3430 
 
12722 amit.gupta 3431 
  def searchCounter(self, type1, searchString):
3432 
    """
3433 
    Parameters:
3434 
     - type1
3435 
     - searchString
3436 
    """
3437 
    self.send_searchCounter(type1, searchString)
3438 
    return self.recv_searchCounter()
12696 amit.gupta 3439 
 
12722 amit.gupta 3440 
  def send_searchCounter(self, type1, searchString):
3441 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3442 
    args = searchCounter_args()
3443 
    args.type1 = type1
3444 
    args.searchString = searchString
3445 
    args.write(self._oprot)
3446 
    self._oprot.writeMessageEnd()
3447 
    self._oprot.trans.flush()
3448 
 
3449 
  def recv_searchCounter(self, ):
3450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3451 
    if mtype == TMessageType.EXCEPTION:
3452 
      x = TApplicationException()
3453 
      x.read(self._iprot)
3454 
      self._iprot.readMessageEnd()
3455 
      raise x
3456 
    result = searchCounter_result()
3457 
    result.read(self._iprot)
3458 
    self._iprot.readMessageEnd()
3459 
    if result.success is not None:
3460 
      return result.success
3461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3462 
 
3463 
  def getAllUsersByCounter(self, counterId):
3464 
    """
3465 
    Parameters:
3466 
     - counterId
3467 
    """
3468 
    self.send_getAllUsersByCounter(counterId)
3469 
    return self.recv_getAllUsersByCounter()
3470 
 
3471 
  def send_getAllUsersByCounter(self, counterId):
3472 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3473 
    args = getAllUsersByCounter_args()
3474 
    args.counterId = counterId
3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_getAllUsersByCounter(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = getAllUsersByCounter_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3489 
    if result.success is not None:
3490 
      return result.success
3491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3492 
 
15251 manish.sha 3493 
  def getActiveAccessTokenForUser(self, userId, source):
3494 
    """
3495 
    Parameters:
3496 
     - userId
3497 
     - source
3498 
    """
3499 
    self.send_getActiveAccessTokenForUser(userId, source)
3500 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3501 
 
15251 manish.sha 3502 
  def send_getActiveAccessTokenForUser(self, userId, source):
3503 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3504 
    args = getActiveAccessTokenForUser_args()
3505 
    args.userId = userId
3506 
    args.source = source
3507 
    args.write(self._oprot)
3508 
    self._oprot.writeMessageEnd()
3509 
    self._oprot.trans.flush()
3510 
 
3511 
  def recv_getActiveAccessTokenForUser(self, ):
3512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3513 
    if mtype == TMessageType.EXCEPTION:
3514 
      x = TApplicationException()
3515 
      x.read(self._iprot)
3516 
      self._iprot.readMessageEnd()
3517 
      raise x
3518 
    result = getActiveAccessTokenForUser_result()
3519 
    result.read(self._iprot)
3520 
    self._iprot.readMessageEnd()
3521 
    if result.success is not None:
3522 
      return result.success
3523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3524 
 
3525 
  def validateAccessToken(self, accessToken):
3526 
    """
3527 
    Parameters:
3528 
     - accessToken
3529 
    """
3530 
    self.send_validateAccessToken(accessToken)
3531 
    return self.recv_validateAccessToken()
3532 
 
3533 
  def send_validateAccessToken(self, accessToken):
3534 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3535 
    args = validateAccessToken_args()
3536 
    args.accessToken = accessToken
3537 
    args.write(self._oprot)
3538 
    self._oprot.writeMessageEnd()
3539 
    self._oprot.trans.flush()
3540 
 
3541 
  def recv_validateAccessToken(self, ):
3542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3543 
    if mtype == TMessageType.EXCEPTION:
3544 
      x = TApplicationException()
3545 
      x.read(self._iprot)
3546 
      self._iprot.readMessageEnd()
3547 
      raise x
3548 
    result = validateAccessToken_result()
3549 
    result.read(self._iprot)
3550 
    self._iprot.readMessageEnd()
3551 
    if result.success is not None:
3552 
      return result.success
3553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3554 
 
17782 amit.gupta 3555 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3556 
    """
3557 
    Parameters:
3558 
     - cartId
3559 
     - itemQty
3560 
     - couponCode
3561 
    """
3562 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3563 
    return self.recv_addItemsToCart()
15251 manish.sha 3564 
 
17782 amit.gupta 3565 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3566 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3567 
    args = addItemsToCart_args()
3568 
    args.cartId = cartId
3569 
    args.itemQty = itemQty
3570 
    args.couponCode = couponCode
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_addItemsToCart(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = addItemsToCart_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3585 
    if result.success is not None:
3586 
      return result.success
3587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3588 
 
3589 
  def validateCartNew(self, cartId, pinCode, sourceId):
3590 
    """
3591 
    Parameters:
3592 
     - cartId
3593 
     - pinCode
3594 
     - sourceId
3595 
    """
3596 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3597 
    return self.recv_validateCartNew()
3598 
 
3599 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3600 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3601 
    args = validateCartNew_args()
3602 
    args.cartId = cartId
3603 
    args.pinCode = pinCode
3604 
    args.sourceId = sourceId
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_validateCartNew(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = validateCartNew_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.success is not None:
3620 
      return result.success
3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3622 
 
18644 manish.sha 3623 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3624 
    """
3625 
    Parameters:
3626 
     - userId
3627 
    """
18644 manish.sha 3628 
    self.send_isAddressEditableForCounter(userId)
3629 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3630 
 
18644 manish.sha 3631 
  def send_isAddressEditableForCounter(self, userId):
3632 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3633 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3634 
    args.userId = userId
3635 
    args.write(self._oprot)
3636 
    self._oprot.writeMessageEnd()
3637 
    self._oprot.trans.flush()
3638 
 
18644 manish.sha 3639 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3641 
    if mtype == TMessageType.EXCEPTION:
3642 
      x = TApplicationException()
3643 
      x.read(self._iprot)
3644 
      self._iprot.readMessageEnd()
3645 
      raise x
18644 manish.sha 3646 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3647 
    result.read(self._iprot)
3648 
    self._iprot.readMessageEnd()
3649 
    if result.success is not None:
3650 
      return result.success
18644 manish.sha 3651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3652 
 
3653 
  def getBillingAddressForUser(self, userId):
3654 
    """
3655 
    Parameters:
3656 
     - userId
3657 
    """
3658 
    self.send_getBillingAddressForUser(userId)
3659 
    return self.recv_getBillingAddressForUser()
3660 
 
3661 
  def send_getBillingAddressForUser(self, userId):
3662 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3663 
    args = getBillingAddressForUser_args()
3664 
    args.userId = userId
3665 
    args.write(self._oprot)
3666 
    self._oprot.writeMessageEnd()
3667 
    self._oprot.trans.flush()
3668 
 
3669 
  def recv_getBillingAddressForUser(self, ):
3670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3671 
    if mtype == TMessageType.EXCEPTION:
3672 
      x = TApplicationException()
3673 
      x.read(self._iprot)
3674 
      self._iprot.readMessageEnd()
3675 
      raise x
3676 
    result = getBillingAddressForUser_result()
3677 
    result.read(self._iprot)
3678 
    self._iprot.readMessageEnd()
3679 
    if result.success is not None:
3680 
      return result.success
3681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3682 
 
18590 manish.sha 3683 
  def isCreditorAssigned(self, userId):
3684 
    """
3685 
    Parameters:
3686 
     - userId
3687 
    """
3688 
    self.send_isCreditorAssigned(userId)
3689 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3690 
 
18590 manish.sha 3691 
  def send_isCreditorAssigned(self, userId):
3692 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3693 
    args = isCreditorAssigned_args()
3694 
    args.userId = userId
3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_isCreditorAssigned(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = isCreditorAssigned_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
3709 
    if result.success is not None:
3710 
      return result.success
3711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3712 
 
3713 
 
3376 rajveer 3714 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3715 
  def __init__(self, handler):
3376 rajveer 3716 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3717 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3718 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3719 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3720 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3721 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3722 
    self._processMap["createUser"] = Processor.process_createUser
3723 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3724 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3725 
    self._processMap["userExists"] = Processor.process_userExists
3726 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3727 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3728 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3729 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3730 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3731 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3732 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3733 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3734 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3735 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3736 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3737 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3738 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3739 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3740 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3741 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3742 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3743 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3744 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3745 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3746 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3747 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3748 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3749 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3750 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3751 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3752 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3753 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3754 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3755 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3756 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3757 
    self._processMap["getCart"] = Processor.process_getCart
3758 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3759 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3760 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3761 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3762 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3763 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3764 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3765 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3766 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3767 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3768 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3769 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3770 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3771 
    self._processMap["checkOut"] = Processor.process_checkOut
3772 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3773 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3774 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3775 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3776 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3777 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3778 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3779 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3780 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3781 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3782 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3783 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3784 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3785 
    self._processMap["insureItem"] = Processor.process_insureItem
3786 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3787 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3788 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3789 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3790 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3791 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3792 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3793 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3794 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3795 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3796 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3797 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3798 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3799 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3800 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3801 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 3802 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 3803 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 3804 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
94 ashish 3805 
 
3806 
  def process(self, iprot, oprot):
3807 
    (name, type, seqid) = iprot.readMessageBegin()
3808 
    if name not in self._processMap:
3809 
      iprot.skip(TType.STRUCT)
3810 
      iprot.readMessageEnd()
3811 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3812 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3813 
      x.write(oprot)
3814 
      oprot.writeMessageEnd()
3815 
      oprot.trans.flush()
3816 
      return
3817 
    else:
3818 
      self._processMap[name](self, seqid, iprot, oprot)
3819 
    return True
3820 
 
559 chandransh 3821 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3822 
    args = createAnonymousUser_args()
94 ashish 3823 
    args.read(iprot)
3824 
    iprot.readMessageEnd()
559 chandransh 3825 
    result = createAnonymousUser_result()
94 ashish 3826 
    try:
559 chandransh 3827 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3828 
    except UserContextException, ucex:
3829 
      result.ucex = ucex
3830 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3831 
    result.write(oprot)
3832 
    oprot.writeMessageEnd()
3833 
    oprot.trans.flush()
3834 
 
559 chandransh 3835 
  def process_getUserById(self, seqid, iprot, oprot):
3836 
    args = getUserById_args()
94 ashish 3837 
    args.read(iprot)
3838 
    iprot.readMessageEnd()
559 chandransh 3839 
    result = getUserById_result()
94 ashish 3840 
    try:
559 chandransh 3841 
      result.success = self._handler.getUserById(args.userId)
3842 
    except UserContextException, ucex:
3843 
      result.ucex = ucex
3844 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3845 
    result.write(oprot)
3846 
    oprot.writeMessageEnd()
3847 
    oprot.trans.flush()
3848 
 
5326 rajveer 3849 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3850 
    args = getUserByCartId_args()
3851 
    args.read(iprot)
3852 
    iprot.readMessageEnd()
3853 
    result = getUserByCartId_result()
3854 
    try:
3855 
      result.success = self._handler.getUserByCartId(args.cartId)
3856 
    except UserContextException, ucex:
3857 
      result.ucex = ucex
3858 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3859 
    result.write(oprot)
3860 
    oprot.writeMessageEnd()
3861 
    oprot.trans.flush()
3862 
 
1491 vikas 3863 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3864 
    args = getUserByEmail_args()
3865 
    args.read(iprot)
3866 
    iprot.readMessageEnd()
3867 
    result = getUserByEmail_result()
3868 
    try:
3869 
      result.success = self._handler.getUserByEmail(args.email)
3870 
    except UserContextException, ucex:
3871 
      result.ucex = ucex
3872 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3873 
    result.write(oprot)
3874 
    oprot.writeMessageEnd()
3875 
    oprot.trans.flush()
3876 
 
3032 mandeep.dh 3877 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3878 
    args = getUserByMobileNumber_args()
3879 
    args.read(iprot)
3880 
    iprot.readMessageEnd()
3881 
    result = getUserByMobileNumber_result()
3882 
    try:
3883 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3884 
    except UserContextException, ucex:
3885 
      result.ucex = ucex
3886 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3887 
    result.write(oprot)
3888 
    oprot.writeMessageEnd()
3889 
    oprot.trans.flush()
3890 
 
559 chandransh 3891 
  def process_createUser(self, seqid, iprot, oprot):
3892 
    args = createUser_args()
94 ashish 3893 
    args.read(iprot)
3894 
    iprot.readMessageEnd()
559 chandransh 3895 
    result = createUser_result()
94 ashish 3896 
    try:
559 chandransh 3897 
      result.success = self._handler.createUser(args.user)
3898 
    except UserContextException, ucex:
3899 
      result.ucex = ucex
3900 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3901 
    result.write(oprot)
3902 
    oprot.writeMessageEnd()
3903 
    oprot.trans.flush()
3904 
 
559 chandransh 3905 
  def process_updateUser(self, seqid, iprot, oprot):
3906 
    args = updateUser_args()
94 ashish 3907 
    args.read(iprot)
3908 
    iprot.readMessageEnd()
559 chandransh 3909 
    result = updateUser_result()
94 ashish 3910 
    try:
559 chandransh 3911 
      result.success = self._handler.updateUser(args.user)
3912 
    except UserContextException, ucex:
3913 
      result.ucex = ucex
3914 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3915 
    result.write(oprot)
3916 
    oprot.writeMessageEnd()
3917 
    oprot.trans.flush()
3918 
 
122 ashish 3919 
  def process_authenticateUser(self, seqid, iprot, oprot):
3920 
    args = authenticateUser_args()
3921 
    args.read(iprot)
3922 
    iprot.readMessageEnd()
3923 
    result = authenticateUser_result()
3924 
    try:
559 chandransh 3925 
      result.success = self._handler.authenticateUser(args.email, args.password)
3926 
    except AuthenticationException, auex:
3927 
      result.auex = auex
122 ashish 3928 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3929 
    result.write(oprot)
3930 
    oprot.writeMessageEnd()
3931 
    oprot.trans.flush()
3932 
 
94 ashish 3933 
  def process_userExists(self, seqid, iprot, oprot):
3934 
    args = userExists_args()
3935 
    args.read(iprot)
3936 
    iprot.readMessageEnd()
3937 
    result = userExists_result()
3938 
    try:
3939 
      result.success = self._handler.userExists(args.email)
3940 
    except UserContextException, ucx:
3941 
      result.ucx = ucx
3942 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3943 
    result.write(oprot)
3944 
    oprot.writeMessageEnd()
3945 
    oprot.trans.flush()
3946 
 
3947 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3948 
    args = addAddressForUser_args()
3949 
    args.read(iprot)
3950 
    iprot.readMessageEnd()
3951 
    result = addAddressForUser_result()
3952 
    try:
567 rajveer 3953 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3954 
    except UserContextException, ucx:
3955 
      result.ucx = ucx
3956 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3957 
    result.write(oprot)
3958 
    oprot.writeMessageEnd()
3959 
    oprot.trans.flush()
3960 
 
3961 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3962 
    args = removeAddressForUser_args()
3963 
    args.read(iprot)
3964 
    iprot.readMessageEnd()
3965 
    result = removeAddressForUser_result()
3966 
    try:
3967 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3968 
    except UserContextException, ucx:
3969 
      result.ucx = ucx
3970 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3971 
    result.write(oprot)
3972 
    oprot.writeMessageEnd()
3973 
    oprot.trans.flush()
3974 
 
3975 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3976 
    args = setUserAsLoggedIn_args()
3977 
    args.read(iprot)
3978 
    iprot.readMessageEnd()
3979 
    result = setUserAsLoggedIn_result()
3980 
    try:
3981 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3982 
    except UserContextException, ucx:
3983 
      result.ucx = ucx
3984 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3985 
    result.write(oprot)
3986 
    oprot.writeMessageEnd()
3987 
    oprot.trans.flush()
3988 
 
3989 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3990 
    args = setUserAsLoggedOut_args()
3991 
    args.read(iprot)
3992 
    iprot.readMessageEnd()
3993 
    result = setUserAsLoggedOut_result()
3994 
    try:
3995 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3996 
    except UserContextException, ucx:
3997 
      result.ucx = ucx
3998 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3999 
    result.write(oprot)
4000 
    oprot.writeMessageEnd()
4001 
    oprot.trans.flush()
4002 
 
504 rajveer 4003 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4004 
    args = setDefaultAddress_args()
4005 
    args.read(iprot)
4006 
    iprot.readMessageEnd()
4007 
    result = setDefaultAddress_result()
4008 
    try:
4009 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4010 
    except UserContextException, ucx:
4011 
      result.ucx = ucx
4012 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4013 
    result.write(oprot)
4014 
    oprot.writeMessageEnd()
4015 
    oprot.trans.flush()
4016 
 
94 ashish 4017 
  def process_updatePassword(self, seqid, iprot, oprot):
4018 
    args = updatePassword_args()
4019 
    args.read(iprot)
4020 
    iprot.readMessageEnd()
4021 
    result = updatePassword_result()
4022 
    try:
594 rajveer 4023 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4024 
    except UserContextException, ucx:
4025 
      result.ucx = ucx
4026 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4027 
    result.write(oprot)
4028 
    oprot.writeMessageEnd()
4029 
    oprot.trans.flush()
4030 
 
581 rajveer 4031 
  def process_forgotPassword(self, seqid, iprot, oprot):
4032 
    args = forgotPassword_args()
4033 
    args.read(iprot)
4034 
    iprot.readMessageEnd()
4035 
    result = forgotPassword_result()
4036 
    try:
884 rajveer 4037 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4038 
    except UserContextException, ucx:
4039 
      result.ucx = ucx
4040 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4041 
    result.write(oprot)
4042 
    oprot.writeMessageEnd()
4043 
    oprot.trans.flush()
4044 
 
594 rajveer 4045 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4046 
    args = getAllAddressesForUser_args()
4047 
    args.read(iprot)
4048 
    iprot.readMessageEnd()
4049 
    result = getAllAddressesForUser_result()
4050 
    try:
4051 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4052 
    except UserContextException, ucx:
4053 
      result.ucx = ucx
4054 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4055 
    result.write(oprot)
4056 
    oprot.writeMessageEnd()
4057 
    oprot.trans.flush()
4058 
 
1894 vikas 4059 
  def process_getAddressById(self, seqid, iprot, oprot):
4060 
    args = getAddressById_args()
4061 
    args.read(iprot)
4062 
    iprot.readMessageEnd()
4063 
    result = getAddressById_result()
4064 
    try:
4065 
      result.success = self._handler.getAddressById(args.addressId)
4066 
    except UserContextException, ucx:
4067 
      result.ucx = ucx
4068 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4069 
    result.write(oprot)
4070 
    oprot.writeMessageEnd()
4071 
    oprot.trans.flush()
4072 
 
594 rajveer 4073 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4074 
    args = getDefaultAddressId_args()
4075 
    args.read(iprot)
4076 
    iprot.readMessageEnd()
4077 
    result = getDefaultAddressId_result()
4078 
    try:
4079 
      result.success = self._handler.getDefaultAddressId(args.userId)
4080 
    except UserContextException, ucx:
4081 
      result.ucx = ucx
4082 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4083 
    result.write(oprot)
4084 
    oprot.writeMessageEnd()
4085 
    oprot.trans.flush()
4086 
 
785 rajveer 4087 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4088 
    args = getDefaultPincode_args()
4089 
    args.read(iprot)
4090 
    iprot.readMessageEnd()
4091 
    result = getDefaultPincode_result()
4092 
    try:
4093 
      result.success = self._handler.getDefaultPincode(args.userId)
4094 
    except UserContextException, ucx:
4095 
      result.ucx = ucx
4096 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4097 
    result.write(oprot)
4098 
    oprot.writeMessageEnd()
4099 
    oprot.trans.flush()
4100 
 
1274 varun.gupt 4101 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4102 
    args = saveUserCommunication_args()
4103 
    args.read(iprot)
4104 
    iprot.readMessageEnd()
4105 
    result = saveUserCommunication_result()
4106 
    try:
4107 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4108 
    except UserCommunicationException, ucx:
4109 
      result.ucx = ucx
4110 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4111 
    result.write(oprot)
4112 
    oprot.writeMessageEnd()
4113 
    oprot.trans.flush()
4114 
 
1590 varun.gupt 4115 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4116 
    args = getUserCommunicationById_args()
4117 
    args.read(iprot)
4118 
    iprot.readMessageEnd()
4119 
    result = getUserCommunicationById_result()
4120 
    try:
4121 
      result.success = self._handler.getUserCommunicationById(args.id)
4122 
    except UserCommunicationException, ucx:
4123 
      result.ucx = ucx
4124 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4125 
    result.write(oprot)
4126 
    oprot.writeMessageEnd()
4127 
    oprot.trans.flush()
4128 
 
4129 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4130 
    args = getUserCommunicationByUser_args()
4131 
    args.read(iprot)
4132 
    iprot.readMessageEnd()
4133 
    result = getUserCommunicationByUser_result()
4134 
    try:
4135 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4136 
    except UserCommunicationException, ucx:
4137 
      result.ucx = ucx
4138 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4139 
    result.write(oprot)
4140 
    oprot.writeMessageEnd()
4141 
    oprot.trans.flush()
4142 
 
4143 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4144 
    args = getAllUserCommunications_args()
4145 
    args.read(iprot)
4146 
    iprot.readMessageEnd()
4147 
    result = getAllUserCommunications_result()
4148 
    try:
4149 
      result.success = self._handler.getAllUserCommunications()
4150 
    except UserCommunicationException, ucx:
4151 
      result.ucx = ucx
4152 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4153 
    result.write(oprot)
4154 
    oprot.writeMessageEnd()
4155 
    oprot.trans.flush()
4156 
 
5407 amar.kumar 4157 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4158 
    args = removeUserCommunication_args()
4159 
    args.read(iprot)
4160 
    iprot.readMessageEnd()
4161 
    result = removeUserCommunication_result()
4162 
    try:
4163 
      self._handler.removeUserCommunication(args.id)
4164 
    except UserCommunicationException, ucx:
4165 
      result.ucx = ucx
4166 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4167 
    result.write(oprot)
4168 
    oprot.writeMessageEnd()
4169 
    oprot.trans.flush()
4170 
 
1845 vikas 4171 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4172 
    args = createMasterAffiliate_args()
4173 
    args.read(iprot)
4174 
    iprot.readMessageEnd()
4175 
    result = createMasterAffiliate_result()
4176 
    try:
1859 vikas 4177 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4178 
    except UserAffiliateException, utx:
1845 vikas 4179 
      result.utx = utx
4180 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4181 
    result.write(oprot)
4182 
    oprot.writeMessageEnd()
4183 
    oprot.trans.flush()
4184 
 
1899 vikas 4185 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4186 
    args = getAllMasterAffiliates_args()
4187 
    args.read(iprot)
4188 
    iprot.readMessageEnd()
4189 
    result = getAllMasterAffiliates_result()
4190 
    try:
4191 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4192 
    except UserAffiliateException, utx:
1899 vikas 4193 
      result.utx = utx
4194 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4195 
    result.write(oprot)
4196 
    oprot.writeMessageEnd()
4197 
    oprot.trans.flush()
4198 
 
1845 vikas 4199 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4200 
    args = getMasterAffiliateById_args()
4201 
    args.read(iprot)
4202 
    iprot.readMessageEnd()
4203 
    result = getMasterAffiliateById_result()
4204 
    try:
4205 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4206 
    except UserAffiliateException, utx:
1845 vikas 4207 
      result.utx = utx
4208 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4209 
    result.write(oprot)
4210 
    oprot.writeMessageEnd()
4211 
    oprot.trans.flush()
4212 
 
4213 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4214 
    args = getMasterAffiliateByName_args()
4215 
    args.read(iprot)
4216 
    iprot.readMessageEnd()
4217 
    result = getMasterAffiliateByName_result()
4218 
    try:
4219 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4220 
    except UserAffiliateException, utx:
1845 vikas 4221 
      result.utx = utx
4222 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4223 
    result.write(oprot)
4224 
    oprot.writeMessageEnd()
4225 
    oprot.trans.flush()
4226 
 
4227 
  def process_createAffiliate(self, seqid, iprot, oprot):
4228 
    args = createAffiliate_args()
4229 
    args.read(iprot)
4230 
    iprot.readMessageEnd()
4231 
    result = createAffiliate_result()
4232 
    try:
1859 vikas 4233 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4234 
    except UserAffiliateException, utx:
1845 vikas 4235 
      result.utx = utx
4236 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4237 
    result.write(oprot)
4238 
    oprot.writeMessageEnd()
4239 
    oprot.trans.flush()
4240 
 
4241 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4242 
    args = getAffiliateById_args()
4243 
    args.read(iprot)
4244 
    iprot.readMessageEnd()
4245 
    result = getAffiliateById_result()
4246 
    try:
4247 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4248 
    except UserAffiliateException, utx:
1845 vikas 4249 
      result.utx = utx
4250 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4251 
    result.write(oprot)
4252 
    oprot.writeMessageEnd()
4253 
    oprot.trans.flush()
4254 
 
4255 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4256 
    args = getAffiliateByName_args()
4257 
    args.read(iprot)
4258 
    iprot.readMessageEnd()
4259 
    result = getAffiliateByName_result()
4260 
    try:
4261 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4262 
    except UserAffiliateException, utx:
1845 vikas 4263 
      result.utx = utx
4264 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4265 
    result.write(oprot)
4266 
    oprot.writeMessageEnd()
4267 
    oprot.trans.flush()
4268 
 
4269 
  def process_getTrackerById(self, seqid, iprot, oprot):
4270 
    args = getTrackerById_args()
4271 
    args.read(iprot)
4272 
    iprot.readMessageEnd()
4273 
    result = getTrackerById_result()
4274 
    try:
1996 vikas 4275 
      result.success = self._handler.getTrackerById(args.id)
4276 
    except UserAffiliateException, utx:
1845 vikas 4277 
      result.utx = utx
4278 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4279 
    result.write(oprot)
4280 
    oprot.writeMessageEnd()
4281 
    oprot.trans.flush()
4282 
 
1996 vikas 4283 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4284 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4285 
    args.read(iprot)
4286 
    iprot.readMessageEnd()
1996 vikas 4287 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4288 
    try:
1996 vikas 4289 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4290 
    except UserAffiliateException, utx:
1845 vikas 4291 
      result.utx = utx
1996 vikas 4292 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4293 
    result.write(oprot)
4294 
    oprot.writeMessageEnd()
4295 
    oprot.trans.flush()
4296 
 
4297 
  def process_addTrackLog(self, seqid, iprot, oprot):
4298 
    args = addTrackLog_args()
4299 
    args.read(iprot)
4300 
    iprot.readMessageEnd()
4301 
    result = addTrackLog_result()
4302 
    try:
1996 vikas 4303 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4304 
    except UserAffiliateException, utx:
1845 vikas 4305 
      result.utx = utx
4306 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4307 
    result.write(oprot)
4308 
    oprot.writeMessageEnd()
4309 
    oprot.trans.flush()
4310 
 
4311 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4312 
    args = getTrackLogById_args()
4313 
    args.read(iprot)
4314 
    iprot.readMessageEnd()
4315 
    result = getTrackLogById_result()
4316 
    try:
4317 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4318 
    except UserAffiliateException, utx:
1845 vikas 4319 
      result.utx = utx
4320 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4321 
    result.write(oprot)
4322 
    oprot.writeMessageEnd()
4323 
    oprot.trans.flush()
4324 
 
1996 vikas 4325 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4326 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4327 
    args.read(iprot)
4328 
    iprot.readMessageEnd()
1996 vikas 4329 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4330 
    try:
3293 vikas 4331 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4332 
    except UserAffiliateException, utx:
1845 vikas 4333 
      result.utx = utx
1996 vikas 4334 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4335 
    result.write(oprot)
4336 
    oprot.writeMessageEnd()
4337 
    oprot.trans.flush()
4338 
 
4339 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4340 
    args = getTrackLogsByUser_args()
4341 
    args.read(iprot)
4342 
    iprot.readMessageEnd()
4343 
    result = getTrackLogsByUser_result()
4344 
    try:
4345 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4346 
    except UserAffiliateException, utx:
1845 vikas 4347 
      result.utx = utx
4348 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4349 
    result.write(oprot)
4350 
    oprot.writeMessageEnd()
4351 
    oprot.trans.flush()
4352 
 
4353 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4354 
    args = getTrackLogs_args()
4355 
    args.read(iprot)
4356 
    iprot.readMessageEnd()
4357 
    result = getTrackLogs_result()
4358 
    try:
1996 vikas 4359 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4360 
    except UserAffiliateException, utx:
1845 vikas 4361 
      result.utx = utx
4362 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4363 
    result.write(oprot)
4364 
    oprot.writeMessageEnd()
4365 
    oprot.trans.flush()
4366 
 
559 chandransh 4367 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4368 
    args = getCurrentCart_args()
94 ashish 4369 
    args.read(iprot)
4370 
    iprot.readMessageEnd()
559 chandransh 4371 
    result = getCurrentCart_result()
94 ashish 4372 
    try:
559 chandransh 4373 
      result.success = self._handler.getCurrentCart(args.userId)
4374 
    except ShoppingCartException, scx:
4375 
      result.scx = scx
4376 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4377 
    result.write(oprot)
4378 
    oprot.writeMessageEnd()
4379 
    oprot.trans.flush()
4380 
 
559 chandransh 4381 
  def process_getCart(self, seqid, iprot, oprot):
4382 
    args = getCart_args()
94 ashish 4383 
    args.read(iprot)
4384 
    iprot.readMessageEnd()
559 chandransh 4385 
    result = getCart_result()
94 ashish 4386 
    try:
559 chandransh 4387 
      result.success = self._handler.getCart(args.cartId)
4388 
    except ShoppingCartException, scx:
4389 
      result.scx = scx
4390 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4391 
    result.write(oprot)
4392 
    oprot.writeMessageEnd()
4393 
    oprot.trans.flush()
4394 
 
559 chandransh 4395 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4396 
    args = getCartsByTime_args()
94 ashish 4397 
    args.read(iprot)
4398 
    iprot.readMessageEnd()
559 chandransh 4399 
    result = getCartsByTime_result()
94 ashish 4400 
    try:
559 chandransh 4401 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4402 
    except ShoppingCartException, scx:
4403 
      result.scx = scx
4404 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4405 
    result.write(oprot)
4406 
    oprot.writeMessageEnd()
4407 
    oprot.trans.flush()
4408 
 
559 chandransh 4409 
  def process_addItemToCart(self, seqid, iprot, oprot):
4410 
    args = addItemToCart_args()
130 ashish 4411 
    args.read(iprot)
4412 
    iprot.readMessageEnd()
559 chandransh 4413 
    result = addItemToCart_result()
130 ashish 4414 
    try:
3557 rajveer 4415 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4416 
    except ShoppingCartException, scx:
4417 
      result.scx = scx
4418 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4419 
    result.write(oprot)
4420 
    oprot.writeMessageEnd()
4421 
    oprot.trans.flush()
4422 
 
559 chandransh 4423 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4424 
    args = deleteItemFromCart_args()
4425 
    args.read(iprot)
4426 
    iprot.readMessageEnd()
4427 
    result = deleteItemFromCart_result()
4428 
    try:
4429 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4430 
    except ShoppingCartException, scx:
4431 
      result.scx = scx
4432 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4433 
    result.write(oprot)
4434 
    oprot.writeMessageEnd()
4435 
    oprot.trans.flush()
130 ashish 4436 
 
559 chandransh 4437 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4438 
    args = addAddressToCart_args()
4439 
    args.read(iprot)
4440 
    iprot.readMessageEnd()
4441 
    result = addAddressToCart_result()
575 chandransh 4442 
    try:
4443 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4444 
    except ShoppingCartException, scx:
4445 
      result.scx = scx
559 chandransh 4446 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
4450 
 
5553 rajveer 4451 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4452 
    args = addStoreToCart_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = addStoreToCart_result()
4456 
    try:
4457 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4458 
    except ShoppingCartException, scx:
4459 
      result.scx = scx
4460 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4461 
    result.write(oprot)
4462 
    oprot.writeMessageEnd()
4463 
    oprot.trans.flush()
4464 
 
1976 varun.gupt 4465 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4466 
    args = applyCouponToCart_args()
4467 
    args.read(iprot)
4468 
    iprot.readMessageEnd()
4469 
    result = applyCouponToCart_result()
4470 
    try:
6922 anupam.sin 4471 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4472 
    except ShoppingCartException, scx:
4473 
      result.scx = scx
4474 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4475 
    result.write(oprot)
4476 
    oprot.writeMessageEnd()
4477 
    oprot.trans.flush()
4478 
 
4479 
  def process_removeCoupon(self, seqid, iprot, oprot):
4480 
    args = removeCoupon_args()
4481 
    args.read(iprot)
4482 
    iprot.readMessageEnd()
4483 
    result = removeCoupon_result()
4484 
    try:
4485 
      self._handler.removeCoupon(args.cartId)
4486 
    except ShoppingCartException, scx:
4487 
      result.scx = scx
4488 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4489 
    result.write(oprot)
4490 
    oprot.writeMessageEnd()
4491 
    oprot.trans.flush()
4492 
 
3554 varun.gupt 4493 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4494 
    args = deleteDiscountsFromCart_args()
4495 
    args.read(iprot)
4496 
    iprot.readMessageEnd()
4497 
    result = deleteDiscountsFromCart_result()
4498 
    try:
4499 
      self._handler.deleteDiscountsFromCart(args.cartId)
4500 
    except ShoppingCartException, scx:
4501 
      result.scx = scx
4502 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4503 
    result.write(oprot)
4504 
    oprot.writeMessageEnd()
4505 
    oprot.trans.flush()
4506 
 
4507 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4508 
    args = saveDiscounts_args()
4509 
    args.read(iprot)
4510 
    iprot.readMessageEnd()
4511 
    result = saveDiscounts_result()
4512 
    try:
4513 
      self._handler.saveDiscounts(args.discounts)
4514 
    except ShoppingCartException, scx:
4515 
      result.scx = scx
4516 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4517 
    result.write(oprot)
4518 
    oprot.writeMessageEnd()
4519 
    oprot.trans.flush()
4520 
 
690 chandransh 4521 
  def process_createOrders(self, seqid, iprot, oprot):
4522 
    args = createOrders_args()
559 chandransh 4523 
    args.read(iprot)
4524 
    iprot.readMessageEnd()
690 chandransh 4525 
    result = createOrders_result()
559 chandransh 4526 
    try:
11526 amit.gupta 4527 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4528 
    except ShoppingCartException, scx:
4529 
      result.scx = scx
690 chandransh 4530 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4531 
    result.write(oprot)
4532 
    oprot.writeMessageEnd()
4533 
    oprot.trans.flush()
4534 
 
4535 
  def process_validateCart(self, seqid, iprot, oprot):
4536 
    args = validateCart_args()
4537 
    args.read(iprot)
4538 
    iprot.readMessageEnd()
4539 
    result = validateCart_result()
575 chandransh 4540 
    try:
3557 rajveer 4541 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4542 
    except ShoppingCartException, scex:
4543 
      result.scex = scex
559 chandransh 4544 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4545 
    result.write(oprot)
4546 
    oprot.writeMessageEnd()
4547 
    oprot.trans.flush()
4548 
 
11980 amit.gupta 4549 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4550 
    args = validateCartWithDealerCoupon_args()
4551 
    args.read(iprot)
4552 
    iprot.readMessageEnd()
4553 
    result = validateCartWithDealerCoupon_result()
4554 
    try:
4555 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4556 
    except ShoppingCartException, scex:
4557 
      result.scex = scex
4558 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4559 
    result.write(oprot)
4560 
    oprot.writeMessageEnd()
4561 
    oprot.trans.flush()
4562 
 
690 chandransh 4563 
  def process_mergeCart(self, seqid, iprot, oprot):
4564 
    args = mergeCart_args()
575 chandransh 4565 
    args.read(iprot)
4566 
    iprot.readMessageEnd()
690 chandransh 4567 
    result = mergeCart_result()
4568 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4569 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4570 
    result.write(oprot)
4571 
    oprot.writeMessageEnd()
4572 
    oprot.trans.flush()
4573 
 
4574 
  def process_checkOut(self, seqid, iprot, oprot):
4575 
    args = checkOut_args()
4576 
    args.read(iprot)
4577 
    iprot.readMessageEnd()
4578 
    result = checkOut_result()
575 chandransh 4579 
    try:
690 chandransh 4580 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4581 
    except ShoppingCartException, scex:
4582 
      result.scex = scex
690 chandransh 4583 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4584 
    result.write(oprot)
4585 
    oprot.writeMessageEnd()
4586 
    oprot.trans.flush()
4587 
 
690 chandransh 4588 
  def process_resetCart(self, seqid, iprot, oprot):
4589 
    args = resetCart_args()
559 chandransh 4590 
    args.read(iprot)
4591 
    iprot.readMessageEnd()
690 chandransh 4592 
    result = resetCart_result()
4593 
    try:
4594 
      result.success = self._handler.resetCart(args.cartId, args.items)
4595 
    except ShoppingCartException, scex:
4596 
      result.scex = scex
4597 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4598 
    result.write(oprot)
4599 
    oprot.writeMessageEnd()
4600 
    oprot.trans.flush()
4601 
 
2981 rajveer 4602 
  def process_getUserCount(self, seqid, iprot, oprot):
4603 
    args = getUserCount_args()
559 chandransh 4604 
    args.read(iprot)
4605 
    iprot.readMessageEnd()
2981 rajveer 4606 
    result = getUserCount_result()
4607 
    result.success = self._handler.getUserCount(args.userType)
4608 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
4612 
 
2981 rajveer 4613 
  def process_getAllUsers(self, seqid, iprot, oprot):
4614 
    args = getAllUsers_args()
559 chandransh 4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
2981 rajveer 4617 
    result = getAllUsers_result()
4618 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4619 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4620 
    result.write(oprot)
4621 
    oprot.writeMessageEnd()
4622 
    oprot.trans.flush()
4623 
 
2981 rajveer 4624 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4625 
    args = getMyResearchItems_args()
559 chandransh 4626 
    args.read(iprot)
4627 
    iprot.readMessageEnd()
2981 rajveer 4628 
    result = getMyResearchItems_result()
559 chandransh 4629 
    try:
2981 rajveer 4630 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4631 
    except WidgetException, scx:
4632 
      result.scx = scx
2981 rajveer 4633 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4634 
    result.write(oprot)
4635 
    oprot.writeMessageEnd()
4636 
    oprot.trans.flush()
4637 
 
2981 rajveer 4638 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4639 
    args = updateMyResearch_args()
772 rajveer 4640 
    args.read(iprot)
4641 
    iprot.readMessageEnd()
2981 rajveer 4642 
    result = updateMyResearch_result()
4643 
    try:
4644 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4645 
    except WidgetException, scx:
4646 
      result.scx = scx
4647 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4648 
    result.write(oprot)
4649 
    oprot.writeMessageEnd()
4650 
    oprot.trans.flush()
559 chandransh 4651 
 
2981 rajveer 4652 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4653 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4654 
    args.read(iprot)
4655 
    iprot.readMessageEnd()
2981 rajveer 4656 
    result = deleteItemFromMyResearch_result()
4657 
    try:
4658 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4659 
    except WidgetException, scx:
4660 
      result.scx = scx
4661 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
772 rajveer 4665 
 
2981 rajveer 4666 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4667 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
2981 rajveer 4670 
    result = getBrowseHistoryItems_result()
4671 
    try:
4672 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4673 
    except WidgetException, scx:
4674 
      result.scx = scx
4675 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4676 
    result.write(oprot)
4677 
    oprot.writeMessageEnd()
4678 
    oprot.trans.flush()
1596 ankur.sing 4679 
 
2981 rajveer 4680 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4681 
    args = updateBrowseHistory_args()
2642 varun.gupt 4682 
    args.read(iprot)
4683 
    iprot.readMessageEnd()
2981 rajveer 4684 
    result = updateBrowseHistory_result()
4685 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4686 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4687 
    result.write(oprot)
4688 
    oprot.writeMessageEnd()
4689 
    oprot.trans.flush()
1673 ankur.sing 4690 
 
3385 varun.gupt 4691 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4692 
    args = getCartsWithCouponCount_args()
4693 
    args.read(iprot)
4694 
    iprot.readMessageEnd()
4695 
    result = getCartsWithCouponCount_result()
4696 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4697 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4698 
    result.write(oprot)
4699 
    oprot.writeMessageEnd()
4700 
    oprot.trans.flush()
2642 varun.gupt 4701 
 
3499 mandeep.dh 4702 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4703 
    args = increaseTrustLevel_args()
4704 
    args.read(iprot)
4705 
    iprot.readMessageEnd()
4706 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4707 
    return
3385 varun.gupt 4708 
 
5407 amar.kumar 4709 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4710 
    args = getTrustLevel_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = getTrustLevel_result()
4714 
    result.success = self._handler.getTrustLevel(args.userId)
4715 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4668 varun.gupt 4720 
  def process_showCODOption(self, seqid, iprot, oprot):
4721 
    args = showCODOption_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = showCODOption_result()
4725 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4726 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
3499 mandeep.dh 4730 
 
5623 anupam.sin 4731 
  def process_getUserEmails(self, seqid, iprot, oprot):
4732 
    args = getUserEmails_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = getUserEmails_result()
4736 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4737 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4668 varun.gupt 4741 
 
6903 anupam.sin 4742 
  def process_insureItem(self, seqid, iprot, oprot):
4743 
    args = insureItem_args()
4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
4746 
    result = insureItem_result()
9299 kshitij.so 4747 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4748 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
4753 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4754 
    args = cancelInsurance_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = cancelInsurance_result()
4758 
    result.success = self._handler.cancelInsurance(args.cartId)
4759 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4763 
 
4764 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4765 
    args = storeInsuranceSpecificDetails_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = storeInsuranceSpecificDetails_result()
4769 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4770 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4771 
    result.write(oprot)
4772 
    oprot.writeMessageEnd()
4773 
    oprot.trans.flush()
4774 
 
4775 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4776 
    args = isInsuranceDetailPresent_args()
4777 
    args.read(iprot)
4778 
    iprot.readMessageEnd()
4779 
    result = isInsuranceDetailPresent_result()
4780 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4781 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4782 
    result.write(oprot)
4783 
    oprot.writeMessageEnd()
4784 
    oprot.trans.flush()
4785 
 
9791 rajveer 4786 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4787 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4788 
    args.read(iprot)
4789 
    iprot.readMessageEnd()
9791 rajveer 4790 
    result = getProductsAddedToCart_result()
4791 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4792 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4793 
    result.write(oprot)
4794 
    oprot.writeMessageEnd()
4795 
    oprot.trans.flush()
5623 anupam.sin 4796 
 
11592 amit.gupta 4797 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4798 
    args = validateCartPlus_args()
4799 
    args.read(iprot)
4800 
    iprot.readMessageEnd()
4801 
    result = validateCartPlus_result()
4802 
    try:
11980 amit.gupta 4803 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4804 
    except ShoppingCartException, scex:
4805 
      result.scex = scex
4806 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4807 
    result.write(oprot)
4808 
    oprot.writeMessageEnd()
4809 
    oprot.trans.flush()
6821 amar.kumar 4810 
 
11679 vikram.rag 4811 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4812 
    args = isPrivateDealUser_args()
4813 
    args.read(iprot)
4814 
    iprot.readMessageEnd()
4815 
    result = isPrivateDealUser_result()
4816 
    result.success = self._handler.isPrivateDealUser(args.userId)
4817 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4818 
    result.write(oprot)
4819 
    oprot.writeMessageEnd()
4820 
    oprot.trans.flush()
11592 amit.gupta 4821 
 
11890 kshitij.so 4822 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4823 
    args = addPrivateDealUser_args()
4824 
    args.read(iprot)
4825 
    iprot.readMessageEnd()
4826 
    result = addPrivateDealUser_result()
4827 
    result.success = self._handler.addPrivateDealUser(args.userId)
4828 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4829 
    result.write(oprot)
4830 
    oprot.writeMessageEnd()
4831 
    oprot.trans.flush()
11679 vikram.rag 4832 
 
11890 kshitij.so 4833 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4834 
    args = changePrivateDealUserStatus_args()
4835 
    args.read(iprot)
4836 
    iprot.readMessageEnd()
4837 
    result = changePrivateDealUserStatus_result()
4838 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4839 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4840 
    result.write(oprot)
4841 
    oprot.writeMessageEnd()
4842 
    oprot.trans.flush()
4843 
 
4844 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4845 
    args = getPrivateDealUser_args()
4846 
    args.read(iprot)
4847 
    iprot.readMessageEnd()
4848 
    result = getPrivateDealUser_result()
4849 
    result.success = self._handler.getPrivateDealUser(args.userId)
4850 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4851 
    result.write(oprot)
4852 
    oprot.writeMessageEnd()
4853 
    oprot.trans.flush()
4854 
 
12696 amit.gupta 4855 
  def process_registerCounter(self, seqid, iprot, oprot):
4856 
    args = registerCounter_args()
4857 
    args.read(iprot)
4858 
    iprot.readMessageEnd()
4859 
    result = registerCounter_result()
4860 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4861 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4862 
    result.write(oprot)
4863 
    oprot.writeMessageEnd()
4864 
    oprot.trans.flush()
11890 kshitij.so 4865 
 
12722 amit.gupta 4866 
  def process_searchCounter(self, seqid, iprot, oprot):
4867 
    args = searchCounter_args()
4868 
    args.read(iprot)
4869 
    iprot.readMessageEnd()
4870 
    result = searchCounter_result()
4871 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4872 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4873 
    result.write(oprot)
4874 
    oprot.writeMessageEnd()
4875 
    oprot.trans.flush()
12696 amit.gupta 4876 
 
12722 amit.gupta 4877 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4878 
    args = getAllUsersByCounter_args()
4879 
    args.read(iprot)
4880 
    iprot.readMessageEnd()
4881 
    result = getAllUsersByCounter_result()
4882 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4883 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4884 
    result.write(oprot)
4885 
    oprot.writeMessageEnd()
4886 
    oprot.trans.flush()
4887 
 
15251 manish.sha 4888 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
4889 
    args = getActiveAccessTokenForUser_args()
4890 
    args.read(iprot)
4891 
    iprot.readMessageEnd()
4892 
    result = getActiveAccessTokenForUser_result()
4893 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
4894 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
4895 
    result.write(oprot)
4896 
    oprot.writeMessageEnd()
4897 
    oprot.trans.flush()
12722 amit.gupta 4898 
 
15251 manish.sha 4899 
  def process_validateAccessToken(self, seqid, iprot, oprot):
4900 
    args = validateAccessToken_args()
4901 
    args.read(iprot)
4902 
    iprot.readMessageEnd()
4903 
    result = validateAccessToken_result()
4904 
    result.success = self._handler.validateAccessToken(args.accessToken)
4905 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
17782 amit.gupta 4910 
  def process_addItemsToCart(self, seqid, iprot, oprot):
4911 
    args = addItemsToCart_args()
4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
4914 
    result = addItemsToCart_result()
4915 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
4916 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
15251 manish.sha 4920 
 
17782 amit.gupta 4921 
  def process_validateCartNew(self, seqid, iprot, oprot):
4922 
    args = validateCartNew_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = validateCartNew_result()
4926 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
4927 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
4931 
 
18644 manish.sha 4932 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
4933 
    args = isAddressEditableForCounter_args()
18530 manish.sha 4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
18644 manish.sha 4936 
    result = isAddressEditableForCounter_result()
4937 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
4938 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
17782 amit.gupta 4942 
 
18530 manish.sha 4943 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
4944 
    args = getBillingAddressForUser_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = getBillingAddressForUser_result()
4948 
    result.success = self._handler.getBillingAddressForUser(args.userId)
4949 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
4953 
 
18590 manish.sha 4954 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
4955 
    args = isCreditorAssigned_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = isCreditorAssigned_result()
4959 
    result.success = self._handler.isCreditorAssigned(args.userId)
4960 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
18530 manish.sha 4964 
 
18590 manish.sha 4965 
 
94 ashish 4966 
# HELPER FUNCTIONS AND STRUCTURES
4967 
 
559 chandransh 4968 
class createAnonymousUser_args:
94 ashish 4969 
  """
4970 
  Attributes:
559 chandransh 4971 
   - jsessionId
94 ashish 4972 
  """
4973 
 
4974 
  thrift_spec = (
4975 
    None, # 0
559 chandransh 4976 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4977 
  )
4978 
 
559 chandransh 4979 
  def __init__(self, jsessionId=None,):
4980 
    self.jsessionId = jsessionId
94 ashish 4981 
 
4982 
  def read(self, iprot):
4983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4985 
      return
4986 
    iprot.readStructBegin()
4987 
    while True:
4988 
      (fname, ftype, fid) = iprot.readFieldBegin()
4989 
      if ftype == TType.STOP:
4990 
        break
4991 
      if fid == 1:
559 chandransh 4992 
        if ftype == TType.STRING:
4993 
          self.jsessionId = iprot.readString();
94 ashish 4994 
        else:
4995 
          iprot.skip(ftype)
4996 
      else:
4997 
        iprot.skip(ftype)
4998 
      iprot.readFieldEnd()
4999 
    iprot.readStructEnd()
5000 
 
5001 
  def write(self, oprot):
5002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5004 
      return
559 chandransh 5005 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5006 
    if self.jsessionId is not None:
559 chandransh 5007 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5008 
      oprot.writeString(self.jsessionId)
94 ashish 5009 
      oprot.writeFieldEnd()
5010 
    oprot.writeFieldStop()
5011 
    oprot.writeStructEnd()
5012 
 
3431 rajveer 5013 
  def validate(self):
5014 
    return
5015 
 
5016 
 
94 ashish 5017 
  def __repr__(self):
5018 
    L = ['%s=%r' % (key, value)
5019 
      for key, value in self.__dict__.iteritems()]
5020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5021 
 
5022 
  def __eq__(self, other):
5023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5024 
 
5025 
  def __ne__(self, other):
5026 
    return not (self == other)
5027 
 
559 chandransh 5028 
class createAnonymousUser_result:
94 ashish 5029 
  """
5030 
  Attributes:
5031 
   - success
559 chandransh 5032 
   - ucex
94 ashish 5033 
  """
5034 
 
5035 
  thrift_spec = (
559 chandransh 5036 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5037 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5038 
  )
5039 
 
559 chandransh 5040 
  def __init__(self, success=None, ucex=None,):
94 ashish 5041 
    self.success = success
559 chandransh 5042 
    self.ucex = ucex
94 ashish 5043 
 
5044 
  def read(self, iprot):
5045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5047 
      return
5048 
    iprot.readStructBegin()
5049 
    while True:
5050 
      (fname, ftype, fid) = iprot.readFieldBegin()
5051 
      if ftype == TType.STOP:
5052 
        break
5053 
      if fid == 0:
5054 
        if ftype == TType.STRUCT:
559 chandransh 5055 
          self.success = User()
94 ashish 5056 
          self.success.read(iprot)
5057 
        else:
5058 
          iprot.skip(ftype)
5059 
      elif fid == 1:
5060 
        if ftype == TType.STRUCT:
559 chandransh 5061 
          self.ucex = UserContextException()
5062 
          self.ucex.read(iprot)
94 ashish 5063 
        else:
5064 
          iprot.skip(ftype)
5065 
      else:
5066 
        iprot.skip(ftype)
5067 
      iprot.readFieldEnd()
5068 
    iprot.readStructEnd()
5069 
 
5070 
  def write(self, oprot):
5071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5073 
      return
559 chandransh 5074 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5075 
    if self.success is not None:
94 ashish 5076 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5077 
      self.success.write(oprot)
5078 
      oprot.writeFieldEnd()
3431 rajveer 5079 
    if self.ucex is not None:
559 chandransh 5080 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5081 
      self.ucex.write(oprot)
94 ashish 5082 
      oprot.writeFieldEnd()
5083 
    oprot.writeFieldStop()
5084 
    oprot.writeStructEnd()
5085 
 
3431 rajveer 5086 
  def validate(self):
5087 
    return
5088 
 
5089 
 
94 ashish 5090 
  def __repr__(self):
5091 
    L = ['%s=%r' % (key, value)
5092 
      for key, value in self.__dict__.iteritems()]
5093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5094 
 
5095 
  def __eq__(self, other):
5096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5097 
 
5098 
  def __ne__(self, other):
5099 
    return not (self == other)
5100 
 
559 chandransh 5101 
class getUserById_args:
94 ashish 5102 
  """
5103 
  Attributes:
5104 
   - userId
5105 
  """
5106 
 
5107 
  thrift_spec = (
5108 
    None, # 0
5109 
    (1, TType.I64, 'userId', None, None, ), # 1
5110 
  )
5111 
 
559 chandransh 5112 
  def __init__(self, userId=None,):
94 ashish 5113 
    self.userId = userId
5114 
 
5115 
  def read(self, iprot):
5116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5118 
      return
5119 
    iprot.readStructBegin()
5120 
    while True:
5121 
      (fname, ftype, fid) = iprot.readFieldBegin()
5122 
      if ftype == TType.STOP:
5123 
        break
5124 
      if fid == 1:
5125 
        if ftype == TType.I64:
5126 
          self.userId = iprot.readI64();
5127 
        else:
5128 
          iprot.skip(ftype)
5129 
      else:
5130 
        iprot.skip(ftype)
5131 
      iprot.readFieldEnd()
5132 
    iprot.readStructEnd()
5133 
 
5134 
  def write(self, oprot):
5135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5137 
      return
559 chandransh 5138 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5139 
    if self.userId is not None:
94 ashish 5140 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5141 
      oprot.writeI64(self.userId)
5142 
      oprot.writeFieldEnd()
5143 
    oprot.writeFieldStop()
5144 
    oprot.writeStructEnd()
5145 
 
3431 rajveer 5146 
  def validate(self):
5147 
    return
5148 
 
5149 
 
94 ashish 5150 
  def __repr__(self):
5151 
    L = ['%s=%r' % (key, value)
5152 
      for key, value in self.__dict__.iteritems()]
5153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5154 
 
5155 
  def __eq__(self, other):
5156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5157 
 
5158 
  def __ne__(self, other):
5159 
    return not (self == other)
5160 
 
559 chandransh 5161 
class getUserById_result:
94 ashish 5162 
  """
5163 
  Attributes:
5164 
   - success
559 chandransh 5165 
   - ucex
94 ashish 5166 
  """
5167 
 
5168 
  thrift_spec = (
559 chandransh 5169 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5170 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5171 
  )
5172 
 
559 chandransh 5173 
  def __init__(self, success=None, ucex=None,):
94 ashish 5174 
    self.success = success
559 chandransh 5175 
    self.ucex = ucex
94 ashish 5176 
 
5177 
  def read(self, iprot):
5178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5180 
      return
5181 
    iprot.readStructBegin()
5182 
    while True:
5183 
      (fname, ftype, fid) = iprot.readFieldBegin()
5184 
      if ftype == TType.STOP:
5185 
        break
5186 
      if fid == 0:
5187 
        if ftype == TType.STRUCT:
559 chandransh 5188 
          self.success = User()
94 ashish 5189 
          self.success.read(iprot)
5190 
        else:
5191 
          iprot.skip(ftype)
5192 
      elif fid == 1:
5193 
        if ftype == TType.STRUCT:
559 chandransh 5194 
          self.ucex = UserContextException()
5195 
          self.ucex.read(iprot)
94 ashish 5196 
        else:
5197 
          iprot.skip(ftype)
5198 
      else:
5199 
        iprot.skip(ftype)
5200 
      iprot.readFieldEnd()
5201 
    iprot.readStructEnd()
5202 
 
5203 
  def write(self, oprot):
5204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5206 
      return
559 chandransh 5207 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5208 
    if self.success is not None:
94 ashish 5209 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5210 
      self.success.write(oprot)
5211 
      oprot.writeFieldEnd()
3431 rajveer 5212 
    if self.ucex is not None:
559 chandransh 5213 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5214 
      self.ucex.write(oprot)
94 ashish 5215 
      oprot.writeFieldEnd()
5216 
    oprot.writeFieldStop()
5217 
    oprot.writeStructEnd()
5218 
 
3431 rajveer 5219 
  def validate(self):
5220 
    return
5221 
 
5222 
 
94 ashish 5223 
  def __repr__(self):
5224 
    L = ['%s=%r' % (key, value)
5225 
      for key, value in self.__dict__.iteritems()]
5226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5227 
 
5228 
  def __eq__(self, other):
5229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5230 
 
5231 
  def __ne__(self, other):
5232 
    return not (self == other)
5233 
 
5326 rajveer 5234 
class getUserByCartId_args:
1491 vikas 5235 
  """
5236 
  Attributes:
5326 rajveer 5237 
   - cartId
1491 vikas 5238 
  """
5239 
 
5240 
  thrift_spec = (
5241 
    None, # 0
5326 rajveer 5242 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5243 
  )
5244 
 
5326 rajveer 5245 
  def __init__(self, cartId=None,):
5246 
    self.cartId = cartId
1491 vikas 5247 
 
5248 
  def read(self, iprot):
5249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5251 
      return
5252 
    iprot.readStructBegin()
5253 
    while True:
5254 
      (fname, ftype, fid) = iprot.readFieldBegin()
5255 
      if ftype == TType.STOP:
5256 
        break
5257 
      if fid == 1:
5326 rajveer 5258 
        if ftype == TType.I64:
5259 
          self.cartId = iprot.readI64();
1491 vikas 5260 
        else:
5261 
          iprot.skip(ftype)
5262 
      else:
5263 
        iprot.skip(ftype)
5264 
      iprot.readFieldEnd()
5265 
    iprot.readStructEnd()
5266 
 
5267 
  def write(self, oprot):
5268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5270 
      return
5326 rajveer 5271 
    oprot.writeStructBegin('getUserByCartId_args')
5272 
    if self.cartId is not None:
5273 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5274 
      oprot.writeI64(self.cartId)
1491 vikas 5275 
      oprot.writeFieldEnd()
5276 
    oprot.writeFieldStop()
5277 
    oprot.writeStructEnd()
5278 
 
3431 rajveer 5279 
  def validate(self):
5280 
    return
5281 
 
5282 
 
1491 vikas 5283 
  def __repr__(self):
5284 
    L = ['%s=%r' % (key, value)
5285 
      for key, value in self.__dict__.iteritems()]
5286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5287 
 
5288 
  def __eq__(self, other):
5289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5290 
 
5291 
  def __ne__(self, other):
5292 
    return not (self == other)
5293 
 
5326 rajveer 5294 
class getUserByCartId_result:
1491 vikas 5295 
  """
5296 
  Attributes:
5297 
   - success
5298 
   - ucex
5299 
  """
5300 
 
5301 
  thrift_spec = (
5302 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5303 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5304 
  )
5305 
 
5306 
  def __init__(self, success=None, ucex=None,):
5307 
    self.success = success
5308 
    self.ucex = ucex
5309 
 
5310 
  def read(self, iprot):
5311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5313 
      return
5314 
    iprot.readStructBegin()
5315 
    while True:
5316 
      (fname, ftype, fid) = iprot.readFieldBegin()
5317 
      if ftype == TType.STOP:
5318 
        break
5319 
      if fid == 0:
5320 
        if ftype == TType.STRUCT:
5321 
          self.success = User()
5322 
          self.success.read(iprot)
5323 
        else:
5324 
          iprot.skip(ftype)
5325 
      elif fid == 1:
5326 
        if ftype == TType.STRUCT:
5327 
          self.ucex = UserContextException()
5328 
          self.ucex.read(iprot)
5329 
        else:
5330 
          iprot.skip(ftype)
5331 
      else:
5332 
        iprot.skip(ftype)
5333 
      iprot.readFieldEnd()
5334 
    iprot.readStructEnd()
5335 
 
5336 
  def write(self, oprot):
5337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5339 
      return
5326 rajveer 5340 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5341 
    if self.success is not None:
1491 vikas 5342 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5343 
      self.success.write(oprot)
5344 
      oprot.writeFieldEnd()
3431 rajveer 5345 
    if self.ucex is not None:
1491 vikas 5346 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5347 
      self.ucex.write(oprot)
5348 
      oprot.writeFieldEnd()
5349 
    oprot.writeFieldStop()
5350 
    oprot.writeStructEnd()
5351 
 
3431 rajveer 5352 
  def validate(self):
5353 
    return
5354 
 
5355 
 
1491 vikas 5356 
  def __repr__(self):
5357 
    L = ['%s=%r' % (key, value)
5358 
      for key, value in self.__dict__.iteritems()]
5359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5360 
 
5361 
  def __eq__(self, other):
5362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5363 
 
5364 
  def __ne__(self, other):
5365 
    return not (self == other)
5366 
 
5326 rajveer 5367 
class getUserByEmail_args:
3032 mandeep.dh 5368 
  """
5369 
  Attributes:
5326 rajveer 5370 
   - email
3032 mandeep.dh 5371 
  """
5372 
 
5373 
  thrift_spec = (
5374 
    None, # 0
5326 rajveer 5375 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5376 
  )
5377 
 
5326 rajveer 5378 
  def __init__(self, email=None,):
5379 
    self.email = email
3032 mandeep.dh 5380 
 
5381 
  def read(self, iprot):
5382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5384 
      return
5385 
    iprot.readStructBegin()
5386 
    while True:
5387 
      (fname, ftype, fid) = iprot.readFieldBegin()
5388 
      if ftype == TType.STOP:
5389 
        break
5390 
      if fid == 1:
5326 rajveer 5391 
        if ftype == TType.STRING:
5392 
          self.email = iprot.readString();
3032 mandeep.dh 5393 
        else:
5394 
          iprot.skip(ftype)
5395 
      else:
5396 
        iprot.skip(ftype)
5397 
      iprot.readFieldEnd()
5398 
    iprot.readStructEnd()
5399 
 
5400 
  def write(self, oprot):
5401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5403 
      return
5326 rajveer 5404 
    oprot.writeStructBegin('getUserByEmail_args')
5405 
    if self.email is not None:
5406 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5407 
      oprot.writeString(self.email)
3032 mandeep.dh 5408 
      oprot.writeFieldEnd()
5409 
    oprot.writeFieldStop()
5410 
    oprot.writeStructEnd()
5411 
 
3431 rajveer 5412 
  def validate(self):
5413 
    return
5414 
 
5415 
 
3032 mandeep.dh 5416 
  def __repr__(self):
5417 
    L = ['%s=%r' % (key, value)
5418 
      for key, value in self.__dict__.iteritems()]
5419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5420 
 
5421 
  def __eq__(self, other):
5422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5423 
 
5424 
  def __ne__(self, other):
5425 
    return not (self == other)
5426 
 
5326 rajveer 5427 
class getUserByEmail_result:
3032 mandeep.dh 5428 
  """
5429 
  Attributes:
5430 
   - success
5431 
   - ucex
5432 
  """
5433 
 
5434 
  thrift_spec = (
5435 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5436 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5437 
  )
5438 
 
5439 
  def __init__(self, success=None, ucex=None,):
5440 
    self.success = success
5441 
    self.ucex = ucex
5442 
 
5443 
  def read(self, iprot):
5444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5446 
      return
5447 
    iprot.readStructBegin()
5448 
    while True:
5449 
      (fname, ftype, fid) = iprot.readFieldBegin()
5450 
      if ftype == TType.STOP:
5451 
        break
5452 
      if fid == 0:
5453 
        if ftype == TType.STRUCT:
5454 
          self.success = User()
5455 
          self.success.read(iprot)
5456 
        else:
5457 
          iprot.skip(ftype)
5458 
      elif fid == 1:
5459 
        if ftype == TType.STRUCT:
5460 
          self.ucex = UserContextException()
5461 
          self.ucex.read(iprot)
5462 
        else:
5463 
          iprot.skip(ftype)
5464 
      else:
5465 
        iprot.skip(ftype)
5466 
      iprot.readFieldEnd()
5467 
    iprot.readStructEnd()
5468 
 
5469 
  def write(self, oprot):
5470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5472 
      return
5326 rajveer 5473 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5474 
    if self.success is not None:
3032 mandeep.dh 5475 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5476 
      self.success.write(oprot)
5477 
      oprot.writeFieldEnd()
3431 rajveer 5478 
    if self.ucex is not None:
3032 mandeep.dh 5479 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5480 
      self.ucex.write(oprot)
5481 
      oprot.writeFieldEnd()
5482 
    oprot.writeFieldStop()
5483 
    oprot.writeStructEnd()
5484 
 
3431 rajveer 5485 
  def validate(self):
5486 
    return
5487 
 
5488 
 
3032 mandeep.dh 5489 
  def __repr__(self):
5490 
    L = ['%s=%r' % (key, value)
5491 
      for key, value in self.__dict__.iteritems()]
5492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5493 
 
5494 
  def __eq__(self, other):
5495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5496 
 
5497 
  def __ne__(self, other):
5498 
    return not (self == other)
5499 
 
5326 rajveer 5500 
class getUserByMobileNumber_args:
94 ashish 5501 
  """
5502 
  Attributes:
5326 rajveer 5503 
   - mobileNumber
94 ashish 5504 
  """
5505 
 
5506 
  thrift_spec = (
5507 
    None, # 0
5326 rajveer 5508 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5509 
  )
5510 
 
5326 rajveer 5511 
  def __init__(self, mobileNumber=None,):
5512 
    self.mobileNumber = mobileNumber
94 ashish 5513 
 
5514 
  def read(self, iprot):
5515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5517 
      return
5518 
    iprot.readStructBegin()
5519 
    while True:
5520 
      (fname, ftype, fid) = iprot.readFieldBegin()
5521 
      if ftype == TType.STOP:
5522 
        break
5523 
      if fid == 1:
5326 rajveer 5524 
        if ftype == TType.I64:
5525 
          self.mobileNumber = iprot.readI64();
94 ashish 5526 
        else:
5527 
          iprot.skip(ftype)
5528 
      else:
5529 
        iprot.skip(ftype)
5530 
      iprot.readFieldEnd()
5531 
    iprot.readStructEnd()
5532 
 
5533 
  def write(self, oprot):
5534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5536 
      return
5326 rajveer 5537 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5538 
    if self.mobileNumber is not None:
5539 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5540 
      oprot.writeI64(self.mobileNumber)
94 ashish 5541 
      oprot.writeFieldEnd()
5542 
    oprot.writeFieldStop()
5543 
    oprot.writeStructEnd()
5544 
 
3431 rajveer 5545 
  def validate(self):
5546 
    return
5547 
 
5548 
 
94 ashish 5549 
  def __repr__(self):
5550 
    L = ['%s=%r' % (key, value)
5551 
      for key, value in self.__dict__.iteritems()]
5552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5553 
 
5554 
  def __eq__(self, other):
5555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5556 
 
5557 
  def __ne__(self, other):
5558 
    return not (self == other)
5559 
 
5326 rajveer 5560 
class getUserByMobileNumber_result:
94 ashish 5561 
  """
5562 
  Attributes:
5563 
   - success
559 chandransh 5564 
   - ucex
94 ashish 5565 
  """
5566 
 
5567 
  thrift_spec = (
559 chandransh 5568 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5569 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5570 
  )
5571 
 
559 chandransh 5572 
  def __init__(self, success=None, ucex=None,):
94 ashish 5573 
    self.success = success
559 chandransh 5574 
    self.ucex = ucex
94 ashish 5575 
 
5576 
  def read(self, iprot):
5577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5579 
      return
5580 
    iprot.readStructBegin()
5581 
    while True:
5582 
      (fname, ftype, fid) = iprot.readFieldBegin()
5583 
      if ftype == TType.STOP:
5584 
        break
5585 
      if fid == 0:
5586 
        if ftype == TType.STRUCT:
559 chandransh 5587 
          self.success = User()
94 ashish 5588 
          self.success.read(iprot)
5589 
        else:
5590 
          iprot.skip(ftype)
5591 
      elif fid == 1:
5592 
        if ftype == TType.STRUCT:
559 chandransh 5593 
          self.ucex = UserContextException()
5594 
          self.ucex.read(iprot)
94 ashish 5595 
        else:
5596 
          iprot.skip(ftype)
5597 
      else:
5598 
        iprot.skip(ftype)
5599 
      iprot.readFieldEnd()
5600 
    iprot.readStructEnd()
5601 
 
5602 
  def write(self, oprot):
5603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5605 
      return
5326 rajveer 5606 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5607 
    if self.success is not None:
94 ashish 5608 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5609 
      self.success.write(oprot)
5610 
      oprot.writeFieldEnd()
3431 rajveer 5611 
    if self.ucex is not None:
559 chandransh 5612 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5613 
      self.ucex.write(oprot)
94 ashish 5614 
      oprot.writeFieldEnd()
5615 
    oprot.writeFieldStop()
5616 
    oprot.writeStructEnd()
5617 
 
3431 rajveer 5618 
  def validate(self):
5619 
    return
5620 
 
5621 
 
94 ashish 5622 
  def __repr__(self):
5623 
    L = ['%s=%r' % (key, value)
5624 
      for key, value in self.__dict__.iteritems()]
5625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5626 
 
5627 
  def __eq__(self, other):
5628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5629 
 
5630 
  def __ne__(self, other):
5631 
    return not (self == other)
5632 
 
5326 rajveer 5633 
class createUser_args:
94 ashish 5634 
  """
5635 
  Attributes:
559 chandransh 5636 
   - user
94 ashish 5637 
  """
5638 
 
5639 
  thrift_spec = (
5640 
    None, # 0
559 chandransh 5641 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5642 
  )
5643 
 
559 chandransh 5644 
  def __init__(self, user=None,):
5645 
    self.user = user
94 ashish 5646 
 
5647 
  def read(self, iprot):
5648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5650 
      return
5651 
    iprot.readStructBegin()
5652 
    while True:
5653 
      (fname, ftype, fid) = iprot.readFieldBegin()
5654 
      if ftype == TType.STOP:
5655 
        break
5656 
      if fid == 1:
559 chandransh 5657 
        if ftype == TType.STRUCT:
5658 
          self.user = User()
5659 
          self.user.read(iprot)
94 ashish 5660 
        else:
5661 
          iprot.skip(ftype)
5662 
      else:
5663 
        iprot.skip(ftype)
5664 
      iprot.readFieldEnd()
5665 
    iprot.readStructEnd()
5666 
 
5667 
  def write(self, oprot):
5668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5670 
      return
5326 rajveer 5671 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5672 
    if self.user is not None:
559 chandransh 5673 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5674 
      self.user.write(oprot)
94 ashish 5675 
      oprot.writeFieldEnd()
5676 
    oprot.writeFieldStop()
5677 
    oprot.writeStructEnd()
5678 
 
3431 rajveer 5679 
  def validate(self):
5680 
    return
5681 
 
5682 
 
94 ashish 5683 
  def __repr__(self):
5684 
    L = ['%s=%r' % (key, value)
5685 
      for key, value in self.__dict__.iteritems()]
5686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5687 
 
5688 
  def __eq__(self, other):
5689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5690 
 
5691 
  def __ne__(self, other):
5692 
    return not (self == other)
5693 
 
5326 rajveer 5694 
class createUser_result:
94 ashish 5695 
  """
5696 
  Attributes:
5697 
   - success
559 chandransh 5698 
   - ucex
94 ashish 5699 
  """
5700 
 
5701 
  thrift_spec = (
559 chandransh 5702 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5703 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5704 
  )
5705 
 
559 chandransh 5706 
  def __init__(self, success=None, ucex=None,):
94 ashish 5707 
    self.success = success
559 chandransh 5708 
    self.ucex = ucex
94 ashish 5709 
 
5710 
  def read(self, iprot):
5711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5713 
      return
5714 
    iprot.readStructBegin()
5715 
    while True:
5716 
      (fname, ftype, fid) = iprot.readFieldBegin()
5717 
      if ftype == TType.STOP:
5718 
        break
5719 
      if fid == 0:
5720 
        if ftype == TType.STRUCT:
559 chandransh 5721 
          self.success = User()
94 ashish 5722 
          self.success.read(iprot)
5723 
        else:
5724 
          iprot.skip(ftype)
5725 
      elif fid == 1:
5726 
        if ftype == TType.STRUCT:
559 chandransh 5727 
          self.ucex = UserContextException()
5728 
          self.ucex.read(iprot)
94 ashish 5729 
        else:
5730 
          iprot.skip(ftype)
5731 
      else:
5732 
        iprot.skip(ftype)
5733 
      iprot.readFieldEnd()
5734 
    iprot.readStructEnd()
5735 
 
5736 
  def write(self, oprot):
5737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5739 
      return
5326 rajveer 5740 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5741 
    if self.success is not None:
94 ashish 5742 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5743 
      self.success.write(oprot)
5744 
      oprot.writeFieldEnd()
3431 rajveer 5745 
    if self.ucex is not None:
559 chandransh 5746 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5747 
      self.ucex.write(oprot)
94 ashish 5748 
      oprot.writeFieldEnd()
5749 
    oprot.writeFieldStop()
5750 
    oprot.writeStructEnd()
5751 
 
3431 rajveer 5752 
  def validate(self):
5753 
    return
5754 
 
5755 
 
94 ashish 5756 
  def __repr__(self):
5757 
    L = ['%s=%r' % (key, value)
5758 
      for key, value in self.__dict__.iteritems()]
5759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5760 
 
5761 
  def __eq__(self, other):
5762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5763 
 
5764 
  def __ne__(self, other):
5765 
    return not (self == other)
5766 
 
5326 rajveer 5767 
class updateUser_args:
94 ashish 5768 
  """
5769 
  Attributes:
5326 rajveer 5770 
   - user
94 ashish 5771 
  """
5772 
 
5773 
  thrift_spec = (
5774 
    None, # 0
5326 rajveer 5775 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5776 
  )
5777 
 
5326 rajveer 5778 
  def __init__(self, user=None,):
5779 
    self.user = user
94 ashish 5780 
 
5781 
  def read(self, iprot):
5782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5784 
      return
5785 
    iprot.readStructBegin()
5786 
    while True:
5787 
      (fname, ftype, fid) = iprot.readFieldBegin()
5788 
      if ftype == TType.STOP:
5789 
        break
5790 
      if fid == 1:
5326 rajveer 5791 
        if ftype == TType.STRUCT:
5792 
          self.user = User()
5793 
          self.user.read(iprot)
94 ashish 5794 
        else:
5795 
          iprot.skip(ftype)
5796 
      else:
5797 
        iprot.skip(ftype)
5798 
      iprot.readFieldEnd()
5799 
    iprot.readStructEnd()
5800 
 
5801 
  def write(self, oprot):
5802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5804 
      return
5326 rajveer 5805 
    oprot.writeStructBegin('updateUser_args')
5806 
    if self.user is not None:
5807 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5808 
      self.user.write(oprot)
94 ashish 5809 
      oprot.writeFieldEnd()
5810 
    oprot.writeFieldStop()
5811 
    oprot.writeStructEnd()
5812 
 
3431 rajveer 5813 
  def validate(self):
5814 
    return
5815 
 
5816 
 
94 ashish 5817 
  def __repr__(self):
5818 
    L = ['%s=%r' % (key, value)
5819 
      for key, value in self.__dict__.iteritems()]
5820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5821 
 
5822 
  def __eq__(self, other):
5823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5824 
 
5825 
  def __ne__(self, other):
5826 
    return not (self == other)
5827 
 
5326 rajveer 5828 
class updateUser_result:
94 ashish 5829 
  """
5830 
  Attributes:
5831 
   - success
559 chandransh 5832 
   - ucex
94 ashish 5833 
  """
5834 
 
5835 
  thrift_spec = (
5326 rajveer 5836 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5837 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5838 
  )
5839 
 
559 chandransh 5840 
  def __init__(self, success=None, ucex=None,):
94 ashish 5841 
    self.success = success
559 chandransh 5842 
    self.ucex = ucex
94 ashish 5843 
 
5844 
  def read(self, iprot):
5845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5847 
      return
5848 
    iprot.readStructBegin()
5849 
    while True:
5850 
      (fname, ftype, fid) = iprot.readFieldBegin()
5851 
      if ftype == TType.STOP:
5852 
        break
5853 
      if fid == 0:
5326 rajveer 5854 
        if ftype == TType.STRUCT:
5855 
          self.success = User()
5856 
          self.success.read(iprot)
94 ashish 5857 
        else:
5858 
          iprot.skip(ftype)
5859 
      elif fid == 1:
5860 
        if ftype == TType.STRUCT:
559 chandransh 5861 
          self.ucex = UserContextException()
5862 
          self.ucex.read(iprot)
94 ashish 5863 
        else:
5864 
          iprot.skip(ftype)
5865 
      else:
5866 
        iprot.skip(ftype)
5867 
      iprot.readFieldEnd()
5868 
    iprot.readStructEnd()
5869 
 
5870 
  def write(self, oprot):
5871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5873 
      return
5326 rajveer 5874 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5875 
    if self.success is not None:
5326 rajveer 5876 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5877 
      self.success.write(oprot)
94 ashish 5878 
      oprot.writeFieldEnd()
3431 rajveer 5879 
    if self.ucex is not None:
559 chandransh 5880 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5881 
      self.ucex.write(oprot)
94 ashish 5882 
      oprot.writeFieldEnd()
5883 
    oprot.writeFieldStop()
5884 
    oprot.writeStructEnd()
5885 
 
3431 rajveer 5886 
  def validate(self):
5887 
    return
5888 
 
5889 
 
94 ashish 5890 
  def __repr__(self):
5891 
    L = ['%s=%r' % (key, value)
5892 
      for key, value in self.__dict__.iteritems()]
5893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5894 
 
5895 
  def __eq__(self, other):
5896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5897 
 
5898 
  def __ne__(self, other):
5899 
    return not (self == other)
5900 
 
559 chandransh 5901 
class authenticateUser_args:
94 ashish 5902 
  """
5903 
  Attributes:
5904 
   - email
5905 
   - password
5906 
  """
5907 
 
5908 
  thrift_spec = (
5909 
    None, # 0
5910 
    (1, TType.STRING, 'email', None, None, ), # 1
5911 
    (2, TType.STRING, 'password', None, None, ), # 2
5912 
  )
5913 
 
5914 
  def __init__(self, email=None, password=None,):
5915 
    self.email = email
5916 
    self.password = password
5917 
 
5918 
  def read(self, iprot):
5919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5921 
      return
5922 
    iprot.readStructBegin()
5923 
    while True:
5924 
      (fname, ftype, fid) = iprot.readFieldBegin()
5925 
      if ftype == TType.STOP:
5926 
        break
5927 
      if fid == 1:
5928 
        if ftype == TType.STRING:
5929 
          self.email = iprot.readString();
5930 
        else:
5931 
          iprot.skip(ftype)
5932 
      elif fid == 2:
5933 
        if ftype == TType.STRING:
5934 
          self.password = iprot.readString();
5935 
        else:
5936 
          iprot.skip(ftype)
5937 
      else:
5938 
        iprot.skip(ftype)
5939 
      iprot.readFieldEnd()
5940 
    iprot.readStructEnd()
5941 
 
5942 
  def write(self, oprot):
5943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5945 
      return
559 chandransh 5946 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5947 
    if self.email is not None:
94 ashish 5948 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5949 
      oprot.writeString(self.email)
5950 
      oprot.writeFieldEnd()
3431 rajveer 5951 
    if self.password is not None:
94 ashish 5952 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5953 
      oprot.writeString(self.password)
5954 
      oprot.writeFieldEnd()
5955 
    oprot.writeFieldStop()
5956 
    oprot.writeStructEnd()
5957 
 
3431 rajveer 5958 
  def validate(self):
5959 
    return
5960 
 
5961 
 
94 ashish 5962 
  def __repr__(self):
5963 
    L = ['%s=%r' % (key, value)
5964 
      for key, value in self.__dict__.iteritems()]
5965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5966 
 
5967 
  def __eq__(self, other):
5968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5969 
 
5970 
  def __ne__(self, other):
5971 
    return not (self == other)
5972 
 
559 chandransh 5973 
class authenticateUser_result:
94 ashish 5974 
  """
5975 
  Attributes:
5976 
   - success
559 chandransh 5977 
   - auex
94 ashish 5978 
  """
5979 
 
5980 
  thrift_spec = (
559 chandransh 5981 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5982 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5983 
  )
5984 
 
559 chandransh 5985 
  def __init__(self, success=None, auex=None,):
94 ashish 5986 
    self.success = success
559 chandransh 5987 
    self.auex = auex
94 ashish 5988 
 
5989 
  def read(self, iprot):
5990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5992 
      return
5993 
    iprot.readStructBegin()
5994 
    while True:
5995 
      (fname, ftype, fid) = iprot.readFieldBegin()
5996 
      if ftype == TType.STOP:
5997 
        break
5998 
      if fid == 0:
5999 
        if ftype == TType.STRUCT:
559 chandransh 6000 
          self.success = User()
94 ashish 6001 
          self.success.read(iprot)
6002 
        else:
6003 
          iprot.skip(ftype)
6004 
      elif fid == 1:
6005 
        if ftype == TType.STRUCT:
559 chandransh 6006 
          self.auex = AuthenticationException()
6007 
          self.auex.read(iprot)
94 ashish 6008 
        else:
6009 
          iprot.skip(ftype)
6010 
      else:
6011 
        iprot.skip(ftype)
6012 
      iprot.readFieldEnd()
6013 
    iprot.readStructEnd()
6014 
 
6015 
  def write(self, oprot):
6016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6018 
      return
559 chandransh 6019 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6020 
    if self.success is not None:
94 ashish 6021 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6022 
      self.success.write(oprot)
6023 
      oprot.writeFieldEnd()
3431 rajveer 6024 
    if self.auex is not None:
559 chandransh 6025 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6026 
      self.auex.write(oprot)
94 ashish 6027 
      oprot.writeFieldEnd()
6028 
    oprot.writeFieldStop()
6029 
    oprot.writeStructEnd()
6030 
 
3431 rajveer 6031 
  def validate(self):
6032 
    return
6033 
 
6034 
 
94 ashish 6035 
  def __repr__(self):
6036 
    L = ['%s=%r' % (key, value)
6037 
      for key, value in self.__dict__.iteritems()]
6038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6039 
 
6040 
  def __eq__(self, other):
6041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6042 
 
6043 
  def __ne__(self, other):
6044 
    return not (self == other)
6045 
 
559 chandransh 6046 
class userExists_args:
122 ashish 6047 
  """
6048 
  Attributes:
559 chandransh 6049 
   - email
122 ashish 6050 
  """
6051 
 
6052 
  thrift_spec = (
6053 
    None, # 0
559 chandransh 6054 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6055 
  )
6056 
 
559 chandransh 6057 
  def __init__(self, email=None,):
6058 
    self.email = email
122 ashish 6059 
 
6060 
  def read(self, iprot):
6061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6063 
      return
6064 
    iprot.readStructBegin()
6065 
    while True:
6066 
      (fname, ftype, fid) = iprot.readFieldBegin()
6067 
      if ftype == TType.STOP:
6068 
        break
6069 
      if fid == 1:
6070 
        if ftype == TType.STRING:
559 chandransh 6071 
          self.email = iprot.readString();
122 ashish 6072 
        else:
6073 
          iprot.skip(ftype)
559 chandransh 6074 
      else:
6075 
        iprot.skip(ftype)
6076 
      iprot.readFieldEnd()
6077 
    iprot.readStructEnd()
6078 
 
6079 
  def write(self, oprot):
6080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6082 
      return
6083 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6084 
    if self.email is not None:
559 chandransh 6085 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6086 
      oprot.writeString(self.email)
6087 
      oprot.writeFieldEnd()
6088 
    oprot.writeFieldStop()
6089 
    oprot.writeStructEnd()
6090 
 
3431 rajveer 6091 
  def validate(self):
6092 
    return
6093 
 
6094 
 
559 chandransh 6095 
  def __repr__(self):
6096 
    L = ['%s=%r' % (key, value)
6097 
      for key, value in self.__dict__.iteritems()]
6098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6099 
 
6100 
  def __eq__(self, other):
6101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6102 
 
6103 
  def __ne__(self, other):
6104 
    return not (self == other)
6105 
 
6106 
class userExists_result:
6107 
  """
6108 
  Attributes:
6109 
   - success
6110 
   - ucx
6111 
  """
6112 
 
6113 
  thrift_spec = (
6114 
    (0, TType.BOOL, 'success', None, None, ), # 0
6115 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6116 
  )
6117 
 
6118 
  def __init__(self, success=None, ucx=None,):
6119 
    self.success = success
6120 
    self.ucx = ucx
6121 
 
6122 
  def read(self, iprot):
6123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6125 
      return
6126 
    iprot.readStructBegin()
6127 
    while True:
6128 
      (fname, ftype, fid) = iprot.readFieldBegin()
6129 
      if ftype == TType.STOP:
6130 
        break
6131 
      if fid == 0:
6132 
        if ftype == TType.BOOL:
6133 
          self.success = iprot.readBool();
6134 
        else:
6135 
          iprot.skip(ftype)
6136 
      elif fid == 1:
6137 
        if ftype == TType.STRUCT:
6138 
          self.ucx = UserContextException()
6139 
          self.ucx.read(iprot)
6140 
        else:
6141 
          iprot.skip(ftype)
6142 
      else:
6143 
        iprot.skip(ftype)
6144 
      iprot.readFieldEnd()
6145 
    iprot.readStructEnd()
6146 
 
6147 
  def write(self, oprot):
6148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6150 
      return
6151 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6152 
    if self.success is not None:
559 chandransh 6153 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6154 
      oprot.writeBool(self.success)
6155 
      oprot.writeFieldEnd()
3431 rajveer 6156 
    if self.ucx is not None:
559 chandransh 6157 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6158 
      self.ucx.write(oprot)
6159 
      oprot.writeFieldEnd()
6160 
    oprot.writeFieldStop()
6161 
    oprot.writeStructEnd()
6162 
 
3431 rajveer 6163 
  def validate(self):
6164 
    return
6165 
 
6166 
 
559 chandransh 6167 
  def __repr__(self):
6168 
    L = ['%s=%r' % (key, value)
6169 
      for key, value in self.__dict__.iteritems()]
6170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6171 
 
6172 
  def __eq__(self, other):
6173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6174 
 
6175 
  def __ne__(self, other):
6176 
    return not (self == other)
6177 
 
6178 
class addAddressForUser_args:
6179 
  """
6180 
  Attributes:
6181 
   - userId
6182 
   - address
6183 
   - setDefault
6184 
  """
6185 
 
6186 
  thrift_spec = (
6187 
    None, # 0
6188 
    (1, TType.I64, 'userId', None, None, ), # 1
6189 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6190 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6191 
  )
6192 
 
567 rajveer 6193 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6194 
    self.userId = userId
6195 
    self.address = address
6196 
    self.setDefault = setDefault
6197 
 
6198 
  def read(self, iprot):
6199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6201 
      return
6202 
    iprot.readStructBegin()
6203 
    while True:
6204 
      (fname, ftype, fid) = iprot.readFieldBegin()
6205 
      if ftype == TType.STOP:
6206 
        break
6207 
      if fid == 1:
6208 
        if ftype == TType.I64:
6209 
          self.userId = iprot.readI64();
6210 
        else:
6211 
          iprot.skip(ftype)
122 ashish 6212 
      elif fid == 2:
559 chandransh 6213 
        if ftype == TType.STRUCT:
6214 
          self.address = Address()
6215 
          self.address.read(iprot)
122 ashish 6216 
        else:
6217 
          iprot.skip(ftype)
6218 
      elif fid == 3:
6219 
        if ftype == TType.BOOL:
559 chandransh 6220 
          self.setDefault = iprot.readBool();
122 ashish 6221 
        else:
6222 
          iprot.skip(ftype)
6223 
      else:
6224 
        iprot.skip(ftype)
6225 
      iprot.readFieldEnd()
6226 
    iprot.readStructEnd()
6227 
 
6228 
  def write(self, oprot):
6229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6231 
      return
559 chandransh 6232 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6233 
    if self.userId is not None:
559 chandransh 6234 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6235 
      oprot.writeI64(self.userId)
122 ashish 6236 
      oprot.writeFieldEnd()
3431 rajveer 6237 
    if self.address is not None:
559 chandransh 6238 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6239 
      self.address.write(oprot)
122 ashish 6240 
      oprot.writeFieldEnd()
3431 rajveer 6241 
    if self.setDefault is not None:
567 rajveer 6242 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6243 
      oprot.writeBool(self.setDefault)
6244 
      oprot.writeFieldEnd()
122 ashish 6245 
    oprot.writeFieldStop()
6246 
    oprot.writeStructEnd()
6247 
 
3431 rajveer 6248 
  def validate(self):
6249 
    return
6250 
 
6251 
 
122 ashish 6252 
  def __repr__(self):
6253 
    L = ['%s=%r' % (key, value)
6254 
      for key, value in self.__dict__.iteritems()]
6255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6256 
 
6257 
  def __eq__(self, other):
6258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6259 
 
6260 
  def __ne__(self, other):
6261 
    return not (self == other)
6262 
 
559 chandransh 6263 
class addAddressForUser_result:
122 ashish 6264 
  """
6265 
  Attributes:
6266 
   - success
559 chandransh 6267 
   - ucx
122 ashish 6268 
  """
6269 
 
6270 
  thrift_spec = (
567 rajveer 6271 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6272 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6273 
  )
6274 
 
559 chandransh 6275 
  def __init__(self, success=None, ucx=None,):
122 ashish 6276 
    self.success = success
559 chandransh 6277 
    self.ucx = ucx
122 ashish 6278 
 
6279 
  def read(self, iprot):
6280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6282 
      return
6283 
    iprot.readStructBegin()
6284 
    while True:
6285 
      (fname, ftype, fid) = iprot.readFieldBegin()
6286 
      if ftype == TType.STOP:
6287 
        break
6288 
      if fid == 0:
567 rajveer 6289 
        if ftype == TType.I64:
6290 
          self.success = iprot.readI64();
122 ashish 6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      elif fid == 1:
6294 
        if ftype == TType.STRUCT:
559 chandransh 6295 
          self.ucx = UserContextException()
6296 
          self.ucx.read(iprot)
122 ashish 6297 
        else:
6298 
          iprot.skip(ftype)
6299 
      else:
6300 
        iprot.skip(ftype)
6301 
      iprot.readFieldEnd()
6302 
    iprot.readStructEnd()
6303 
 
6304 
  def write(self, oprot):
6305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6307 
      return
559 chandransh 6308 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6309 
    if self.success is not None:
567 rajveer 6310 
      oprot.writeFieldBegin('success', TType.I64, 0)
6311 
      oprot.writeI64(self.success)
122 ashish 6312 
      oprot.writeFieldEnd()
3431 rajveer 6313 
    if self.ucx is not None:
559 chandransh 6314 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6315 
      self.ucx.write(oprot)
122 ashish 6316 
      oprot.writeFieldEnd()
6317 
    oprot.writeFieldStop()
6318 
    oprot.writeStructEnd()
6319 
 
3431 rajveer 6320 
  def validate(self):
6321 
    return
6322 
 
6323 
 
122 ashish 6324 
  def __repr__(self):
6325 
    L = ['%s=%r' % (key, value)
6326 
      for key, value in self.__dict__.iteritems()]
6327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6328 
 
6329 
  def __eq__(self, other):
6330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6331 
 
6332 
  def __ne__(self, other):
6333 
    return not (self == other)
6334 
 
559 chandransh 6335 
class removeAddressForUser_args:
94 ashish 6336 
  """
6337 
  Attributes:
559 chandransh 6338 
   - userid
6339 
   - addressId
94 ashish 6340 
  """
6341 
 
6342 
  thrift_spec = (
6343 
    None, # 0
559 chandransh 6344 
    (1, TType.I64, 'userid', None, None, ), # 1
6345 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6346 
  )
6347 
 
559 chandransh 6348 
  def __init__(self, userid=None, addressId=None,):
6349 
    self.userid = userid
6350 
    self.addressId = addressId
94 ashish 6351 
 
6352 
  def read(self, iprot):
6353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6355 
      return
6356 
    iprot.readStructBegin()
6357 
    while True:
6358 
      (fname, ftype, fid) = iprot.readFieldBegin()
6359 
      if ftype == TType.STOP:
6360 
        break
6361 
      if fid == 1:
559 chandransh 6362 
        if ftype == TType.I64:
6363 
          self.userid = iprot.readI64();
94 ashish 6364 
        else:
6365 
          iprot.skip(ftype)
559 chandransh 6366 
      elif fid == 2:
6367 
        if ftype == TType.I64:
6368 
          self.addressId = iprot.readI64();
6369 
        else:
6370 
          iprot.skip(ftype)
94 ashish 6371 
      else:
6372 
        iprot.skip(ftype)
6373 
      iprot.readFieldEnd()
6374 
    iprot.readStructEnd()
6375 
 
6376 
  def write(self, oprot):
6377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6379 
      return
559 chandransh 6380 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6381 
    if self.userid is not None:
559 chandransh 6382 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6383 
      oprot.writeI64(self.userid)
94 ashish 6384 
      oprot.writeFieldEnd()
3431 rajveer 6385 
    if self.addressId is not None:
559 chandransh 6386 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6387 
      oprot.writeI64(self.addressId)
6388 
      oprot.writeFieldEnd()
94 ashish 6389 
    oprot.writeFieldStop()
6390 
    oprot.writeStructEnd()
6391 
 
3431 rajveer 6392 
  def validate(self):
6393 
    return
6394 
 
6395 
 
94 ashish 6396 
  def __repr__(self):
6397 
    L = ['%s=%r' % (key, value)
6398 
      for key, value in self.__dict__.iteritems()]
6399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6400 
 
6401 
  def __eq__(self, other):
6402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6403 
 
6404 
  def __ne__(self, other):
6405 
    return not (self == other)
6406 
 
559 chandransh 6407 
class removeAddressForUser_result:
94 ashish 6408 
  """
6409 
  Attributes:
6410 
   - success
6411 
   - ucx
6412 
  """
6413 
 
6414 
  thrift_spec = (
6415 
    (0, TType.BOOL, 'success', None, None, ), # 0
6416 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6417 
  )
6418 
 
6419 
  def __init__(self, success=None, ucx=None,):
6420 
    self.success = success
6421 
    self.ucx = ucx
6422 
 
6423 
  def read(self, iprot):
6424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6426 
      return
6427 
    iprot.readStructBegin()
6428 
    while True:
6429 
      (fname, ftype, fid) = iprot.readFieldBegin()
6430 
      if ftype == TType.STOP:
6431 
        break
6432 
      if fid == 0:
6433 
        if ftype == TType.BOOL:
6434 
          self.success = iprot.readBool();
6435 
        else:
6436 
          iprot.skip(ftype)
6437 
      elif fid == 1:
6438 
        if ftype == TType.STRUCT:
6439 
          self.ucx = UserContextException()
6440 
          self.ucx.read(iprot)
6441 
        else:
6442 
          iprot.skip(ftype)
6443 
      else:
6444 
        iprot.skip(ftype)
6445 
      iprot.readFieldEnd()
6446 
    iprot.readStructEnd()
6447 
 
6448 
  def write(self, oprot):
6449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6451 
      return
559 chandransh 6452 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6453 
    if self.success is not None:
94 ashish 6454 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6455 
      oprot.writeBool(self.success)
6456 
      oprot.writeFieldEnd()
3431 rajveer 6457 
    if self.ucx is not None:
94 ashish 6458 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6459 
      self.ucx.write(oprot)
6460 
      oprot.writeFieldEnd()
6461 
    oprot.writeFieldStop()
6462 
    oprot.writeStructEnd()
6463 
 
3431 rajveer 6464 
  def validate(self):
6465 
    return
6466 
 
6467 
 
94 ashish 6468 
  def __repr__(self):
6469 
    L = ['%s=%r' % (key, value)
6470 
      for key, value in self.__dict__.iteritems()]
6471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6472 
 
6473 
  def __eq__(self, other):
6474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6475 
 
6476 
  def __ne__(self, other):
6477 
    return not (self == other)
6478 
 
559 chandransh 6479 
class setUserAsLoggedIn_args:
94 ashish 6480 
  """
6481 
  Attributes:
559 chandransh 6482 
   - userId
94 ashish 6483 
   - timestamp
6484 
  """
6485 
 
6486 
  thrift_spec = (
6487 
    None, # 0
559 chandransh 6488 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6489 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6490 
  )
6491 
 
559 chandransh 6492 
  def __init__(self, userId=None, timestamp=None,):
6493 
    self.userId = userId
94 ashish 6494 
    self.timestamp = timestamp
6495 
 
6496 
  def read(self, iprot):
6497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6499 
      return
6500 
    iprot.readStructBegin()
6501 
    while True:
6502 
      (fname, ftype, fid) = iprot.readFieldBegin()
6503 
      if ftype == TType.STOP:
6504 
        break
6505 
      if fid == 1:
559 chandransh 6506 
        if ftype == TType.I64:
6507 
          self.userId = iprot.readI64();
94 ashish 6508 
        else:
6509 
          iprot.skip(ftype)
6510 
      elif fid == 2:
6511 
        if ftype == TType.I64:
6512 
          self.timestamp = iprot.readI64();
6513 
        else:
6514 
          iprot.skip(ftype)
6515 
      else:
6516 
        iprot.skip(ftype)
6517 
      iprot.readFieldEnd()
6518 
    iprot.readStructEnd()
6519 
 
6520 
  def write(self, oprot):
6521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6523 
      return
559 chandransh 6524 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6525 
    if self.userId is not None:
559 chandransh 6526 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6527 
      oprot.writeI64(self.userId)
94 ashish 6528 
      oprot.writeFieldEnd()
3431 rajveer 6529 
    if self.timestamp is not None:
94 ashish 6530 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6531 
      oprot.writeI64(self.timestamp)
6532 
      oprot.writeFieldEnd()
6533 
    oprot.writeFieldStop()
6534 
    oprot.writeStructEnd()
6535 
 
3431 rajveer 6536 
  def validate(self):
6537 
    return
6538 
 
6539 
 
94 ashish 6540 
  def __repr__(self):
6541 
    L = ['%s=%r' % (key, value)
6542 
      for key, value in self.__dict__.iteritems()]
6543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6544 
 
6545 
  def __eq__(self, other):
6546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6547 
 
6548 
  def __ne__(self, other):
6549 
    return not (self == other)
6550 
 
559 chandransh 6551 
class setUserAsLoggedIn_result:
94 ashish 6552 
  """
6553 
  Attributes:
6554 
   - success
6555 
   - ucx
6556 
  """
6557 
 
6558 
  thrift_spec = (
6559 
    (0, TType.BOOL, 'success', None, None, ), # 0
6560 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6561 
  )
6562 
 
6563 
  def __init__(self, success=None, ucx=None,):
6564 
    self.success = success
6565 
    self.ucx = ucx
6566 
 
6567 
  def read(self, iprot):
6568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6570 
      return
6571 
    iprot.readStructBegin()
6572 
    while True:
6573 
      (fname, ftype, fid) = iprot.readFieldBegin()
6574 
      if ftype == TType.STOP:
6575 
        break
6576 
      if fid == 0:
6577 
        if ftype == TType.BOOL:
6578 
          self.success = iprot.readBool();
6579 
        else:
6580 
          iprot.skip(ftype)
6581 
      elif fid == 1:
6582 
        if ftype == TType.STRUCT:
6583 
          self.ucx = UserContextException()
6584 
          self.ucx.read(iprot)
6585 
        else:
6586 
          iprot.skip(ftype)
6587 
      else:
6588 
        iprot.skip(ftype)
6589 
      iprot.readFieldEnd()
6590 
    iprot.readStructEnd()
6591 
 
6592 
  def write(self, oprot):
6593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6595 
      return
559 chandransh 6596 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6597 
    if self.success is not None:
94 ashish 6598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6599 
      oprot.writeBool(self.success)
6600 
      oprot.writeFieldEnd()
3431 rajveer 6601 
    if self.ucx is not None:
94 ashish 6602 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6603 
      self.ucx.write(oprot)
6604 
      oprot.writeFieldEnd()
6605 
    oprot.writeFieldStop()
6606 
    oprot.writeStructEnd()
6607 
 
3431 rajveer 6608 
  def validate(self):
6609 
    return
6610 
 
6611 
 
94 ashish 6612 
  def __repr__(self):
6613 
    L = ['%s=%r' % (key, value)
6614 
      for key, value in self.__dict__.iteritems()]
6615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6616 
 
6617 
  def __eq__(self, other):
6618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6619 
 
6620 
  def __ne__(self, other):
6621 
    return not (self == other)
6622 
 
559 chandransh 6623 
class setUserAsLoggedOut_args:
94 ashish 6624 
  """
6625 
  Attributes:
6626 
   - userid
6627 
   - timestamp
6628 
  """
6629 
 
6630 
  thrift_spec = (
6631 
    None, # 0
559 chandransh 6632 
    (1, TType.I64, 'userid', None, None, ), # 1
6633 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6634 
  )
6635 
 
559 chandransh 6636 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6637 
    self.userid = userid
6638 
    self.timestamp = timestamp
6639 
 
6640 
  def read(self, iprot):
6641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6643 
      return
6644 
    iprot.readStructBegin()
6645 
    while True:
6646 
      (fname, ftype, fid) = iprot.readFieldBegin()
6647 
      if ftype == TType.STOP:
6648 
        break
6649 
      if fid == 1:
6650 
        if ftype == TType.I64:
6651 
          self.userid = iprot.readI64();
6652 
        else:
6653 
          iprot.skip(ftype)
559 chandransh 6654 
      elif fid == 2:
94 ashish 6655 
        if ftype == TType.I64:
6656 
          self.timestamp = iprot.readI64();
6657 
        else:
6658 
          iprot.skip(ftype)
6659 
      else:
6660 
        iprot.skip(ftype)
6661 
      iprot.readFieldEnd()
6662 
    iprot.readStructEnd()
6663 
 
6664 
  def write(self, oprot):
6665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6667 
      return
559 chandransh 6668 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6669 
    if self.userid is not None:
559 chandransh 6670 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6671 
      oprot.writeI64(self.userid)
6672 
      oprot.writeFieldEnd()
3431 rajveer 6673 
    if self.timestamp is not None:
559 chandransh 6674 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6675 
      oprot.writeI64(self.timestamp)
6676 
      oprot.writeFieldEnd()
6677 
    oprot.writeFieldStop()
6678 
    oprot.writeStructEnd()
6679 
 
3431 rajveer 6680 
  def validate(self):
6681 
    return
6682 
 
6683 
 
94 ashish 6684 
  def __repr__(self):
6685 
    L = ['%s=%r' % (key, value)
6686 
      for key, value in self.__dict__.iteritems()]
6687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6688 
 
6689 
  def __eq__(self, other):
6690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6691 
 
6692 
  def __ne__(self, other):
6693 
    return not (self == other)
6694 
 
559 chandransh 6695 
class setUserAsLoggedOut_result:
94 ashish 6696 
  """
6697 
  Attributes:
6698 
   - success
6699 
   - ucx
6700 
  """
6701 
 
6702 
  thrift_spec = (
6703 
    (0, TType.BOOL, 'success', None, None, ), # 0
6704 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6705 
  )
6706 
 
6707 
  def __init__(self, success=None, ucx=None,):
6708 
    self.success = success
6709 
    self.ucx = ucx
6710 
 
6711 
  def read(self, iprot):
6712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6714 
      return
6715 
    iprot.readStructBegin()
6716 
    while True:
6717 
      (fname, ftype, fid) = iprot.readFieldBegin()
6718 
      if ftype == TType.STOP:
6719 
        break
6720 
      if fid == 0:
6721 
        if ftype == TType.BOOL:
6722 
          self.success = iprot.readBool();
6723 
        else:
6724 
          iprot.skip(ftype)
6725 
      elif fid == 1:
6726 
        if ftype == TType.STRUCT:
6727 
          self.ucx = UserContextException()
6728 
          self.ucx.read(iprot)
6729 
        else:
6730 
          iprot.skip(ftype)
6731 
      else:
6732 
        iprot.skip(ftype)
6733 
      iprot.readFieldEnd()
6734 
    iprot.readStructEnd()
6735 
 
6736 
  def write(self, oprot):
6737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6739 
      return
559 chandransh 6740 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6741 
    if self.success is not None:
94 ashish 6742 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6743 
      oprot.writeBool(self.success)
6744 
      oprot.writeFieldEnd()
3431 rajveer 6745 
    if self.ucx is not None:
94 ashish 6746 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6747 
      self.ucx.write(oprot)
6748 
      oprot.writeFieldEnd()
6749 
    oprot.writeFieldStop()
6750 
    oprot.writeStructEnd()
6751 
 
3431 rajveer 6752 
  def validate(self):
6753 
    return
6754 
 
6755 
 
94 ashish 6756 
  def __repr__(self):
6757 
    L = ['%s=%r' % (key, value)
6758 
      for key, value in self.__dict__.iteritems()]
6759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6760 
 
6761 
  def __eq__(self, other):
6762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6763 
 
6764 
  def __ne__(self, other):
6765 
    return not (self == other)
6766 
 
559 chandransh 6767 
class setDefaultAddress_args:
94 ashish 6768 
  """
6769 
  Attributes:
6770 
   - userid
6771 
   - addressId
6772 
  """
6773 
 
6774 
  thrift_spec = (
6775 
    None, # 0
6776 
    (1, TType.I64, 'userid', None, None, ), # 1
6777 
    (2, TType.I64, 'addressId', None, None, ), # 2
6778 
  )
6779 
 
6780 
  def __init__(self, userid=None, addressId=None,):
6781 
    self.userid = userid
6782 
    self.addressId = addressId
6783 
 
6784 
  def read(self, iprot):
6785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6787 
      return
6788 
    iprot.readStructBegin()
6789 
    while True:
6790 
      (fname, ftype, fid) = iprot.readFieldBegin()
6791 
      if ftype == TType.STOP:
6792 
        break
6793 
      if fid == 1:
6794 
        if ftype == TType.I64:
6795 
          self.userid = iprot.readI64();
6796 
        else:
6797 
          iprot.skip(ftype)
6798 
      elif fid == 2:
6799 
        if ftype == TType.I64:
6800 
          self.addressId = iprot.readI64();
6801 
        else:
6802 
          iprot.skip(ftype)
6803 
      else:
6804 
        iprot.skip(ftype)
6805 
      iprot.readFieldEnd()
6806 
    iprot.readStructEnd()
6807 
 
6808 
  def write(self, oprot):
6809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6811 
      return
559 chandransh 6812 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6813 
    if self.userid is not None:
94 ashish 6814 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6815 
      oprot.writeI64(self.userid)
6816 
      oprot.writeFieldEnd()
3431 rajveer 6817 
    if self.addressId is not None:
94 ashish 6818 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6819 
      oprot.writeI64(self.addressId)
6820 
      oprot.writeFieldEnd()
6821 
    oprot.writeFieldStop()
6822 
    oprot.writeStructEnd()
6823 
 
3431 rajveer 6824 
  def validate(self):
6825 
    return
6826 
 
6827 
 
94 ashish 6828 
  def __repr__(self):
6829 
    L = ['%s=%r' % (key, value)
6830 
      for key, value in self.__dict__.iteritems()]
6831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6832 
 
6833 
  def __eq__(self, other):
6834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6835 
 
6836 
  def __ne__(self, other):
6837 
    return not (self == other)
6838 
 
559 chandransh 6839 
class setDefaultAddress_result:
94 ashish 6840 
  """
6841 
  Attributes:
6842 
   - success
6843 
   - ucx
6844 
  """
6845 
 
6846 
  thrift_spec = (
6847 
    (0, TType.BOOL, 'success', None, None, ), # 0
6848 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6849 
  )
6850 
 
6851 
  def __init__(self, success=None, ucx=None,):
6852 
    self.success = success
6853 
    self.ucx = ucx
6854 
 
6855 
  def read(self, iprot):
6856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6858 
      return
6859 
    iprot.readStructBegin()
6860 
    while True:
6861 
      (fname, ftype, fid) = iprot.readFieldBegin()
6862 
      if ftype == TType.STOP:
6863 
        break
6864 
      if fid == 0:
6865 
        if ftype == TType.BOOL:
6866 
          self.success = iprot.readBool();
6867 
        else:
6868 
          iprot.skip(ftype)
6869 
      elif fid == 1:
6870 
        if ftype == TType.STRUCT:
6871 
          self.ucx = UserContextException()
6872 
          self.ucx.read(iprot)
6873 
        else:
6874 
          iprot.skip(ftype)
6875 
      else:
6876 
        iprot.skip(ftype)
6877 
      iprot.readFieldEnd()
6878 
    iprot.readStructEnd()
6879 
 
6880 
  def write(self, oprot):
6881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6883 
      return
559 chandransh 6884 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6885 
    if self.success is not None:
94 ashish 6886 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6887 
      oprot.writeBool(self.success)
6888 
      oprot.writeFieldEnd()
3431 rajveer 6889 
    if self.ucx is not None:
94 ashish 6890 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6891 
      self.ucx.write(oprot)
6892 
      oprot.writeFieldEnd()
6893 
    oprot.writeFieldStop()
6894 
    oprot.writeStructEnd()
6895 
 
3431 rajveer 6896 
  def validate(self):
6897 
    return
6898 
 
6899 
 
94 ashish 6900 
  def __repr__(self):
6901 
    L = ['%s=%r' % (key, value)
6902 
      for key, value in self.__dict__.iteritems()]
6903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6904 
 
6905 
  def __eq__(self, other):
6906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6907 
 
6908 
  def __ne__(self, other):
6909 
    return not (self == other)
6910 
 
559 chandransh 6911 
class updatePassword_args:
94 ashish 6912 
  """
6913 
  Attributes:
559 chandransh 6914 
   - userid
594 rajveer 6915 
   - oldPassword
6916 
   - newPassword
94 ashish 6917 
  """
6918 
 
6919 
  thrift_spec = (
6920 
    None, # 0
559 chandransh 6921 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6922 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6923 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6924 
  )
6925 
 
594 rajveer 6926 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6927 
    self.userid = userid
594 rajveer 6928 
    self.oldPassword = oldPassword
6929 
    self.newPassword = newPassword
94 ashish 6930 
 
6931 
  def read(self, iprot):
6932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6934 
      return
6935 
    iprot.readStructBegin()
6936 
    while True:
6937 
      (fname, ftype, fid) = iprot.readFieldBegin()
6938 
      if ftype == TType.STOP:
6939 
        break
6940 
      if fid == 1:
6941 
        if ftype == TType.I64:
559 chandransh 6942 
          self.userid = iprot.readI64();
94 ashish 6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      elif fid == 2:
559 chandransh 6946 
        if ftype == TType.STRING:
594 rajveer 6947 
          self.oldPassword = iprot.readString();
94 ashish 6948 
        else:
6949 
          iprot.skip(ftype)
594 rajveer 6950 
      elif fid == 3:
6951 
        if ftype == TType.STRING:
6952 
          self.newPassword = iprot.readString();
6953 
        else:
6954 
          iprot.skip(ftype)
94 ashish 6955 
      else:
6956 
        iprot.skip(ftype)
6957 
      iprot.readFieldEnd()
6958 
    iprot.readStructEnd()
6959 
 
6960 
  def write(self, oprot):
6961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6963 
      return
559 chandransh 6964 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6965 
    if self.userid is not None:
559 chandransh 6966 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6967 
      oprot.writeI64(self.userid)
94 ashish 6968 
      oprot.writeFieldEnd()
3431 rajveer 6969 
    if self.oldPassword is not None:
594 rajveer 6970 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6971 
      oprot.writeString(self.oldPassword)
94 ashish 6972 
      oprot.writeFieldEnd()
3431 rajveer 6973 
    if self.newPassword is not None:
594 rajveer 6974 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6975 
      oprot.writeString(self.newPassword)
6976 
      oprot.writeFieldEnd()
94 ashish 6977 
    oprot.writeFieldStop()
6978 
    oprot.writeStructEnd()
6979 
 
3431 rajveer 6980 
  def validate(self):
6981 
    return
6982 
 
6983 
 
94 ashish 6984 
  def __repr__(self):
6985 
    L = ['%s=%r' % (key, value)
6986 
      for key, value in self.__dict__.iteritems()]
6987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6988 
 
6989 
  def __eq__(self, other):
6990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6991 
 
6992 
  def __ne__(self, other):
6993 
    return not (self == other)
6994 
 
559 chandransh 6995 
class updatePassword_result:
94 ashish 6996 
  """
6997 
  Attributes:
6998 
   - success
6999 
   - ucx
7000 
  """
7001 
 
7002 
  thrift_spec = (
7003 
    (0, TType.BOOL, 'success', None, None, ), # 0
7004 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7005 
  )
7006 
 
7007 
  def __init__(self, success=None, ucx=None,):
7008 
    self.success = success
7009 
    self.ucx = ucx
7010 
 
7011 
  def read(self, iprot):
7012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7014 
      return
7015 
    iprot.readStructBegin()
7016 
    while True:
7017 
      (fname, ftype, fid) = iprot.readFieldBegin()
7018 
      if ftype == TType.STOP:
7019 
        break
7020 
      if fid == 0:
7021 
        if ftype == TType.BOOL:
7022 
          self.success = iprot.readBool();
7023 
        else:
7024 
          iprot.skip(ftype)
7025 
      elif fid == 1:
7026 
        if ftype == TType.STRUCT:
7027 
          self.ucx = UserContextException()
7028 
          self.ucx.read(iprot)
7029 
        else:
7030 
          iprot.skip(ftype)
7031 
      else:
7032 
        iprot.skip(ftype)
7033 
      iprot.readFieldEnd()
7034 
    iprot.readStructEnd()
7035 
 
7036 
  def write(self, oprot):
7037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7039 
      return
559 chandransh 7040 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7041 
    if self.success is not None:
94 ashish 7042 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7043 
      oprot.writeBool(self.success)
7044 
      oprot.writeFieldEnd()
3431 rajveer 7045 
    if self.ucx is not None:
94 ashish 7046 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7047 
      self.ucx.write(oprot)
7048 
      oprot.writeFieldEnd()
7049 
    oprot.writeFieldStop()
7050 
    oprot.writeStructEnd()
7051 
 
3431 rajveer 7052 
  def validate(self):
7053 
    return
7054 
 
7055 
 
94 ashish 7056 
  def __repr__(self):
7057 
    L = ['%s=%r' % (key, value)
7058 
      for key, value in self.__dict__.iteritems()]
7059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7060 
 
7061 
  def __eq__(self, other):
7062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7063 
 
7064 
  def __ne__(self, other):
7065 
    return not (self == other)
7066 
 
581 rajveer 7067 
class forgotPassword_args:
7068 
  """
7069 
  Attributes:
7070 
   - email
884 rajveer 7071 
   - newPassword
581 rajveer 7072 
  """
7073 
 
7074 
  thrift_spec = (
7075 
    None, # 0
7076 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7077 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7078 
  )
7079 
 
884 rajveer 7080 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7081 
    self.email = email
884 rajveer 7082 
    self.newPassword = newPassword
581 rajveer 7083 
 
7084 
  def read(self, iprot):
7085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7087 
      return
7088 
    iprot.readStructBegin()
7089 
    while True:
7090 
      (fname, ftype, fid) = iprot.readFieldBegin()
7091 
      if ftype == TType.STOP:
7092 
        break
7093 
      if fid == 1:
7094 
        if ftype == TType.STRING:
7095 
          self.email = iprot.readString();
7096 
        else:
7097 
          iprot.skip(ftype)
884 rajveer 7098 
      elif fid == 2:
7099 
        if ftype == TType.STRING:
7100 
          self.newPassword = iprot.readString();
7101 
        else:
7102 
          iprot.skip(ftype)
581 rajveer 7103 
      else:
7104 
        iprot.skip(ftype)
7105 
      iprot.readFieldEnd()
7106 
    iprot.readStructEnd()
7107 
 
7108 
  def write(self, oprot):
7109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7111 
      return
7112 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7113 
    if self.email is not None:
581 rajveer 7114 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7115 
      oprot.writeString(self.email)
7116 
      oprot.writeFieldEnd()
3431 rajveer 7117 
    if self.newPassword is not None:
884 rajveer 7118 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7119 
      oprot.writeString(self.newPassword)
7120 
      oprot.writeFieldEnd()
581 rajveer 7121 
    oprot.writeFieldStop()
7122 
    oprot.writeStructEnd()
7123 
 
3431 rajveer 7124 
  def validate(self):
7125 
    return
7126 
 
7127 
 
581 rajveer 7128 
  def __repr__(self):
7129 
    L = ['%s=%r' % (key, value)
7130 
      for key, value in self.__dict__.iteritems()]
7131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7132 
 
7133 
  def __eq__(self, other):
7134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7135 
 
7136 
  def __ne__(self, other):
7137 
    return not (self == other)
7138 
 
7139 
class forgotPassword_result:
7140 
  """
7141 
  Attributes:
7142 
   - success
7143 
   - ucx
7144 
  """
7145 
 
7146 
  thrift_spec = (
7147 
    (0, TType.BOOL, 'success', None, None, ), # 0
7148 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7149 
  )
7150 
 
7151 
  def __init__(self, success=None, ucx=None,):
7152 
    self.success = success
7153 
    self.ucx = ucx
7154 
 
7155 
  def read(self, iprot):
7156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7158 
      return
7159 
    iprot.readStructBegin()
7160 
    while True:
7161 
      (fname, ftype, fid) = iprot.readFieldBegin()
7162 
      if ftype == TType.STOP:
7163 
        break
7164 
      if fid == 0:
7165 
        if ftype == TType.BOOL:
7166 
          self.success = iprot.readBool();
7167 
        else:
7168 
          iprot.skip(ftype)
7169 
      elif fid == 1:
7170 
        if ftype == TType.STRUCT:
7171 
          self.ucx = UserContextException()
7172 
          self.ucx.read(iprot)
7173 
        else:
7174 
          iprot.skip(ftype)
7175 
      else:
7176 
        iprot.skip(ftype)
7177 
      iprot.readFieldEnd()
7178 
    iprot.readStructEnd()
7179 
 
7180 
  def write(self, oprot):
7181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7183 
      return
7184 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7185 
    if self.success is not None:
581 rajveer 7186 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7187 
      oprot.writeBool(self.success)
7188 
      oprot.writeFieldEnd()
3431 rajveer 7189 
    if self.ucx is not None:
581 rajveer 7190 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7191 
      self.ucx.write(oprot)
7192 
      oprot.writeFieldEnd()
7193 
    oprot.writeFieldStop()
7194 
    oprot.writeStructEnd()
7195 
 
3431 rajveer 7196 
  def validate(self):
7197 
    return
7198 
 
7199 
 
581 rajveer 7200 
  def __repr__(self):
7201 
    L = ['%s=%r' % (key, value)
7202 
      for key, value in self.__dict__.iteritems()]
7203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7204 
 
7205 
  def __eq__(self, other):
7206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7207 
 
7208 
  def __ne__(self, other):
7209 
    return not (self == other)
7210 
 
594 rajveer 7211 
class getAllAddressesForUser_args:
7212 
  """
7213 
  Attributes:
7214 
   - userId
7215 
  """
7216 
 
7217 
  thrift_spec = (
7218 
    None, # 0
7219 
    (1, TType.I64, 'userId', None, None, ), # 1
7220 
  )
7221 
 
7222 
  def __init__(self, userId=None,):
7223 
    self.userId = userId
7224 
 
7225 
  def read(self, iprot):
7226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7228 
      return
7229 
    iprot.readStructBegin()
7230 
    while True:
7231 
      (fname, ftype, fid) = iprot.readFieldBegin()
7232 
      if ftype == TType.STOP:
7233 
        break
7234 
      if fid == 1:
7235 
        if ftype == TType.I64:
7236 
          self.userId = iprot.readI64();
7237 
        else:
7238 
          iprot.skip(ftype)
7239 
      else:
7240 
        iprot.skip(ftype)
7241 
      iprot.readFieldEnd()
7242 
    iprot.readStructEnd()
7243 
 
7244 
  def write(self, oprot):
7245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7247 
      return
7248 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7249 
    if self.userId is not None:
594 rajveer 7250 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7251 
      oprot.writeI64(self.userId)
7252 
      oprot.writeFieldEnd()
7253 
    oprot.writeFieldStop()
7254 
    oprot.writeStructEnd()
7255 
 
3431 rajveer 7256 
  def validate(self):
7257 
    return
7258 
 
7259 
 
594 rajveer 7260 
  def __repr__(self):
7261 
    L = ['%s=%r' % (key, value)
7262 
      for key, value in self.__dict__.iteritems()]
7263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7264 
 
7265 
  def __eq__(self, other):
7266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7267 
 
7268 
  def __ne__(self, other):
7269 
    return not (self == other)
7270 
 
7271 
class getAllAddressesForUser_result:
7272 
  """
7273 
  Attributes:
7274 
   - success
7275 
   - ucx
7276 
  """
7277 
 
7278 
  thrift_spec = (
7279 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7280 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7281 
  )
7282 
 
7283 
  def __init__(self, success=None, ucx=None,):
7284 
    self.success = success
7285 
    self.ucx = ucx
7286 
 
7287 
  def read(self, iprot):
7288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7290 
      return
7291 
    iprot.readStructBegin()
7292 
    while True:
7293 
      (fname, ftype, fid) = iprot.readFieldBegin()
7294 
      if ftype == TType.STOP:
7295 
        break
7296 
      if fid == 0:
7297 
        if ftype == TType.LIST:
7298 
          self.success = []
11592 amit.gupta 7299 
          (_etype100, _size97) = iprot.readListBegin()
7300 
          for _i101 in xrange(_size97):
7301 
            _elem102 = Address()
7302 
            _elem102.read(iprot)
7303 
            self.success.append(_elem102)
594 rajveer 7304 
          iprot.readListEnd()
7305 
        else:
7306 
          iprot.skip(ftype)
7307 
      elif fid == 1:
7308 
        if ftype == TType.STRUCT:
7309 
          self.ucx = UserContextException()
7310 
          self.ucx.read(iprot)
7311 
        else:
7312 
          iprot.skip(ftype)
7313 
      else:
7314 
        iprot.skip(ftype)
7315 
      iprot.readFieldEnd()
7316 
    iprot.readStructEnd()
7317 
 
7318 
  def write(self, oprot):
7319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7321 
      return
7322 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7323 
    if self.success is not None:
594 rajveer 7324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7326 
      for iter103 in self.success:
7327 
        iter103.write(oprot)
594 rajveer 7328 
      oprot.writeListEnd()
7329 
      oprot.writeFieldEnd()
3431 rajveer 7330 
    if self.ucx is not None:
594 rajveer 7331 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7332 
      self.ucx.write(oprot)
7333 
      oprot.writeFieldEnd()
7334 
    oprot.writeFieldStop()
7335 
    oprot.writeStructEnd()
7336 
 
3431 rajveer 7337 
  def validate(self):
7338 
    return
7339 
 
7340 
 
594 rajveer 7341 
  def __repr__(self):
7342 
    L = ['%s=%r' % (key, value)
7343 
      for key, value in self.__dict__.iteritems()]
7344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7345 
 
7346 
  def __eq__(self, other):
7347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7348 
 
7349 
  def __ne__(self, other):
7350 
    return not (self == other)
7351 
 
1894 vikas 7352 
class getAddressById_args:
7353 
  """
7354 
  Attributes:
7355 
   - addressId
7356 
  """
7357 
 
7358 
  thrift_spec = (
7359 
    None, # 0
7360 
    (1, TType.I64, 'addressId', None, None, ), # 1
7361 
  )
7362 
 
7363 
  def __init__(self, addressId=None,):
7364 
    self.addressId = addressId
7365 
 
7366 
  def read(self, iprot):
7367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7369 
      return
7370 
    iprot.readStructBegin()
7371 
    while True:
7372 
      (fname, ftype, fid) = iprot.readFieldBegin()
7373 
      if ftype == TType.STOP:
7374 
        break
7375 
      if fid == 1:
7376 
        if ftype == TType.I64:
7377 
          self.addressId = iprot.readI64();
7378 
        else:
7379 
          iprot.skip(ftype)
7380 
      else:
7381 
        iprot.skip(ftype)
7382 
      iprot.readFieldEnd()
7383 
    iprot.readStructEnd()
7384 
 
7385 
  def write(self, oprot):
7386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7388 
      return
7389 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7390 
    if self.addressId is not None:
1894 vikas 7391 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7392 
      oprot.writeI64(self.addressId)
7393 
      oprot.writeFieldEnd()
7394 
    oprot.writeFieldStop()
7395 
    oprot.writeStructEnd()
7396 
 
3431 rajveer 7397 
  def validate(self):
7398 
    return
7399 
 
7400 
 
1894 vikas 7401 
  def __repr__(self):
7402 
    L = ['%s=%r' % (key, value)
7403 
      for key, value in self.__dict__.iteritems()]
7404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7405 
 
7406 
  def __eq__(self, other):
7407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7408 
 
7409 
  def __ne__(self, other):
7410 
    return not (self == other)
7411 
 
7412 
class getAddressById_result:
7413 
  """
7414 
  Attributes:
7415 
   - success
7416 
   - ucx
7417 
  """
7418 
 
7419 
  thrift_spec = (
7420 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7421 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7422 
  )
7423 
 
7424 
  def __init__(self, success=None, ucx=None,):
7425 
    self.success = success
7426 
    self.ucx = ucx
7427 
 
7428 
  def read(self, iprot):
7429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7431 
      return
7432 
    iprot.readStructBegin()
7433 
    while True:
7434 
      (fname, ftype, fid) = iprot.readFieldBegin()
7435 
      if ftype == TType.STOP:
7436 
        break
7437 
      if fid == 0:
7438 
        if ftype == TType.STRUCT:
7439 
          self.success = Address()
7440 
          self.success.read(iprot)
7441 
        else:
7442 
          iprot.skip(ftype)
7443 
      elif fid == 1:
7444 
        if ftype == TType.STRUCT:
7445 
          self.ucx = UserContextException()
7446 
          self.ucx.read(iprot)
7447 
        else:
7448 
          iprot.skip(ftype)
7449 
      else:
7450 
        iprot.skip(ftype)
7451 
      iprot.readFieldEnd()
7452 
    iprot.readStructEnd()
7453 
 
7454 
  def write(self, oprot):
7455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7457 
      return
7458 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7459 
    if self.success is not None:
1894 vikas 7460 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7461 
      self.success.write(oprot)
7462 
      oprot.writeFieldEnd()
3431 rajveer 7463 
    if self.ucx is not None:
1894 vikas 7464 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7465 
      self.ucx.write(oprot)
7466 
      oprot.writeFieldEnd()
7467 
    oprot.writeFieldStop()
7468 
    oprot.writeStructEnd()
7469 
 
3431 rajveer 7470 
  def validate(self):
7471 
    return
7472 
 
7473 
 
1894 vikas 7474 
  def __repr__(self):
7475 
    L = ['%s=%r' % (key, value)
7476 
      for key, value in self.__dict__.iteritems()]
7477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7478 
 
7479 
  def __eq__(self, other):
7480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7481 
 
7482 
  def __ne__(self, other):
7483 
    return not (self == other)
7484 
 
594 rajveer 7485 
class getDefaultAddressId_args:
7486 
  """
7487 
  Attributes:
7488 
   - userId
7489 
  """
7490 
 
7491 
  thrift_spec = (
7492 
    None, # 0
7493 
    (1, TType.I64, 'userId', None, None, ), # 1
7494 
  )
7495 
 
7496 
  def __init__(self, userId=None,):
7497 
    self.userId = userId
7498 
 
7499 
  def read(self, iprot):
7500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7502 
      return
7503 
    iprot.readStructBegin()
7504 
    while True:
7505 
      (fname, ftype, fid) = iprot.readFieldBegin()
7506 
      if ftype == TType.STOP:
7507 
        break
7508 
      if fid == 1:
7509 
        if ftype == TType.I64:
7510 
          self.userId = iprot.readI64();
7511 
        else:
7512 
          iprot.skip(ftype)
7513 
      else:
7514 
        iprot.skip(ftype)
7515 
      iprot.readFieldEnd()
7516 
    iprot.readStructEnd()
7517 
 
7518 
  def write(self, oprot):
7519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7521 
      return
7522 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7523 
    if self.userId is not None:
594 rajveer 7524 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7525 
      oprot.writeI64(self.userId)
7526 
      oprot.writeFieldEnd()
7527 
    oprot.writeFieldStop()
7528 
    oprot.writeStructEnd()
7529 
 
3431 rajveer 7530 
  def validate(self):
7531 
    return
7532 
 
7533 
 
594 rajveer 7534 
  def __repr__(self):
7535 
    L = ['%s=%r' % (key, value)
7536 
      for key, value in self.__dict__.iteritems()]
7537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7538 
 
7539 
  def __eq__(self, other):
7540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7541 
 
7542 
  def __ne__(self, other):
7543 
    return not (self == other)
7544 
 
7545 
class getDefaultAddressId_result:
7546 
  """
7547 
  Attributes:
7548 
   - success
7549 
   - ucx
7550 
  """
7551 
 
7552 
  thrift_spec = (
7553 
    (0, TType.I64, 'success', None, None, ), # 0
7554 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7555 
  )
7556 
 
7557 
  def __init__(self, success=None, ucx=None,):
7558 
    self.success = success
7559 
    self.ucx = ucx
7560 
 
7561 
  def read(self, iprot):
7562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7564 
      return
7565 
    iprot.readStructBegin()
7566 
    while True:
7567 
      (fname, ftype, fid) = iprot.readFieldBegin()
7568 
      if ftype == TType.STOP:
7569 
        break
7570 
      if fid == 0:
7571 
        if ftype == TType.I64:
7572 
          self.success = iprot.readI64();
7573 
        else:
7574 
          iprot.skip(ftype)
7575 
      elif fid == 1:
7576 
        if ftype == TType.STRUCT:
7577 
          self.ucx = UserContextException()
7578 
          self.ucx.read(iprot)
7579 
        else:
7580 
          iprot.skip(ftype)
7581 
      else:
7582 
        iprot.skip(ftype)
7583 
      iprot.readFieldEnd()
7584 
    iprot.readStructEnd()
7585 
 
7586 
  def write(self, oprot):
7587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7589 
      return
7590 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7591 
    if self.success is not None:
594 rajveer 7592 
      oprot.writeFieldBegin('success', TType.I64, 0)
7593 
      oprot.writeI64(self.success)
7594 
      oprot.writeFieldEnd()
3431 rajveer 7595 
    if self.ucx is not None:
594 rajveer 7596 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7597 
      self.ucx.write(oprot)
7598 
      oprot.writeFieldEnd()
7599 
    oprot.writeFieldStop()
7600 
    oprot.writeStructEnd()
7601 
 
3431 rajveer 7602 
  def validate(self):
7603 
    return
7604 
 
7605 
 
594 rajveer 7606 
  def __repr__(self):
7607 
    L = ['%s=%r' % (key, value)
7608 
      for key, value in self.__dict__.iteritems()]
7609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7610 
 
7611 
  def __eq__(self, other):
7612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7613 
 
7614 
  def __ne__(self, other):
7615 
    return not (self == other)
7616 
 
785 rajveer 7617 
class getDefaultPincode_args:
7618 
  """
7619 
  Attributes:
7620 
   - userId
7621 
  """
7622 
 
7623 
  thrift_spec = (
7624 
    None, # 0
7625 
    (1, TType.I64, 'userId', None, None, ), # 1
7626 
  )
7627 
 
7628 
  def __init__(self, userId=None,):
7629 
    self.userId = userId
7630 
 
7631 
  def read(self, iprot):
7632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7634 
      return
7635 
    iprot.readStructBegin()
7636 
    while True:
7637 
      (fname, ftype, fid) = iprot.readFieldBegin()
7638 
      if ftype == TType.STOP:
7639 
        break
7640 
      if fid == 1:
7641 
        if ftype == TType.I64:
7642 
          self.userId = iprot.readI64();
7643 
        else:
7644 
          iprot.skip(ftype)
7645 
      else:
7646 
        iprot.skip(ftype)
7647 
      iprot.readFieldEnd()
7648 
    iprot.readStructEnd()
7649 
 
7650 
  def write(self, oprot):
7651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7653 
      return
7654 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7655 
    if self.userId is not None:
785 rajveer 7656 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7657 
      oprot.writeI64(self.userId)
7658 
      oprot.writeFieldEnd()
7659 
    oprot.writeFieldStop()
7660 
    oprot.writeStructEnd()
7661 
 
3431 rajveer 7662 
  def validate(self):
7663 
    return
7664 
 
7665 
 
785 rajveer 7666 
  def __repr__(self):
7667 
    L = ['%s=%r' % (key, value)
7668 
      for key, value in self.__dict__.iteritems()]
7669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7670 
 
7671 
  def __eq__(self, other):
7672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7673 
 
7674 
  def __ne__(self, other):
7675 
    return not (self == other)
7676 
 
7677 
class getDefaultPincode_result:
7678 
  """
7679 
  Attributes:
7680 
   - success
7681 
   - ucx
7682 
  """
7683 
 
7684 
  thrift_spec = (
7685 
    (0, TType.STRING, 'success', None, None, ), # 0
7686 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7687 
  )
7688 
 
7689 
  def __init__(self, success=None, ucx=None,):
7690 
    self.success = success
7691 
    self.ucx = ucx
7692 
 
7693 
  def read(self, iprot):
7694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7696 
      return
7697 
    iprot.readStructBegin()
7698 
    while True:
7699 
      (fname, ftype, fid) = iprot.readFieldBegin()
7700 
      if ftype == TType.STOP:
7701 
        break
7702 
      if fid == 0:
7703 
        if ftype == TType.STRING:
7704 
          self.success = iprot.readString();
7705 
        else:
7706 
          iprot.skip(ftype)
7707 
      elif fid == 1:
7708 
        if ftype == TType.STRUCT:
7709 
          self.ucx = UserContextException()
7710 
          self.ucx.read(iprot)
7711 
        else:
7712 
          iprot.skip(ftype)
7713 
      else:
7714 
        iprot.skip(ftype)
7715 
      iprot.readFieldEnd()
7716 
    iprot.readStructEnd()
7717 
 
7718 
  def write(self, oprot):
7719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7721 
      return
7722 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7723 
    if self.success is not None:
785 rajveer 7724 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7725 
      oprot.writeString(self.success)
7726 
      oprot.writeFieldEnd()
3431 rajveer 7727 
    if self.ucx is not None:
785 rajveer 7728 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7729 
      self.ucx.write(oprot)
7730 
      oprot.writeFieldEnd()
7731 
    oprot.writeFieldStop()
7732 
    oprot.writeStructEnd()
7733 
 
3431 rajveer 7734 
  def validate(self):
7735 
    return
7736 
 
7737 
 
785 rajveer 7738 
  def __repr__(self):
7739 
    L = ['%s=%r' % (key, value)
7740 
      for key, value in self.__dict__.iteritems()]
7741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7742 
 
7743 
  def __eq__(self, other):
7744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7745 
 
7746 
  def __ne__(self, other):
7747 
    return not (self == other)
7748 
 
1274 varun.gupt 7749 
class saveUserCommunication_args:
7750 
  """
7751 
  Attributes:
7752 
   - userId
7753 
   - replyTo
7754 
   - communicationType
7755 
   - orderId
7756 
   - airwaybillNo
7757 
   - productName
7758 
   - subject
7759 
   - message
7760 
  """
7761 
 
7762 
  thrift_spec = (
7763 
    None, # 0
7764 
    (1, TType.I64, 'userId', None, None, ), # 1
7765 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7766 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7767 
    (4, TType.I64, 'orderId', None, None, ), # 4
7768 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7769 
    (6, TType.STRING, 'productName', None, None, ), # 6
7770 
    (7, TType.STRING, 'subject', None, None, ), # 7
7771 
    (8, TType.STRING, 'message', None, None, ), # 8
7772 
  )
7773 
 
7774 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7775 
    self.userId = userId
7776 
    self.replyTo = replyTo
7777 
    self.communicationType = communicationType
7778 
    self.orderId = orderId
7779 
    self.airwaybillNo = airwaybillNo
7780 
    self.productName = productName
7781 
    self.subject = subject
7782 
    self.message = message
7783 
 
7784 
  def read(self, iprot):
7785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7787 
      return
7788 
    iprot.readStructBegin()
7789 
    while True:
7790 
      (fname, ftype, fid) = iprot.readFieldBegin()
7791 
      if ftype == TType.STOP:
7792 
        break
7793 
      if fid == 1:
7794 
        if ftype == TType.I64:
7795 
          self.userId = iprot.readI64();
7796 
        else:
7797 
          iprot.skip(ftype)
7798 
      elif fid == 2:
7799 
        if ftype == TType.STRING:
7800 
          self.replyTo = iprot.readString();
7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      elif fid == 3:
7804 
        if ftype == TType.I64:
7805 
          self.communicationType = iprot.readI64();
7806 
        else:
7807 
          iprot.skip(ftype)
7808 
      elif fid == 4:
7809 
        if ftype == TType.I64:
7810 
          self.orderId = iprot.readI64();
7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      elif fid == 5:
7814 
        if ftype == TType.STRING:
7815 
          self.airwaybillNo = iprot.readString();
7816 
        else:
7817 
          iprot.skip(ftype)
7818 
      elif fid == 6:
7819 
        if ftype == TType.STRING:
7820 
          self.productName = iprot.readString();
7821 
        else:
7822 
          iprot.skip(ftype)
7823 
      elif fid == 7:
7824 
        if ftype == TType.STRING:
7825 
          self.subject = iprot.readString();
7826 
        else:
7827 
          iprot.skip(ftype)
7828 
      elif fid == 8:
7829 
        if ftype == TType.STRING:
7830 
          self.message = iprot.readString();
7831 
        else:
7832 
          iprot.skip(ftype)
7833 
      else:
7834 
        iprot.skip(ftype)
7835 
      iprot.readFieldEnd()
7836 
    iprot.readStructEnd()
7837 
 
7838 
  def write(self, oprot):
7839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7841 
      return
7842 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7843 
    if self.userId is not None:
1274 varun.gupt 7844 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7845 
      oprot.writeI64(self.userId)
7846 
      oprot.writeFieldEnd()
3431 rajveer 7847 
    if self.replyTo is not None:
1274 varun.gupt 7848 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7849 
      oprot.writeString(self.replyTo)
7850 
      oprot.writeFieldEnd()
3431 rajveer 7851 
    if self.communicationType is not None:
1274 varun.gupt 7852 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7853 
      oprot.writeI64(self.communicationType)
7854 
      oprot.writeFieldEnd()
3431 rajveer 7855 
    if self.orderId is not None:
1274 varun.gupt 7856 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7857 
      oprot.writeI64(self.orderId)
7858 
      oprot.writeFieldEnd()
3431 rajveer 7859 
    if self.airwaybillNo is not None:
1274 varun.gupt 7860 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7861 
      oprot.writeString(self.airwaybillNo)
7862 
      oprot.writeFieldEnd()
3431 rajveer 7863 
    if self.productName is not None:
1274 varun.gupt 7864 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7865 
      oprot.writeString(self.productName)
7866 
      oprot.writeFieldEnd()
3431 rajveer 7867 
    if self.subject is not None:
1274 varun.gupt 7868 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7869 
      oprot.writeString(self.subject)
7870 
      oprot.writeFieldEnd()
3431 rajveer 7871 
    if self.message is not None:
1274 varun.gupt 7872 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7873 
      oprot.writeString(self.message)
7874 
      oprot.writeFieldEnd()
7875 
    oprot.writeFieldStop()
7876 
    oprot.writeStructEnd()
7877 
 
3431 rajveer 7878 
  def validate(self):
7879 
    return
7880 
 
7881 
 
1274 varun.gupt 7882 
  def __repr__(self):
7883 
    L = ['%s=%r' % (key, value)
7884 
      for key, value in self.__dict__.iteritems()]
7885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7886 
 
7887 
  def __eq__(self, other):
7888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7889 
 
7890 
  def __ne__(self, other):
7891 
    return not (self == other)
7892 
 
7893 
class saveUserCommunication_result:
7894 
  """
7895 
  Attributes:
7896 
   - success
7897 
   - ucx
7898 
  """
7899 
 
7900 
  thrift_spec = (
7901 
    (0, TType.BOOL, 'success', None, None, ), # 0
7902 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7903 
  )
7904 
 
7905 
  def __init__(self, success=None, ucx=None,):
7906 
    self.success = success
7907 
    self.ucx = ucx
7908 
 
7909 
  def read(self, iprot):
7910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7912 
      return
7913 
    iprot.readStructBegin()
7914 
    while True:
7915 
      (fname, ftype, fid) = iprot.readFieldBegin()
7916 
      if ftype == TType.STOP:
7917 
        break
7918 
      if fid == 0:
7919 
        if ftype == TType.BOOL:
7920 
          self.success = iprot.readBool();
7921 
        else:
7922 
          iprot.skip(ftype)
7923 
      elif fid == 1:
7924 
        if ftype == TType.STRUCT:
7925 
          self.ucx = UserCommunicationException()
7926 
          self.ucx.read(iprot)
7927 
        else:
7928 
          iprot.skip(ftype)
7929 
      else:
7930 
        iprot.skip(ftype)
7931 
      iprot.readFieldEnd()
7932 
    iprot.readStructEnd()
7933 
 
7934 
  def write(self, oprot):
7935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7937 
      return
7938 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7939 
    if self.success is not None:
1274 varun.gupt 7940 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7941 
      oprot.writeBool(self.success)
7942 
      oprot.writeFieldEnd()
3431 rajveer 7943 
    if self.ucx is not None:
1274 varun.gupt 7944 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7945 
      self.ucx.write(oprot)
7946 
      oprot.writeFieldEnd()
7947 
    oprot.writeFieldStop()
7948 
    oprot.writeStructEnd()
7949 
 
3431 rajveer 7950 
  def validate(self):
7951 
    return
7952 
 
7953 
 
1274 varun.gupt 7954 
  def __repr__(self):
7955 
    L = ['%s=%r' % (key, value)
7956 
      for key, value in self.__dict__.iteritems()]
7957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7958 
 
7959 
  def __eq__(self, other):
7960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7961 
 
7962 
  def __ne__(self, other):
7963 
    return not (self == other)
7964 
 
1590 varun.gupt 7965 
class getUserCommunicationById_args:
7966 
  """
7967 
  Attributes:
7968 
   - id
7969 
  """
7970 
 
7971 
  thrift_spec = (
7972 
    None, # 0
7973 
    (1, TType.I64, 'id', None, None, ), # 1
7974 
  )
7975 
 
7976 
  def __init__(self, id=None,):
7977 
    self.id = id
7978 
 
7979 
  def read(self, iprot):
7980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7982 
      return
7983 
    iprot.readStructBegin()
7984 
    while True:
7985 
      (fname, ftype, fid) = iprot.readFieldBegin()
7986 
      if ftype == TType.STOP:
7987 
        break
7988 
      if fid == 1:
7989 
        if ftype == TType.I64:
7990 
          self.id = iprot.readI64();
7991 
        else:
7992 
          iprot.skip(ftype)
7993 
      else:
7994 
        iprot.skip(ftype)
7995 
      iprot.readFieldEnd()
7996 
    iprot.readStructEnd()
7997 
 
7998 
  def write(self, oprot):
7999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8001 
      return
8002 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8003 
    if self.id is not None:
1590 varun.gupt 8004 
      oprot.writeFieldBegin('id', TType.I64, 1)
8005 
      oprot.writeI64(self.id)
8006 
      oprot.writeFieldEnd()
8007 
    oprot.writeFieldStop()
8008 
    oprot.writeStructEnd()
8009 
 
3431 rajveer 8010 
  def validate(self):
8011 
    return
8012 
 
8013 
 
1590 varun.gupt 8014 
  def __repr__(self):
8015 
    L = ['%s=%r' % (key, value)
8016 
      for key, value in self.__dict__.iteritems()]
8017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8018 
 
8019 
  def __eq__(self, other):
8020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8021 
 
8022 
  def __ne__(self, other):
8023 
    return not (self == other)
8024 
 
8025 
class getUserCommunicationById_result:
8026 
  """
8027 
  Attributes:
8028 
   - success
8029 
   - ucx
8030 
  """
8031 
 
8032 
  thrift_spec = (
8033 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8034 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8035 
  )
8036 
 
8037 
  def __init__(self, success=None, ucx=None,):
8038 
    self.success = success
8039 
    self.ucx = ucx
8040 
 
8041 
  def read(self, iprot):
8042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8044 
      return
8045 
    iprot.readStructBegin()
8046 
    while True:
8047 
      (fname, ftype, fid) = iprot.readFieldBegin()
8048 
      if ftype == TType.STOP:
8049 
        break
8050 
      if fid == 0:
8051 
        if ftype == TType.STRUCT:
8052 
          self.success = UserCommunication()
8053 
          self.success.read(iprot)
8054 
        else:
8055 
          iprot.skip(ftype)
8056 
      elif fid == 1:
8057 
        if ftype == TType.STRUCT:
8058 
          self.ucx = UserCommunicationException()
8059 
          self.ucx.read(iprot)
8060 
        else:
8061 
          iprot.skip(ftype)
8062 
      else:
8063 
        iprot.skip(ftype)
8064 
      iprot.readFieldEnd()
8065 
    iprot.readStructEnd()
8066 
 
8067 
  def write(self, oprot):
8068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8070 
      return
8071 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8072 
    if self.success is not None:
1590 varun.gupt 8073 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8074 
      self.success.write(oprot)
8075 
      oprot.writeFieldEnd()
3431 rajveer 8076 
    if self.ucx is not None:
1590 varun.gupt 8077 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8078 
      self.ucx.write(oprot)
8079 
      oprot.writeFieldEnd()
8080 
    oprot.writeFieldStop()
8081 
    oprot.writeStructEnd()
8082 
 
3431 rajveer 8083 
  def validate(self):
8084 
    return
8085 
 
8086 
 
1590 varun.gupt 8087 
  def __repr__(self):
8088 
    L = ['%s=%r' % (key, value)
8089 
      for key, value in self.__dict__.iteritems()]
8090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8091 
 
8092 
  def __eq__(self, other):
8093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8094 
 
8095 
  def __ne__(self, other):
8096 
    return not (self == other)
8097 
 
8098 
class getUserCommunicationByUser_args:
8099 
  """
8100 
  Attributes:
8101 
   - userId
8102 
  """
8103 
 
8104 
  thrift_spec = (
8105 
    None, # 0
8106 
    (1, TType.I64, 'userId', None, None, ), # 1
8107 
  )
8108 
 
8109 
  def __init__(self, userId=None,):
8110 
    self.userId = userId
8111 
 
8112 
  def read(self, iprot):
8113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8115 
      return
8116 
    iprot.readStructBegin()
8117 
    while True:
8118 
      (fname, ftype, fid) = iprot.readFieldBegin()
8119 
      if ftype == TType.STOP:
8120 
        break
8121 
      if fid == 1:
8122 
        if ftype == TType.I64:
8123 
          self.userId = iprot.readI64();
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      else:
8127 
        iprot.skip(ftype)
8128 
      iprot.readFieldEnd()
8129 
    iprot.readStructEnd()
8130 
 
8131 
  def write(self, oprot):
8132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8134 
      return
8135 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8136 
    if self.userId is not None:
1590 varun.gupt 8137 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8138 
      oprot.writeI64(self.userId)
8139 
      oprot.writeFieldEnd()
8140 
    oprot.writeFieldStop()
8141 
    oprot.writeStructEnd()
8142 
 
3431 rajveer 8143 
  def validate(self):
8144 
    return
8145 
 
8146 
 
1590 varun.gupt 8147 
  def __repr__(self):
8148 
    L = ['%s=%r' % (key, value)
8149 
      for key, value in self.__dict__.iteritems()]
8150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8151 
 
8152 
  def __eq__(self, other):
8153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8154 
 
8155 
  def __ne__(self, other):
8156 
    return not (self == other)
8157 
 
8158 
class getUserCommunicationByUser_result:
8159 
  """
8160 
  Attributes:
8161 
   - success
8162 
   - ucx
8163 
  """
8164 
 
8165 
  thrift_spec = (
8166 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8167 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8168 
  )
8169 
 
8170 
  def __init__(self, success=None, ucx=None,):
8171 
    self.success = success
8172 
    self.ucx = ucx
8173 
 
8174 
  def read(self, iprot):
8175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8177 
      return
8178 
    iprot.readStructBegin()
8179 
    while True:
8180 
      (fname, ftype, fid) = iprot.readFieldBegin()
8181 
      if ftype == TType.STOP:
8182 
        break
8183 
      if fid == 0:
8184 
        if ftype == TType.LIST:
8185 
          self.success = []
11592 amit.gupta 8186 
          (_etype107, _size104) = iprot.readListBegin()
8187 
          for _i108 in xrange(_size104):
8188 
            _elem109 = UserCommunication()
8189 
            _elem109.read(iprot)
8190 
            self.success.append(_elem109)
1590 varun.gupt 8191 
          iprot.readListEnd()
8192 
        else:
8193 
          iprot.skip(ftype)
8194 
      elif fid == 1:
8195 
        if ftype == TType.STRUCT:
8196 
          self.ucx = UserCommunicationException()
8197 
          self.ucx.read(iprot)
8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      else:
8201 
        iprot.skip(ftype)
8202 
      iprot.readFieldEnd()
8203 
    iprot.readStructEnd()
8204 
 
8205 
  def write(self, oprot):
8206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8208 
      return
8209 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8210 
    if self.success is not None:
1590 varun.gupt 8211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8212 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8213 
      for iter110 in self.success:
8214 
        iter110.write(oprot)
1590 varun.gupt 8215 
      oprot.writeListEnd()
8216 
      oprot.writeFieldEnd()
3431 rajveer 8217 
    if self.ucx is not None:
1590 varun.gupt 8218 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8219 
      self.ucx.write(oprot)
8220 
      oprot.writeFieldEnd()
8221 
    oprot.writeFieldStop()
8222 
    oprot.writeStructEnd()
8223 
 
3431 rajveer 8224 
  def validate(self):
8225 
    return
8226 
 
8227 
 
1590 varun.gupt 8228 
  def __repr__(self):
8229 
    L = ['%s=%r' % (key, value)
8230 
      for key, value in self.__dict__.iteritems()]
8231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8232 
 
8233 
  def __eq__(self, other):
8234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8235 
 
8236 
  def __ne__(self, other):
8237 
    return not (self == other)
8238 
 
8239 
class getAllUserCommunications_args:
8240 
 
8241 
  thrift_spec = (
8242 
  )
8243 
 
8244 
  def read(self, iprot):
8245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8247 
      return
8248 
    iprot.readStructBegin()
8249 
    while True:
8250 
      (fname, ftype, fid) = iprot.readFieldBegin()
8251 
      if ftype == TType.STOP:
8252 
        break
8253 
      else:
8254 
        iprot.skip(ftype)
8255 
      iprot.readFieldEnd()
8256 
    iprot.readStructEnd()
8257 
 
8258 
  def write(self, oprot):
8259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8261 
      return
8262 
    oprot.writeStructBegin('getAllUserCommunications_args')
8263 
    oprot.writeFieldStop()
8264 
    oprot.writeStructEnd()
8265 
 
3431 rajveer 8266 
  def validate(self):
8267 
    return
8268 
 
8269 
 
1590 varun.gupt 8270 
  def __repr__(self):
8271 
    L = ['%s=%r' % (key, value)
8272 
      for key, value in self.__dict__.iteritems()]
8273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8274 
 
8275 
  def __eq__(self, other):
8276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8277 
 
8278 
  def __ne__(self, other):
8279 
    return not (self == other)
8280 
 
8281 
class getAllUserCommunications_result:
8282 
  """
8283 
  Attributes:
8284 
   - success
8285 
   - ucx
8286 
  """
8287 
 
8288 
  thrift_spec = (
8289 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8290 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8291 
  )
8292 
 
8293 
  def __init__(self, success=None, ucx=None,):
8294 
    self.success = success
8295 
    self.ucx = ucx
8296 
 
8297 
  def read(self, iprot):
8298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8300 
      return
8301 
    iprot.readStructBegin()
8302 
    while True:
8303 
      (fname, ftype, fid) = iprot.readFieldBegin()
8304 
      if ftype == TType.STOP:
8305 
        break
8306 
      if fid == 0:
8307 
        if ftype == TType.LIST:
8308 
          self.success = []
11592 amit.gupta 8309 
          (_etype114, _size111) = iprot.readListBegin()
8310 
          for _i115 in xrange(_size111):
8311 
            _elem116 = UserCommunication()
8312 
            _elem116.read(iprot)
8313 
            self.success.append(_elem116)
1590 varun.gupt 8314 
          iprot.readListEnd()
8315 
        else:
8316 
          iprot.skip(ftype)
8317 
      elif fid == 1:
8318 
        if ftype == TType.STRUCT:
8319 
          self.ucx = UserCommunicationException()
8320 
          self.ucx.read(iprot)
8321 
        else:
8322 
          iprot.skip(ftype)
8323 
      else:
8324 
        iprot.skip(ftype)
8325 
      iprot.readFieldEnd()
8326 
    iprot.readStructEnd()
8327 
 
8328 
  def write(self, oprot):
8329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8331 
      return
8332 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8333 
    if self.success is not None:
1590 varun.gupt 8334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8336 
      for iter117 in self.success:
8337 
        iter117.write(oprot)
1590 varun.gupt 8338 
      oprot.writeListEnd()
8339 
      oprot.writeFieldEnd()
3431 rajveer 8340 
    if self.ucx is not None:
1590 varun.gupt 8341 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8342 
      self.ucx.write(oprot)
8343 
      oprot.writeFieldEnd()
8344 
    oprot.writeFieldStop()
8345 
    oprot.writeStructEnd()
8346 
 
3431 rajveer 8347 
  def validate(self):
8348 
    return
8349 
 
8350 
 
1590 varun.gupt 8351 
  def __repr__(self):
8352 
    L = ['%s=%r' % (key, value)
8353 
      for key, value in self.__dict__.iteritems()]
8354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8355 
 
8356 
  def __eq__(self, other):
8357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8358 
 
8359 
  def __ne__(self, other):
8360 
    return not (self == other)
8361 
 
5407 amar.kumar 8362 
class removeUserCommunication_args:
8363 
  """
8364 
  Attributes:
8365 
   - id
8366 
  """
8367 
 
8368 
  thrift_spec = (
8369 
    None, # 0
8370 
    (1, TType.I64, 'id', None, None, ), # 1
8371 
  )
8372 
 
8373 
  def __init__(self, id=None,):
8374 
    self.id = id
8375 
 
8376 
  def read(self, iprot):
8377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8379 
      return
8380 
    iprot.readStructBegin()
8381 
    while True:
8382 
      (fname, ftype, fid) = iprot.readFieldBegin()
8383 
      if ftype == TType.STOP:
8384 
        break
8385 
      if fid == 1:
8386 
        if ftype == TType.I64:
8387 
          self.id = iprot.readI64();
8388 
        else:
8389 
          iprot.skip(ftype)
8390 
      else:
8391 
        iprot.skip(ftype)
8392 
      iprot.readFieldEnd()
8393 
    iprot.readStructEnd()
8394 
 
8395 
  def write(self, oprot):
8396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8398 
      return
8399 
    oprot.writeStructBegin('removeUserCommunication_args')
8400 
    if self.id is not None:
8401 
      oprot.writeFieldBegin('id', TType.I64, 1)
8402 
      oprot.writeI64(self.id)
8403 
      oprot.writeFieldEnd()
8404 
    oprot.writeFieldStop()
8405 
    oprot.writeStructEnd()
8406 
 
8407 
  def validate(self):
8408 
    return
8409 
 
8410 
 
8411 
  def __repr__(self):
8412 
    L = ['%s=%r' % (key, value)
8413 
      for key, value in self.__dict__.iteritems()]
8414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8415 
 
8416 
  def __eq__(self, other):
8417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8418 
 
8419 
  def __ne__(self, other):
8420 
    return not (self == other)
8421 
 
8422 
class removeUserCommunication_result:
8423 
  """
8424 
  Attributes:
8425 
   - ucx
8426 
  """
8427 
 
8428 
  thrift_spec = (
8429 
    None, # 0
8430 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8431 
  )
8432 
 
8433 
  def __init__(self, ucx=None,):
8434 
    self.ucx = ucx
8435 
 
8436 
  def read(self, iprot):
8437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8439 
      return
8440 
    iprot.readStructBegin()
8441 
    while True:
8442 
      (fname, ftype, fid) = iprot.readFieldBegin()
8443 
      if ftype == TType.STOP:
8444 
        break
8445 
      if fid == 1:
8446 
        if ftype == TType.STRUCT:
8447 
          self.ucx = UserCommunicationException()
8448 
          self.ucx.read(iprot)
8449 
        else:
8450 
          iprot.skip(ftype)
8451 
      else:
8452 
        iprot.skip(ftype)
8453 
      iprot.readFieldEnd()
8454 
    iprot.readStructEnd()
8455 
 
8456 
  def write(self, oprot):
8457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8459 
      return
8460 
    oprot.writeStructBegin('removeUserCommunication_result')
8461 
    if self.ucx is not None:
8462 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8463 
      self.ucx.write(oprot)
8464 
      oprot.writeFieldEnd()
8465 
    oprot.writeFieldStop()
8466 
    oprot.writeStructEnd()
8467 
 
8468 
  def validate(self):
8469 
    return
8470 
 
8471 
 
8472 
  def __repr__(self):
8473 
    L = ['%s=%r' % (key, value)
8474 
      for key, value in self.__dict__.iteritems()]
8475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8476 
 
8477 
  def __eq__(self, other):
8478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8479 
 
8480 
  def __ne__(self, other):
8481 
    return not (self == other)
8482 
 
1845 vikas 8483 
class createMasterAffiliate_args:
8484 
  """
8485 
  Attributes:
8486 
   - name
1859 vikas 8487 
   - addedOn
1845 vikas 8488 
  """
8489 
 
8490 
  thrift_spec = (
8491 
    None, # 0
8492 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8493 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8494 
  )
8495 
 
1859 vikas 8496 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8497 
    self.name = name
1859 vikas 8498 
    self.addedOn = addedOn
1845 vikas 8499 
 
8500 
  def read(self, iprot):
8501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8503 
      return
8504 
    iprot.readStructBegin()
8505 
    while True:
8506 
      (fname, ftype, fid) = iprot.readFieldBegin()
8507 
      if ftype == TType.STOP:
8508 
        break
8509 
      if fid == 1:
8510 
        if ftype == TType.STRING:
8511 
          self.name = iprot.readString();
8512 
        else:
8513 
          iprot.skip(ftype)
1859 vikas 8514 
      elif fid == 2:
8515 
        if ftype == TType.I64:
8516 
          self.addedOn = iprot.readI64();
8517 
        else:
8518 
          iprot.skip(ftype)
1845 vikas 8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
8528 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8529 
    if self.name is not None:
1845 vikas 8530 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8531 
      oprot.writeString(self.name)
8532 
      oprot.writeFieldEnd()
3431 rajveer 8533 
    if self.addedOn is not None:
1859 vikas 8534 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8535 
      oprot.writeI64(self.addedOn)
8536 
      oprot.writeFieldEnd()
1845 vikas 8537 
    oprot.writeFieldStop()
8538 
    oprot.writeStructEnd()
8539 
 
3431 rajveer 8540 
  def validate(self):
8541 
    return
8542 
 
8543 
 
1845 vikas 8544 
  def __repr__(self):
8545 
    L = ['%s=%r' % (key, value)
8546 
      for key, value in self.__dict__.iteritems()]
8547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8548 
 
8549 
  def __eq__(self, other):
8550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8551 
 
8552 
  def __ne__(self, other):
8553 
    return not (self == other)
8554 
 
8555 
class createMasterAffiliate_result:
8556 
  """
8557 
  Attributes:
8558 
   - success
8559 
   - utx
8560 
  """
8561 
 
8562 
  thrift_spec = (
8563 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8564 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8565 
  )
8566 
 
8567 
  def __init__(self, success=None, utx=None,):
8568 
    self.success = success
8569 
    self.utx = utx
8570 
 
8571 
  def read(self, iprot):
8572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8574 
      return
8575 
    iprot.readStructBegin()
8576 
    while True:
8577 
      (fname, ftype, fid) = iprot.readFieldBegin()
8578 
      if ftype == TType.STOP:
8579 
        break
8580 
      if fid == 0:
8581 
        if ftype == TType.STRUCT:
8582 
          self.success = MasterAffiliate()
8583 
          self.success.read(iprot)
8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      elif fid == 1:
8587 
        if ftype == TType.STRUCT:
1996 vikas 8588 
          self.utx = UserAffiliateException()
1845 vikas 8589 
          self.utx.read(iprot)
8590 
        else:
8591 
          iprot.skip(ftype)
8592 
      else:
8593 
        iprot.skip(ftype)
8594 
      iprot.readFieldEnd()
8595 
    iprot.readStructEnd()
8596 
 
8597 
  def write(self, oprot):
8598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8600 
      return
8601 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8602 
    if self.success is not None:
1845 vikas 8603 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8604 
      self.success.write(oprot)
8605 
      oprot.writeFieldEnd()
3431 rajveer 8606 
    if self.utx is not None:
1845 vikas 8607 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8608 
      self.utx.write(oprot)
8609 
      oprot.writeFieldEnd()
8610 
    oprot.writeFieldStop()
8611 
    oprot.writeStructEnd()
8612 
 
3431 rajveer 8613 
  def validate(self):
8614 
    return
8615 
 
8616 
 
1845 vikas 8617 
  def __repr__(self):
8618 
    L = ['%s=%r' % (key, value)
8619 
      for key, value in self.__dict__.iteritems()]
8620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8621 
 
8622 
  def __eq__(self, other):
8623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8624 
 
8625 
  def __ne__(self, other):
8626 
    return not (self == other)
8627 
 
1899 vikas 8628 
class getAllMasterAffiliates_args:
8629 
 
8630 
  thrift_spec = (
8631 
  )
8632 
 
8633 
  def read(self, iprot):
8634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8636 
      return
8637 
    iprot.readStructBegin()
8638 
    while True:
8639 
      (fname, ftype, fid) = iprot.readFieldBegin()
8640 
      if ftype == TType.STOP:
8641 
        break
8642 
      else:
8643 
        iprot.skip(ftype)
8644 
      iprot.readFieldEnd()
8645 
    iprot.readStructEnd()
8646 
 
8647 
  def write(self, oprot):
8648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8650 
      return
8651 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8652 
    oprot.writeFieldStop()
8653 
    oprot.writeStructEnd()
8654 
 
3431 rajveer 8655 
  def validate(self):
8656 
    return
8657 
 
8658 
 
1899 vikas 8659 
  def __repr__(self):
8660 
    L = ['%s=%r' % (key, value)
8661 
      for key, value in self.__dict__.iteritems()]
8662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8663 
 
8664 
  def __eq__(self, other):
8665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8666 
 
8667 
  def __ne__(self, other):
8668 
    return not (self == other)
8669 
 
8670 
class getAllMasterAffiliates_result:
8671 
  """
8672 
  Attributes:
8673 
   - success
8674 
   - utx
8675 
  """
8676 
 
8677 
  thrift_spec = (
8678 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8679 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8680 
  )
8681 
 
8682 
  def __init__(self, success=None, utx=None,):
8683 
    self.success = success
8684 
    self.utx = utx
8685 
 
8686 
  def read(self, iprot):
8687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8689 
      return
8690 
    iprot.readStructBegin()
8691 
    while True:
8692 
      (fname, ftype, fid) = iprot.readFieldBegin()
8693 
      if ftype == TType.STOP:
8694 
        break
8695 
      if fid == 0:
8696 
        if ftype == TType.LIST:
8697 
          self.success = []
11592 amit.gupta 8698 
          (_etype121, _size118) = iprot.readListBegin()
8699 
          for _i122 in xrange(_size118):
8700 
            _elem123 = MasterAffiliate()
8701 
            _elem123.read(iprot)
8702 
            self.success.append(_elem123)
1899 vikas 8703 
          iprot.readListEnd()
8704 
        else:
8705 
          iprot.skip(ftype)
8706 
      elif fid == 1:
8707 
        if ftype == TType.STRUCT:
1996 vikas 8708 
          self.utx = UserAffiliateException()
1899 vikas 8709 
          self.utx.read(iprot)
8710 
        else:
8711 
          iprot.skip(ftype)
8712 
      else:
8713 
        iprot.skip(ftype)
8714 
      iprot.readFieldEnd()
8715 
    iprot.readStructEnd()
8716 
 
8717 
  def write(self, oprot):
8718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8720 
      return
8721 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8722 
    if self.success is not None:
1899 vikas 8723 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8724 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8725 
      for iter124 in self.success:
8726 
        iter124.write(oprot)
1899 vikas 8727 
      oprot.writeListEnd()
8728 
      oprot.writeFieldEnd()
3431 rajveer 8729 
    if self.utx is not None:
1899 vikas 8730 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8731 
      self.utx.write(oprot)
8732 
      oprot.writeFieldEnd()
8733 
    oprot.writeFieldStop()
8734 
    oprot.writeStructEnd()
8735 
 
3431 rajveer 8736 
  def validate(self):
8737 
    return
8738 
 
8739 
 
1899 vikas 8740 
  def __repr__(self):
8741 
    L = ['%s=%r' % (key, value)
8742 
      for key, value in self.__dict__.iteritems()]
8743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8744 
 
8745 
  def __eq__(self, other):
8746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8747 
 
8748 
  def __ne__(self, other):
8749 
    return not (self == other)
8750 
 
1845 vikas 8751 
class getMasterAffiliateById_args:
8752 
  """
8753 
  Attributes:
8754 
   - id
8755 
  """
8756 
 
8757 
  thrift_spec = (
8758 
    None, # 0
8759 
    (1, TType.I64, 'id', None, None, ), # 1
8760 
  )
8761 
 
8762 
  def __init__(self, id=None,):
8763 
    self.id = id
8764 
 
8765 
  def read(self, iprot):
8766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8768 
      return
8769 
    iprot.readStructBegin()
8770 
    while True:
8771 
      (fname, ftype, fid) = iprot.readFieldBegin()
8772 
      if ftype == TType.STOP:
8773 
        break
8774 
      if fid == 1:
8775 
        if ftype == TType.I64:
8776 
          self.id = iprot.readI64();
8777 
        else:
8778 
          iprot.skip(ftype)
8779 
      else:
8780 
        iprot.skip(ftype)
8781 
      iprot.readFieldEnd()
8782 
    iprot.readStructEnd()
8783 
 
8784 
  def write(self, oprot):
8785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8787 
      return
8788 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8789 
    if self.id is not None:
1845 vikas 8790 
      oprot.writeFieldBegin('id', TType.I64, 1)
8791 
      oprot.writeI64(self.id)
8792 
      oprot.writeFieldEnd()
8793 
    oprot.writeFieldStop()
8794 
    oprot.writeStructEnd()
8795 
 
3431 rajveer 8796 
  def validate(self):
8797 
    return
8798 
 
8799 
 
1845 vikas 8800 
  def __repr__(self):
8801 
    L = ['%s=%r' % (key, value)
8802 
      for key, value in self.__dict__.iteritems()]
8803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8804 
 
8805 
  def __eq__(self, other):
8806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8807 
 
8808 
  def __ne__(self, other):
8809 
    return not (self == other)
8810 
 
8811 
class getMasterAffiliateById_result:
8812 
  """
8813 
  Attributes:
8814 
   - success
8815 
   - utx
8816 
  """
8817 
 
8818 
  thrift_spec = (
8819 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8820 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8821 
  )
8822 
 
8823 
  def __init__(self, success=None, utx=None,):
8824 
    self.success = success
8825 
    self.utx = utx
8826 
 
8827 
  def read(self, iprot):
8828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8830 
      return
8831 
    iprot.readStructBegin()
8832 
    while True:
8833 
      (fname, ftype, fid) = iprot.readFieldBegin()
8834 
      if ftype == TType.STOP:
8835 
        break
8836 
      if fid == 0:
8837 
        if ftype == TType.STRUCT:
8838 
          self.success = MasterAffiliate()
8839 
          self.success.read(iprot)
8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      elif fid == 1:
8843 
        if ftype == TType.STRUCT:
1996 vikas 8844 
          self.utx = UserAffiliateException()
1845 vikas 8845 
          self.utx.read(iprot)
8846 
        else:
8847 
          iprot.skip(ftype)
8848 
      else:
8849 
        iprot.skip(ftype)
8850 
      iprot.readFieldEnd()
8851 
    iprot.readStructEnd()
8852 
 
8853 
  def write(self, oprot):
8854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8856 
      return
8857 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8858 
    if self.success is not None:
1845 vikas 8859 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8860 
      self.success.write(oprot)
8861 
      oprot.writeFieldEnd()
3431 rajveer 8862 
    if self.utx is not None:
1845 vikas 8863 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8864 
      self.utx.write(oprot)
8865 
      oprot.writeFieldEnd()
8866 
    oprot.writeFieldStop()
8867 
    oprot.writeStructEnd()
8868 
 
3431 rajveer 8869 
  def validate(self):
8870 
    return
8871 
 
8872 
 
1845 vikas 8873 
  def __repr__(self):
8874 
    L = ['%s=%r' % (key, value)
8875 
      for key, value in self.__dict__.iteritems()]
8876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8877 
 
8878 
  def __eq__(self, other):
8879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8880 
 
8881 
  def __ne__(self, other):
8882 
    return not (self == other)
8883 
 
8884 
class getMasterAffiliateByName_args:
8885 
  """
8886 
  Attributes:
8887 
   - name
8888 
  """
8889 
 
8890 
  thrift_spec = (
8891 
    None, # 0
8892 
    (1, TType.STRING, 'name', None, None, ), # 1
8893 
  )
8894 
 
8895 
  def __init__(self, name=None,):
8896 
    self.name = name
8897 
 
8898 
  def read(self, iprot):
8899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8901 
      return
8902 
    iprot.readStructBegin()
8903 
    while True:
8904 
      (fname, ftype, fid) = iprot.readFieldBegin()
8905 
      if ftype == TType.STOP:
8906 
        break
8907 
      if fid == 1:
8908 
        if ftype == TType.STRING:
8909 
          self.name = iprot.readString();
8910 
        else:
8911 
          iprot.skip(ftype)
8912 
      else:
8913 
        iprot.skip(ftype)
8914 
      iprot.readFieldEnd()
8915 
    iprot.readStructEnd()
8916 
 
8917 
  def write(self, oprot):
8918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8920 
      return
8921 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8922 
    if self.name is not None:
1845 vikas 8923 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8924 
      oprot.writeString(self.name)
8925 
      oprot.writeFieldEnd()
8926 
    oprot.writeFieldStop()
8927 
    oprot.writeStructEnd()
8928 
 
3431 rajveer 8929 
  def validate(self):
8930 
    return
8931 
 
8932 
 
1845 vikas 8933 
  def __repr__(self):
8934 
    L = ['%s=%r' % (key, value)
8935 
      for key, value in self.__dict__.iteritems()]
8936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8937 
 
8938 
  def __eq__(self, other):
8939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8940 
 
8941 
  def __ne__(self, other):
8942 
    return not (self == other)
8943 
 
8944 
class getMasterAffiliateByName_result:
8945 
  """
8946 
  Attributes:
8947 
   - success
8948 
   - utx
8949 
  """
8950 
 
8951 
  thrift_spec = (
8952 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8953 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8954 
  )
8955 
 
8956 
  def __init__(self, success=None, utx=None,):
8957 
    self.success = success
8958 
    self.utx = utx
8959 
 
8960 
  def read(self, iprot):
8961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8963 
      return
8964 
    iprot.readStructBegin()
8965 
    while True:
8966 
      (fname, ftype, fid) = iprot.readFieldBegin()
8967 
      if ftype == TType.STOP:
8968 
        break
8969 
      if fid == 0:
8970 
        if ftype == TType.STRUCT:
8971 
          self.success = MasterAffiliate()
8972 
          self.success.read(iprot)
8973 
        else:
8974 
          iprot.skip(ftype)
8975 
      elif fid == 1:
8976 
        if ftype == TType.STRUCT:
1996 vikas 8977 
          self.utx = UserAffiliateException()
1845 vikas 8978 
          self.utx.read(iprot)
8979 
        else:
8980 
          iprot.skip(ftype)
8981 
      else:
8982 
        iprot.skip(ftype)
8983 
      iprot.readFieldEnd()
8984 
    iprot.readStructEnd()
8985 
 
8986 
  def write(self, oprot):
8987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8989 
      return
8990 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8991 
    if self.success is not None:
1845 vikas 8992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8993 
      self.success.write(oprot)
8994 
      oprot.writeFieldEnd()
3431 rajveer 8995 
    if self.utx is not None:
1845 vikas 8996 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8997 
      self.utx.write(oprot)
8998 
      oprot.writeFieldEnd()
8999 
    oprot.writeFieldStop()
9000 
    oprot.writeStructEnd()
9001 
 
3431 rajveer 9002 
  def validate(self):
9003 
    return
9004 
 
9005 
 
1845 vikas 9006 
  def __repr__(self):
9007 
    L = ['%s=%r' % (key, value)
9008 
      for key, value in self.__dict__.iteritems()]
9009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9010 
 
9011 
  def __eq__(self, other):
9012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9013 
 
9014 
  def __ne__(self, other):
9015 
    return not (self == other)
9016 
 
9017 
class createAffiliate_args:
9018 
  """
9019 
  Attributes:
9020 
   - name
9021 
   - url
9022 
   - masterAffiliateId
1859 vikas 9023 
   - addedOn
1845 vikas 9024 
  """
9025 
 
9026 
  thrift_spec = (
9027 
    None, # 0
9028 
    (1, TType.STRING, 'name', None, None, ), # 1
9029 
    (2, TType.STRING, 'url', None, None, ), # 2
9030 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9031 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9032 
  )
9033 
 
1859 vikas 9034 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9035 
    self.name = name
9036 
    self.url = url
9037 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9038 
    self.addedOn = addedOn
1845 vikas 9039 
 
9040 
  def read(self, iprot):
9041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9043 
      return
9044 
    iprot.readStructBegin()
9045 
    while True:
9046 
      (fname, ftype, fid) = iprot.readFieldBegin()
9047 
      if ftype == TType.STOP:
9048 
        break
9049 
      if fid == 1:
9050 
        if ftype == TType.STRING:
9051 
          self.name = iprot.readString();
9052 
        else:
9053 
          iprot.skip(ftype)
9054 
      elif fid == 2:
9055 
        if ftype == TType.STRING:
9056 
          self.url = iprot.readString();
9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      elif fid == 3:
9060 
        if ftype == TType.I64:
9061 
          self.masterAffiliateId = iprot.readI64();
9062 
        else:
9063 
          iprot.skip(ftype)
1859 vikas 9064 
      elif fid == 4:
9065 
        if ftype == TType.I64:
9066 
          self.addedOn = iprot.readI64();
9067 
        else:
9068 
          iprot.skip(ftype)
1845 vikas 9069 
      else:
9070 
        iprot.skip(ftype)
9071 
      iprot.readFieldEnd()
9072 
    iprot.readStructEnd()
9073 
 
9074 
  def write(self, oprot):
9075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9077 
      return
9078 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9079 
    if self.name is not None:
1845 vikas 9080 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9081 
      oprot.writeString(self.name)
9082 
      oprot.writeFieldEnd()
3431 rajveer 9083 
    if self.url is not None:
1845 vikas 9084 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9085 
      oprot.writeString(self.url)
9086 
      oprot.writeFieldEnd()
3431 rajveer 9087 
    if self.masterAffiliateId is not None:
1845 vikas 9088 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9089 
      oprot.writeI64(self.masterAffiliateId)
9090 
      oprot.writeFieldEnd()
3431 rajveer 9091 
    if self.addedOn is not None:
1859 vikas 9092 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9093 
      oprot.writeI64(self.addedOn)
9094 
      oprot.writeFieldEnd()
1845 vikas 9095 
    oprot.writeFieldStop()
9096 
    oprot.writeStructEnd()
9097 
 
3431 rajveer 9098 
  def validate(self):
9099 
    return
9100 
 
9101 
 
1845 vikas 9102 
  def __repr__(self):
9103 
    L = ['%s=%r' % (key, value)
9104 
      for key, value in self.__dict__.iteritems()]
9105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9106 
 
9107 
  def __eq__(self, other):
9108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9109 
 
9110 
  def __ne__(self, other):
9111 
    return not (self == other)
9112 
 
9113 
class createAffiliate_result:
9114 
  """
9115 
  Attributes:
9116 
   - success
9117 
   - utx
9118 
  """
9119 
 
9120 
  thrift_spec = (
9121 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9122 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9123 
  )
9124 
 
9125 
  def __init__(self, success=None, utx=None,):
9126 
    self.success = success
9127 
    self.utx = utx
9128 
 
9129 
  def read(self, iprot):
9130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9132 
      return
9133 
    iprot.readStructBegin()
9134 
    while True:
9135 
      (fname, ftype, fid) = iprot.readFieldBegin()
9136 
      if ftype == TType.STOP:
9137 
        break
9138 
      if fid == 0:
9139 
        if ftype == TType.STRUCT:
9140 
          self.success = Affiliate()
9141 
          self.success.read(iprot)
9142 
        else:
9143 
          iprot.skip(ftype)
9144 
      elif fid == 1:
9145 
        if ftype == TType.STRUCT:
1996 vikas 9146 
          self.utx = UserAffiliateException()
1845 vikas 9147 
          self.utx.read(iprot)
9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
9159 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9160 
    if self.success is not None:
1845 vikas 9161 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9162 
      self.success.write(oprot)
9163 
      oprot.writeFieldEnd()
3431 rajveer 9164 
    if self.utx is not None:
1845 vikas 9165 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9166 
      self.utx.write(oprot)
9167 
      oprot.writeFieldEnd()
9168 
    oprot.writeFieldStop()
9169 
    oprot.writeStructEnd()
9170 
 
3431 rajveer 9171 
  def validate(self):
9172 
    return
9173 
 
9174 
 
1845 vikas 9175 
  def __repr__(self):
9176 
    L = ['%s=%r' % (key, value)
9177 
      for key, value in self.__dict__.iteritems()]
9178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9179 
 
9180 
  def __eq__(self, other):
9181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9182 
 
9183 
  def __ne__(self, other):
9184 
    return not (self == other)
9185 
 
9186 
class getAffiliateById_args:
9187 
  """
9188 
  Attributes:
9189 
   - id
9190 
  """
9191 
 
9192 
  thrift_spec = (
9193 
    None, # 0
9194 
    (1, TType.I64, 'id', None, None, ), # 1
9195 
  )
9196 
 
9197 
  def __init__(self, id=None,):
9198 
    self.id = id
9199 
 
9200 
  def read(self, iprot):
9201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9203 
      return
9204 
    iprot.readStructBegin()
9205 
    while True:
9206 
      (fname, ftype, fid) = iprot.readFieldBegin()
9207 
      if ftype == TType.STOP:
9208 
        break
9209 
      if fid == 1:
9210 
        if ftype == TType.I64:
9211 
          self.id = iprot.readI64();
9212 
        else:
9213 
          iprot.skip(ftype)
9214 
      else:
9215 
        iprot.skip(ftype)
9216 
      iprot.readFieldEnd()
9217 
    iprot.readStructEnd()
9218 
 
9219 
  def write(self, oprot):
9220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9222 
      return
9223 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9224 
    if self.id is not None:
1845 vikas 9225 
      oprot.writeFieldBegin('id', TType.I64, 1)
9226 
      oprot.writeI64(self.id)
9227 
      oprot.writeFieldEnd()
9228 
    oprot.writeFieldStop()
9229 
    oprot.writeStructEnd()
9230 
 
3431 rajveer 9231 
  def validate(self):
9232 
    return
9233 
 
9234 
 
1845 vikas 9235 
  def __repr__(self):
9236 
    L = ['%s=%r' % (key, value)
9237 
      for key, value in self.__dict__.iteritems()]
9238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9239 
 
9240 
  def __eq__(self, other):
9241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9242 
 
9243 
  def __ne__(self, other):
9244 
    return not (self == other)
9245 
 
9246 
class getAffiliateById_result:
9247 
  """
9248 
  Attributes:
9249 
   - success
9250 
   - utx
9251 
  """
9252 
 
9253 
  thrift_spec = (
9254 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9255 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9256 
  )
9257 
 
9258 
  def __init__(self, success=None, utx=None,):
9259 
    self.success = success
9260 
    self.utx = utx
9261 
 
9262 
  def read(self, iprot):
9263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9265 
      return
9266 
    iprot.readStructBegin()
9267 
    while True:
9268 
      (fname, ftype, fid) = iprot.readFieldBegin()
9269 
      if ftype == TType.STOP:
9270 
        break
9271 
      if fid == 0:
9272 
        if ftype == TType.STRUCT:
9273 
          self.success = Affiliate()
9274 
          self.success.read(iprot)
9275 
        else:
9276 
          iprot.skip(ftype)
9277 
      elif fid == 1:
9278 
        if ftype == TType.STRUCT:
1996 vikas 9279 
          self.utx = UserAffiliateException()
1845 vikas 9280 
          self.utx.read(iprot)
9281 
        else:
9282 
          iprot.skip(ftype)
9283 
      else:
9284 
        iprot.skip(ftype)
9285 
      iprot.readFieldEnd()
9286 
    iprot.readStructEnd()
9287 
 
9288 
  def write(self, oprot):
9289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9291 
      return
9292 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9293 
    if self.success is not None:
1845 vikas 9294 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9295 
      self.success.write(oprot)
9296 
      oprot.writeFieldEnd()
3431 rajveer 9297 
    if self.utx is not None:
1845 vikas 9298 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9299 
      self.utx.write(oprot)
9300 
      oprot.writeFieldEnd()
9301 
    oprot.writeFieldStop()
9302 
    oprot.writeStructEnd()
9303 
 
3431 rajveer 9304 
  def validate(self):
9305 
    return
9306 
 
9307 
 
1845 vikas 9308 
  def __repr__(self):
9309 
    L = ['%s=%r' % (key, value)
9310 
      for key, value in self.__dict__.iteritems()]
9311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9312 
 
9313 
  def __eq__(self, other):
9314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9315 
 
9316 
  def __ne__(self, other):
9317 
    return not (self == other)
9318 
 
9319 
class getAffiliateByName_args:
9320 
  """
9321 
  Attributes:
9322 
   - name
9323 
  """
9324 
 
9325 
  thrift_spec = (
9326 
    None, # 0
9327 
    (1, TType.STRING, 'name', None, None, ), # 1
9328 
  )
9329 
 
9330 
  def __init__(self, name=None,):
9331 
    self.name = name
9332 
 
9333 
  def read(self, iprot):
9334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9336 
      return
9337 
    iprot.readStructBegin()
9338 
    while True:
9339 
      (fname, ftype, fid) = iprot.readFieldBegin()
9340 
      if ftype == TType.STOP:
9341 
        break
9342 
      if fid == 1:
9343 
        if ftype == TType.STRING:
9344 
          self.name = iprot.readString();
9345 
        else:
9346 
          iprot.skip(ftype)
9347 
      else:
9348 
        iprot.skip(ftype)
9349 
      iprot.readFieldEnd()
9350 
    iprot.readStructEnd()
9351 
 
9352 
  def write(self, oprot):
9353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9355 
      return
9356 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9357 
    if self.name is not None:
1845 vikas 9358 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9359 
      oprot.writeString(self.name)
9360 
      oprot.writeFieldEnd()
9361 
    oprot.writeFieldStop()
9362 
    oprot.writeStructEnd()
9363 
 
3431 rajveer 9364 
  def validate(self):
9365 
    return
9366 
 
9367 
 
1845 vikas 9368 
  def __repr__(self):
9369 
    L = ['%s=%r' % (key, value)
9370 
      for key, value in self.__dict__.iteritems()]
9371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9372 
 
9373 
  def __eq__(self, other):
9374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9375 
 
9376 
  def __ne__(self, other):
9377 
    return not (self == other)
9378 
 
9379 
class getAffiliateByName_result:
9380 
  """
9381 
  Attributes:
9382 
   - success
9383 
   - utx
9384 
  """
9385 
 
9386 
  thrift_spec = (
9387 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9388 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9389 
  )
9390 
 
9391 
  def __init__(self, success=None, utx=None,):
9392 
    self.success = success
9393 
    self.utx = utx
9394 
 
9395 
  def read(self, iprot):
9396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9398 
      return
9399 
    iprot.readStructBegin()
9400 
    while True:
9401 
      (fname, ftype, fid) = iprot.readFieldBegin()
9402 
      if ftype == TType.STOP:
9403 
        break
9404 
      if fid == 0:
9405 
        if ftype == TType.STRUCT:
9406 
          self.success = Affiliate()
9407 
          self.success.read(iprot)
9408 
        else:
9409 
          iprot.skip(ftype)
9410 
      elif fid == 1:
9411 
        if ftype == TType.STRUCT:
1996 vikas 9412 
          self.utx = UserAffiliateException()
1845 vikas 9413 
          self.utx.read(iprot)
9414 
        else:
9415 
          iprot.skip(ftype)
9416 
      else:
9417 
        iprot.skip(ftype)
9418 
      iprot.readFieldEnd()
9419 
    iprot.readStructEnd()
9420 
 
9421 
  def write(self, oprot):
9422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9424 
      return
9425 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9426 
    if self.success is not None:
1845 vikas 9427 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9428 
      self.success.write(oprot)
9429 
      oprot.writeFieldEnd()
3431 rajveer 9430 
    if self.utx is not None:
1845 vikas 9431 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9432 
      self.utx.write(oprot)
9433 
      oprot.writeFieldEnd()
9434 
    oprot.writeFieldStop()
9435 
    oprot.writeStructEnd()
9436 
 
3431 rajveer 9437 
  def validate(self):
9438 
    return
9439 
 
9440 
 
1845 vikas 9441 
  def __repr__(self):
9442 
    L = ['%s=%r' % (key, value)
9443 
      for key, value in self.__dict__.iteritems()]
9444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9445 
 
9446 
  def __eq__(self, other):
9447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9448 
 
9449 
  def __ne__(self, other):
9450 
    return not (self == other)
9451 
 
1996 vikas 9452 
class getTrackerById_args:
1845 vikas 9453 
  """
9454 
  Attributes:
9455 
   - id
9456 
  """
9457 
 
9458 
  thrift_spec = (
9459 
    None, # 0
9460 
    (1, TType.I64, 'id', None, None, ), # 1
9461 
  )
9462 
 
9463 
  def __init__(self, id=None,):
9464 
    self.id = id
9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 1:
9476 
        if ftype == TType.I64:
9477 
          self.id = iprot.readI64();
9478 
        else:
9479 
          iprot.skip(ftype)
9480 
      else:
9481 
        iprot.skip(ftype)
9482 
      iprot.readFieldEnd()
9483 
    iprot.readStructEnd()
9484 
 
9485 
  def write(self, oprot):
9486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9488 
      return
1996 vikas 9489 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9490 
    if self.id is not None:
1845 vikas 9491 
      oprot.writeFieldBegin('id', TType.I64, 1)
9492 
      oprot.writeI64(self.id)
9493 
      oprot.writeFieldEnd()
9494 
    oprot.writeFieldStop()
9495 
    oprot.writeStructEnd()
9496 
 
3431 rajveer 9497 
  def validate(self):
9498 
    return
9499 
 
9500 
 
1845 vikas 9501 
  def __repr__(self):
9502 
    L = ['%s=%r' % (key, value)
9503 
      for key, value in self.__dict__.iteritems()]
9504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9505 
 
9506 
  def __eq__(self, other):
9507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9508 
 
9509 
  def __ne__(self, other):
9510 
    return not (self == other)
9511 
 
9512 
class getTrackerById_result:
9513 
  """
9514 
  Attributes:
9515 
   - success
9516 
   - utx
9517 
  """
9518 
 
9519 
  thrift_spec = (
9520 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9521 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9522 
  )
9523 
 
9524 
  def __init__(self, success=None, utx=None,):
9525 
    self.success = success
9526 
    self.utx = utx
9527 
 
9528 
  def read(self, iprot):
9529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9531 
      return
9532 
    iprot.readStructBegin()
9533 
    while True:
9534 
      (fname, ftype, fid) = iprot.readFieldBegin()
9535 
      if ftype == TType.STOP:
9536 
        break
9537 
      if fid == 0:
9538 
        if ftype == TType.STRUCT:
9539 
          self.success = Tracker()
9540 
          self.success.read(iprot)
9541 
        else:
9542 
          iprot.skip(ftype)
9543 
      elif fid == 1:
9544 
        if ftype == TType.STRUCT:
1996 vikas 9545 
          self.utx = UserAffiliateException()
1845 vikas 9546 
          self.utx.read(iprot)
9547 
        else:
9548 
          iprot.skip(ftype)
9549 
      else:
9550 
        iprot.skip(ftype)
9551 
      iprot.readFieldEnd()
9552 
    iprot.readStructEnd()
9553 
 
9554 
  def write(self, oprot):
9555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9557 
      return
9558 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9559 
    if self.success is not None:
1845 vikas 9560 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9561 
      self.success.write(oprot)
9562 
      oprot.writeFieldEnd()
3431 rajveer 9563 
    if self.utx is not None:
1845 vikas 9564 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9565 
      self.utx.write(oprot)
9566 
      oprot.writeFieldEnd()
9567 
    oprot.writeFieldStop()
9568 
    oprot.writeStructEnd()
9569 
 
3431 rajveer 9570 
  def validate(self):
9571 
    return
9572 
 
9573 
 
1845 vikas 9574 
  def __repr__(self):
9575 
    L = ['%s=%r' % (key, value)
9576 
      for key, value in self.__dict__.iteritems()]
9577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9578 
 
9579 
  def __eq__(self, other):
9580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9581 
 
9582 
  def __ne__(self, other):
9583 
    return not (self == other)
9584 
 
1996 vikas 9585 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9586 
  """
9587 
  Attributes:
1996 vikas 9588 
   - id
1845 vikas 9589 
  """
9590 
 
9591 
  thrift_spec = (
9592 
    None, # 0
1996 vikas 9593 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9594 
  )
9595 
 
1996 vikas 9596 
  def __init__(self, id=None,):
9597 
    self.id = id
1845 vikas 9598 
 
9599 
  def read(self, iprot):
9600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9602 
      return
9603 
    iprot.readStructBegin()
9604 
    while True:
9605 
      (fname, ftype, fid) = iprot.readFieldBegin()
9606 
      if ftype == TType.STOP:
9607 
        break
9608 
      if fid == 1:
9609 
        if ftype == TType.I64:
1996 vikas 9610 
          self.id = iprot.readI64();
1845 vikas 9611 
        else:
9612 
          iprot.skip(ftype)
9613 
      else:
9614 
        iprot.skip(ftype)
9615 
      iprot.readFieldEnd()
9616 
    iprot.readStructEnd()
9617 
 
9618 
  def write(self, oprot):
9619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9621 
      return
1996 vikas 9622 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9623 
    if self.id is not None:
1996 vikas 9624 
      oprot.writeFieldBegin('id', TType.I64, 1)
9625 
      oprot.writeI64(self.id)
1845 vikas 9626 
      oprot.writeFieldEnd()
9627 
    oprot.writeFieldStop()
9628 
    oprot.writeStructEnd()
9629 
 
3431 rajveer 9630 
  def validate(self):
9631 
    return
9632 
 
9633 
 
1845 vikas 9634 
  def __repr__(self):
9635 
    L = ['%s=%r' % (key, value)
9636 
      for key, value in self.__dict__.iteritems()]
9637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9638 
 
9639 
  def __eq__(self, other):
9640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9641 
 
9642 
  def __ne__(self, other):
9643 
    return not (self == other)
9644 
 
1996 vikas 9645 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9646 
  """
9647 
  Attributes:
9648 
   - success
9649 
   - utx
9650 
  """
9651 
 
9652 
  thrift_spec = (
1996 vikas 9653 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9654 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9655 
  )
9656 
 
9657 
  def __init__(self, success=None, utx=None,):
9658 
    self.success = success
9659 
    self.utx = utx
9660 
 
9661 
  def read(self, iprot):
9662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9664 
      return
9665 
    iprot.readStructBegin()
9666 
    while True:
9667 
      (fname, ftype, fid) = iprot.readFieldBegin()
9668 
      if ftype == TType.STOP:
9669 
        break
9670 
      if fid == 0:
9671 
        if ftype == TType.LIST:
9672 
          self.success = []
11592 amit.gupta 9673 
          (_etype128, _size125) = iprot.readListBegin()
9674 
          for _i129 in xrange(_size125):
9675 
            _elem130 = Affiliate()
9676 
            _elem130.read(iprot)
9677 
            self.success.append(_elem130)
1845 vikas 9678 
          iprot.readListEnd()
9679 
        else:
9680 
          iprot.skip(ftype)
9681 
      elif fid == 1:
9682 
        if ftype == TType.STRUCT:
1996 vikas 9683 
          self.utx = UserAffiliateException()
1845 vikas 9684 
          self.utx.read(iprot)
9685 
        else:
9686 
          iprot.skip(ftype)
9687 
      else:
9688 
        iprot.skip(ftype)
9689 
      iprot.readFieldEnd()
9690 
    iprot.readStructEnd()
9691 
 
9692 
  def write(self, oprot):
9693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9695 
      return
1996 vikas 9696 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9697 
    if self.success is not None:
1845 vikas 9698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9700 
      for iter131 in self.success:
9701 
        iter131.write(oprot)
1845 vikas 9702 
      oprot.writeListEnd()
9703 
      oprot.writeFieldEnd()
3431 rajveer 9704 
    if self.utx is not None:
1845 vikas 9705 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9706 
      self.utx.write(oprot)
9707 
      oprot.writeFieldEnd()
9708 
    oprot.writeFieldStop()
9709 
    oprot.writeStructEnd()
9710 
 
3431 rajveer 9711 
  def validate(self):
9712 
    return
9713 
 
9714 
 
1845 vikas 9715 
  def __repr__(self):
9716 
    L = ['%s=%r' % (key, value)
9717 
      for key, value in self.__dict__.iteritems()]
9718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9719 
 
9720 
  def __eq__(self, other):
9721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9722 
 
9723 
  def __ne__(self, other):
9724 
    return not (self == other)
9725 
 
9726 
class addTrackLog_args:
9727 
  """
9728 
  Attributes:
1996 vikas 9729 
   - affiliateId
1845 vikas 9730 
   - userId
9731 
   - event
9732 
   - url
9733 
   - data
1859 vikas 9734 
   - addedOn
1845 vikas 9735 
  """
9736 
 
9737 
  thrift_spec = (
9738 
    None, # 0
1996 vikas 9739 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9740 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9741 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9742 
    (4, TType.STRING, 'url', None, None, ), # 4
9743 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9744 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9745 
  )
9746 
 
1996 vikas 9747 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9748 
    self.affiliateId = affiliateId
1845 vikas 9749 
    self.userId = userId
9750 
    self.event = event
9751 
    self.url = url
9752 
    self.data = data
1859 vikas 9753 
    self.addedOn = addedOn
1845 vikas 9754 
 
9755 
  def read(self, iprot):
9756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9758 
      return
9759 
    iprot.readStructBegin()
9760 
    while True:
9761 
      (fname, ftype, fid) = iprot.readFieldBegin()
9762 
      if ftype == TType.STOP:
9763 
        break
9764 
      if fid == 1:
9765 
        if ftype == TType.I64:
1996 vikas 9766 
          self.affiliateId = iprot.readI64();
1845 vikas 9767 
        else:
9768 
          iprot.skip(ftype)
9769 
      elif fid == 2:
9770 
        if ftype == TType.I64:
9771 
          self.userId = iprot.readI64();
9772 
        else:
9773 
          iprot.skip(ftype)
9774 
      elif fid == 3:
3378 vikas 9775 
        if ftype == TType.I32:
9776 
          self.event = iprot.readI32();
1845 vikas 9777 
        else:
9778 
          iprot.skip(ftype)
9779 
      elif fid == 4:
9780 
        if ftype == TType.STRING:
9781 
          self.url = iprot.readString();
9782 
        else:
9783 
          iprot.skip(ftype)
9784 
      elif fid == 5:
9785 
        if ftype == TType.STRING:
9786 
          self.data = iprot.readString();
9787 
        else:
9788 
          iprot.skip(ftype)
1859 vikas 9789 
      elif fid == 6:
9790 
        if ftype == TType.I64:
9791 
          self.addedOn = iprot.readI64();
9792 
        else:
9793 
          iprot.skip(ftype)
1845 vikas 9794 
      else:
9795 
        iprot.skip(ftype)
9796 
      iprot.readFieldEnd()
9797 
    iprot.readStructEnd()
9798 
 
9799 
  def write(self, oprot):
9800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9802 
      return
9803 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9804 
    if self.affiliateId is not None:
1996 vikas 9805 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9806 
      oprot.writeI64(self.affiliateId)
1845 vikas 9807 
      oprot.writeFieldEnd()
3431 rajveer 9808 
    if self.userId is not None:
1845 vikas 9809 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9810 
      oprot.writeI64(self.userId)
9811 
      oprot.writeFieldEnd()
3431 rajveer 9812 
    if self.event is not None:
3378 vikas 9813 
      oprot.writeFieldBegin('event', TType.I32, 3)
9814 
      oprot.writeI32(self.event)
1845 vikas 9815 
      oprot.writeFieldEnd()
3431 rajveer 9816 
    if self.url is not None:
1845 vikas 9817 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9818 
      oprot.writeString(self.url)
9819 
      oprot.writeFieldEnd()
3431 rajveer 9820 
    if self.data is not None:
1845 vikas 9821 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9822 
      oprot.writeString(self.data)
9823 
      oprot.writeFieldEnd()
3431 rajveer 9824 
    if self.addedOn is not None:
1859 vikas 9825 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9826 
      oprot.writeI64(self.addedOn)
9827 
      oprot.writeFieldEnd()
1845 vikas 9828 
    oprot.writeFieldStop()
9829 
    oprot.writeStructEnd()
9830 
 
3431 rajveer 9831 
  def validate(self):
9832 
    return
9833 
 
9834 
 
1845 vikas 9835 
  def __repr__(self):
9836 
    L = ['%s=%r' % (key, value)
9837 
      for key, value in self.__dict__.iteritems()]
9838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9839 
 
9840 
  def __eq__(self, other):
9841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9842 
 
9843 
  def __ne__(self, other):
9844 
    return not (self == other)
9845 
 
9846 
class addTrackLog_result:
9847 
  """
9848 
  Attributes:
9849 
   - success
9850 
   - utx
9851 
  """
9852 
 
9853 
  thrift_spec = (
9854 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9855 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9856 
  )
9857 
 
9858 
  def __init__(self, success=None, utx=None,):
9859 
    self.success = success
9860 
    self.utx = utx
9861 
 
9862 
  def read(self, iprot):
9863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9865 
      return
9866 
    iprot.readStructBegin()
9867 
    while True:
9868 
      (fname, ftype, fid) = iprot.readFieldBegin()
9869 
      if ftype == TType.STOP:
9870 
        break
9871 
      if fid == 0:
9872 
        if ftype == TType.I64:
9873 
          self.success = iprot.readI64();
9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      elif fid == 1:
9877 
        if ftype == TType.STRUCT:
1996 vikas 9878 
          self.utx = UserAffiliateException()
1845 vikas 9879 
          self.utx.read(iprot)
9880 
        else:
9881 
          iprot.skip(ftype)
9882 
      else:
9883 
        iprot.skip(ftype)
9884 
      iprot.readFieldEnd()
9885 
    iprot.readStructEnd()
9886 
 
9887 
  def write(self, oprot):
9888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9890 
      return
9891 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9892 
    if self.success is not None:
1845 vikas 9893 
      oprot.writeFieldBegin('success', TType.I64, 0)
9894 
      oprot.writeI64(self.success)
9895 
      oprot.writeFieldEnd()
3431 rajveer 9896 
    if self.utx is not None:
1845 vikas 9897 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9898 
      self.utx.write(oprot)
9899 
      oprot.writeFieldEnd()
9900 
    oprot.writeFieldStop()
9901 
    oprot.writeStructEnd()
9902 
 
3431 rajveer 9903 
  def validate(self):
9904 
    return
9905 
 
9906 
 
1845 vikas 9907 
  def __repr__(self):
9908 
    L = ['%s=%r' % (key, value)
9909 
      for key, value in self.__dict__.iteritems()]
9910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9911 
 
9912 
  def __eq__(self, other):
9913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9914 
 
9915 
  def __ne__(self, other):
9916 
    return not (self == other)
9917 
 
9918 
class getTrackLogById_args:
9919 
  """
9920 
  Attributes:
9921 
   - id
9922 
  """
9923 
 
9924 
  thrift_spec = (
9925 
    None, # 0
9926 
    (1, TType.I64, 'id', None, None, ), # 1
9927 
  )
9928 
 
9929 
  def __init__(self, id=None,):
9930 
    self.id = id
9931 
 
9932 
  def read(self, iprot):
9933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9935 
      return
9936 
    iprot.readStructBegin()
9937 
    while True:
9938 
      (fname, ftype, fid) = iprot.readFieldBegin()
9939 
      if ftype == TType.STOP:
9940 
        break
9941 
      if fid == 1:
9942 
        if ftype == TType.I64:
9943 
          self.id = iprot.readI64();
9944 
        else:
9945 
          iprot.skip(ftype)
9946 
      else:
9947 
        iprot.skip(ftype)
9948 
      iprot.readFieldEnd()
9949 
    iprot.readStructEnd()
9950 
 
9951 
  def write(self, oprot):
9952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9954 
      return
9955 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9956 
    if self.id is not None:
1845 vikas 9957 
      oprot.writeFieldBegin('id', TType.I64, 1)
9958 
      oprot.writeI64(self.id)
9959 
      oprot.writeFieldEnd()
9960 
    oprot.writeFieldStop()
9961 
    oprot.writeStructEnd()
9962 
 
3431 rajveer 9963 
  def validate(self):
9964 
    return
9965 
 
9966 
 
1845 vikas 9967 
  def __repr__(self):
9968 
    L = ['%s=%r' % (key, value)
9969 
      for key, value in self.__dict__.iteritems()]
9970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9971 
 
9972 
  def __eq__(self, other):
9973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9974 
 
9975 
  def __ne__(self, other):
9976 
    return not (self == other)
9977 
 
9978 
class getTrackLogById_result:
9979 
  """
9980 
  Attributes:
9981 
   - success
9982 
   - utx
9983 
  """
9984 
 
9985 
  thrift_spec = (
9986 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9987 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9988 
  )
9989 
 
9990 
  def __init__(self, success=None, utx=None,):
9991 
    self.success = success
9992 
    self.utx = utx
9993 
 
9994 
  def read(self, iprot):
9995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9997 
      return
9998 
    iprot.readStructBegin()
9999 
    while True:
10000 
      (fname, ftype, fid) = iprot.readFieldBegin()
10001 
      if ftype == TType.STOP:
10002 
        break
10003 
      if fid == 0:
10004 
        if ftype == TType.STRUCT:
10005 
          self.success = TrackLog()
10006 
          self.success.read(iprot)
10007 
        else:
10008 
          iprot.skip(ftype)
10009 
      elif fid == 1:
10010 
        if ftype == TType.STRUCT:
1996 vikas 10011 
          self.utx = UserAffiliateException()
1845 vikas 10012 
          self.utx.read(iprot)
10013 
        else:
10014 
          iprot.skip(ftype)
10015 
      else:
10016 
        iprot.skip(ftype)
10017 
      iprot.readFieldEnd()
10018 
    iprot.readStructEnd()
10019 
 
10020 
  def write(self, oprot):
10021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10023 
      return
10024 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10025 
    if self.success is not None:
1845 vikas 10026 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10027 
      self.success.write(oprot)
10028 
      oprot.writeFieldEnd()
3431 rajveer 10029 
    if self.utx is not None:
1845 vikas 10030 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10031 
      self.utx.write(oprot)
10032 
      oprot.writeFieldEnd()
10033 
    oprot.writeFieldStop()
10034 
    oprot.writeStructEnd()
10035 
 
3431 rajveer 10036 
  def validate(self):
10037 
    return
10038 
 
10039 
 
1845 vikas 10040 
  def __repr__(self):
10041 
    L = ['%s=%r' % (key, value)
10042 
      for key, value in self.__dict__.iteritems()]
10043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10044 
 
10045 
  def __eq__(self, other):
10046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10047 
 
10048 
  def __ne__(self, other):
10049 
    return not (self == other)
10050 
 
1996 vikas 10051 
class getTrackLogsByAffiliate_args:
1845 vikas 10052 
  """
10053 
  Attributes:
1996 vikas 10054 
   - affiliateId
3293 vikas 10055 
   - startDate
10056 
   - endDate
1845 vikas 10057 
  """
10058 
 
10059 
  thrift_spec = (
10060 
    None, # 0
1996 vikas 10061 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10062 
    (2, TType.I64, 'startDate', None, None, ), # 2
10063 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10064 
  )
10065 
 
3293 vikas 10066 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10067 
    self.affiliateId = affiliateId
3293 vikas 10068 
    self.startDate = startDate
10069 
    self.endDate = endDate
1845 vikas 10070 
 
10071 
  def read(self, iprot):
10072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10074 
      return
10075 
    iprot.readStructBegin()
10076 
    while True:
10077 
      (fname, ftype, fid) = iprot.readFieldBegin()
10078 
      if ftype == TType.STOP:
10079 
        break
10080 
      if fid == 1:
10081 
        if ftype == TType.I64:
1996 vikas 10082 
          self.affiliateId = iprot.readI64();
1845 vikas 10083 
        else:
10084 
          iprot.skip(ftype)
3293 vikas 10085 
      elif fid == 2:
10086 
        if ftype == TType.I64:
10087 
          self.startDate = iprot.readI64();
10088 
        else:
10089 
          iprot.skip(ftype)
10090 
      elif fid == 3:
10091 
        if ftype == TType.I64:
10092 
          self.endDate = iprot.readI64();
10093 
        else:
10094 
          iprot.skip(ftype)
1845 vikas 10095 
      else:
10096 
        iprot.skip(ftype)
10097 
      iprot.readFieldEnd()
10098 
    iprot.readStructEnd()
10099 
 
10100 
  def write(self, oprot):
10101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10103 
      return
1996 vikas 10104 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10105 
    if self.affiliateId is not None:
1996 vikas 10106 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10107 
      oprot.writeI64(self.affiliateId)
1845 vikas 10108 
      oprot.writeFieldEnd()
3431 rajveer 10109 
    if self.startDate is not None:
3293 vikas 10110 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10111 
      oprot.writeI64(self.startDate)
10112 
      oprot.writeFieldEnd()
3431 rajveer 10113 
    if self.endDate is not None:
3293 vikas 10114 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10115 
      oprot.writeI64(self.endDate)
10116 
      oprot.writeFieldEnd()
1845 vikas 10117 
    oprot.writeFieldStop()
10118 
    oprot.writeStructEnd()
10119 
 
3431 rajveer 10120 
  def validate(self):
10121 
    return
10122 
 
10123 
 
1845 vikas 10124 
  def __repr__(self):
10125 
    L = ['%s=%r' % (key, value)
10126 
      for key, value in self.__dict__.iteritems()]
10127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10128 
 
10129 
  def __eq__(self, other):
10130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10131 
 
10132 
  def __ne__(self, other):
10133 
    return not (self == other)
10134 
 
1996 vikas 10135 
class getTrackLogsByAffiliate_result:
1845 vikas 10136 
  """
10137 
  Attributes:
10138 
   - success
10139 
   - utx
10140 
  """
10141 
 
10142 
  thrift_spec = (
10143 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10144 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10145 
  )
10146 
 
10147 
  def __init__(self, success=None, utx=None,):
10148 
    self.success = success
10149 
    self.utx = utx
10150 
 
10151 
  def read(self, iprot):
10152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10154 
      return
10155 
    iprot.readStructBegin()
10156 
    while True:
10157 
      (fname, ftype, fid) = iprot.readFieldBegin()
10158 
      if ftype == TType.STOP:
10159 
        break
10160 
      if fid == 0:
10161 
        if ftype == TType.LIST:
10162 
          self.success = []
11592 amit.gupta 10163 
          (_etype135, _size132) = iprot.readListBegin()
10164 
          for _i136 in xrange(_size132):
10165 
            _elem137 = TrackLog()
10166 
            _elem137.read(iprot)
10167 
            self.success.append(_elem137)
1845 vikas 10168 
          iprot.readListEnd()
10169 
        else:
10170 
          iprot.skip(ftype)
10171 
      elif fid == 1:
10172 
        if ftype == TType.STRUCT:
1996 vikas 10173 
          self.utx = UserAffiliateException()
1845 vikas 10174 
          self.utx.read(iprot)
10175 
        else:
10176 
          iprot.skip(ftype)
10177 
      else:
10178 
        iprot.skip(ftype)
10179 
      iprot.readFieldEnd()
10180 
    iprot.readStructEnd()
10181 
 
10182 
  def write(self, oprot):
10183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10185 
      return
1996 vikas 10186 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10187 
    if self.success is not None:
1845 vikas 10188 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10189 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10190 
      for iter138 in self.success:
10191 
        iter138.write(oprot)
1845 vikas 10192 
      oprot.writeListEnd()
10193 
      oprot.writeFieldEnd()
3431 rajveer 10194 
    if self.utx is not None:
1845 vikas 10195 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10196 
      self.utx.write(oprot)
10197 
      oprot.writeFieldEnd()
10198 
    oprot.writeFieldStop()
10199 
    oprot.writeStructEnd()
10200 
 
3431 rajveer 10201 
  def validate(self):
10202 
    return
10203 
 
10204 
 
1845 vikas 10205 
  def __repr__(self):
10206 
    L = ['%s=%r' % (key, value)
10207 
      for key, value in self.__dict__.iteritems()]
10208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10209 
 
10210 
  def __eq__(self, other):
10211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10212 
 
10213 
  def __ne__(self, other):
10214 
    return not (self == other)
10215 
 
10216 
class getTrackLogsByUser_args:
10217 
  """
10218 
  Attributes:
10219 
   - userId
10220 
  """
10221 
 
10222 
  thrift_spec = (
10223 
    None, # 0
10224 
    (1, TType.I64, 'userId', None, None, ), # 1
10225 
  )
10226 
 
10227 
  def __init__(self, userId=None,):
10228 
    self.userId = userId
10229 
 
10230 
  def read(self, iprot):
10231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10233 
      return
10234 
    iprot.readStructBegin()
10235 
    while True:
10236 
      (fname, ftype, fid) = iprot.readFieldBegin()
10237 
      if ftype == TType.STOP:
10238 
        break
10239 
      if fid == 1:
10240 
        if ftype == TType.I64:
10241 
          self.userId = iprot.readI64();
10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      else:
10245 
        iprot.skip(ftype)
10246 
      iprot.readFieldEnd()
10247 
    iprot.readStructEnd()
10248 
 
10249 
  def write(self, oprot):
10250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10252 
      return
10253 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10254 
    if self.userId is not None:
1845 vikas 10255 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10256 
      oprot.writeI64(self.userId)
10257 
      oprot.writeFieldEnd()
10258 
    oprot.writeFieldStop()
10259 
    oprot.writeStructEnd()
10260 
 
3431 rajveer 10261 
  def validate(self):
10262 
    return
10263 
 
10264 
 
1845 vikas 10265 
  def __repr__(self):
10266 
    L = ['%s=%r' % (key, value)
10267 
      for key, value in self.__dict__.iteritems()]
10268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10269 
 
10270 
  def __eq__(self, other):
10271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10272 
 
10273 
  def __ne__(self, other):
10274 
    return not (self == other)
10275 
 
10276 
class getTrackLogsByUser_result:
10277 
  """
10278 
  Attributes:
10279 
   - success
10280 
   - utx
10281 
  """
10282 
 
10283 
  thrift_spec = (
10284 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10285 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10286 
  )
10287 
 
10288 
  def __init__(self, success=None, utx=None,):
10289 
    self.success = success
10290 
    self.utx = utx
10291 
 
10292 
  def read(self, iprot):
10293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10295 
      return
10296 
    iprot.readStructBegin()
10297 
    while True:
10298 
      (fname, ftype, fid) = iprot.readFieldBegin()
10299 
      if ftype == TType.STOP:
10300 
        break
10301 
      if fid == 0:
10302 
        if ftype == TType.LIST:
10303 
          self.success = []
11592 amit.gupta 10304 
          (_etype142, _size139) = iprot.readListBegin()
10305 
          for _i143 in xrange(_size139):
10306 
            _elem144 = TrackLog()
10307 
            _elem144.read(iprot)
10308 
            self.success.append(_elem144)
1845 vikas 10309 
          iprot.readListEnd()
10310 
        else:
10311 
          iprot.skip(ftype)
10312 
      elif fid == 1:
10313 
        if ftype == TType.STRUCT:
1996 vikas 10314 
          self.utx = UserAffiliateException()
1845 vikas 10315 
          self.utx.read(iprot)
10316 
        else:
10317 
          iprot.skip(ftype)
10318 
      else:
10319 
        iprot.skip(ftype)
10320 
      iprot.readFieldEnd()
10321 
    iprot.readStructEnd()
10322 
 
10323 
  def write(self, oprot):
10324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10326 
      return
10327 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10328 
    if self.success is not None:
1845 vikas 10329 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10330 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10331 
      for iter145 in self.success:
10332 
        iter145.write(oprot)
1845 vikas 10333 
      oprot.writeListEnd()
10334 
      oprot.writeFieldEnd()
3431 rajveer 10335 
    if self.utx is not None:
1845 vikas 10336 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10337 
      self.utx.write(oprot)
10338 
      oprot.writeFieldEnd()
10339 
    oprot.writeFieldStop()
10340 
    oprot.writeStructEnd()
10341 
 
3431 rajveer 10342 
  def validate(self):
10343 
    return
10344 
 
10345 
 
1845 vikas 10346 
  def __repr__(self):
10347 
    L = ['%s=%r' % (key, value)
10348 
      for key, value in self.__dict__.iteritems()]
10349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10350 
 
10351 
  def __eq__(self, other):
10352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10353 
 
10354 
  def __ne__(self, other):
10355 
    return not (self == other)
10356 
 
10357 
class getTrackLogs_args:
10358 
  """
10359 
  Attributes:
10360 
   - userId
10361 
   - event
10362 
   - url
10363 
  """
10364 
 
10365 
  thrift_spec = (
10366 
    None, # 0
1996 vikas 10367 
    (1, TType.I64, 'userId', None, None, ), # 1
10368 
    (2, TType.STRING, 'event', None, None, ), # 2
10369 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10370 
  )
10371 
 
1996 vikas 10372 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10373 
    self.userId = userId
10374 
    self.event = event
10375 
    self.url = url
10376 
 
10377 
  def read(self, iprot):
10378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10380 
      return
10381 
    iprot.readStructBegin()
10382 
    while True:
10383 
      (fname, ftype, fid) = iprot.readFieldBegin()
10384 
      if ftype == TType.STOP:
10385 
        break
10386 
      if fid == 1:
10387 
        if ftype == TType.I64:
1996 vikas 10388 
          self.userId = iprot.readI64();
1845 vikas 10389 
        else:
10390 
          iprot.skip(ftype)
10391 
      elif fid == 2:
10392 
        if ftype == TType.STRING:
10393 
          self.event = iprot.readString();
10394 
        else:
10395 
          iprot.skip(ftype)
1996 vikas 10396 
      elif fid == 3:
1845 vikas 10397 
        if ftype == TType.STRING:
10398 
          self.url = iprot.readString();
10399 
        else:
10400 
          iprot.skip(ftype)
10401 
      else:
10402 
        iprot.skip(ftype)
10403 
      iprot.readFieldEnd()
10404 
    iprot.readStructEnd()
10405 
 
10406 
  def write(self, oprot):
10407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10409 
      return
10410 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10411 
    if self.userId is not None:
1996 vikas 10412 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10413 
      oprot.writeI64(self.userId)
10414 
      oprot.writeFieldEnd()
3431 rajveer 10415 
    if self.event is not None:
1996 vikas 10416 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10417 
      oprot.writeString(self.event)
10418 
      oprot.writeFieldEnd()
3431 rajveer 10419 
    if self.url is not None:
1996 vikas 10420 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10421 
      oprot.writeString(self.url)
10422 
      oprot.writeFieldEnd()
10423 
    oprot.writeFieldStop()
10424 
    oprot.writeStructEnd()
10425 
 
3431 rajveer 10426 
  def validate(self):
10427 
    return
10428 
 
10429 
 
1845 vikas 10430 
  def __repr__(self):
10431 
    L = ['%s=%r' % (key, value)
10432 
      for key, value in self.__dict__.iteritems()]
10433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10434 
 
10435 
  def __eq__(self, other):
10436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10437 
 
10438 
  def __ne__(self, other):
10439 
    return not (self == other)
10440 
 
10441 
class getTrackLogs_result:
10442 
  """
10443 
  Attributes:
10444 
   - success
10445 
   - utx
10446 
  """
10447 
 
10448 
  thrift_spec = (
10449 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10450 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10451 
  )
10452 
 
10453 
  def __init__(self, success=None, utx=None,):
10454 
    self.success = success
10455 
    self.utx = utx
10456 
 
10457 
  def read(self, iprot):
10458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10460 
      return
10461 
    iprot.readStructBegin()
10462 
    while True:
10463 
      (fname, ftype, fid) = iprot.readFieldBegin()
10464 
      if ftype == TType.STOP:
10465 
        break
10466 
      if fid == 0:
10467 
        if ftype == TType.LIST:
10468 
          self.success = []
11592 amit.gupta 10469 
          (_etype149, _size146) = iprot.readListBegin()
10470 
          for _i150 in xrange(_size146):
10471 
            _elem151 = TrackLog()
10472 
            _elem151.read(iprot)
10473 
            self.success.append(_elem151)
1845 vikas 10474 
          iprot.readListEnd()
10475 
        else:
10476 
          iprot.skip(ftype)
10477 
      elif fid == 1:
10478 
        if ftype == TType.STRUCT:
1996 vikas 10479 
          self.utx = UserAffiliateException()
1845 vikas 10480 
          self.utx.read(iprot)
10481 
        else:
10482 
          iprot.skip(ftype)
10483 
      else:
10484 
        iprot.skip(ftype)
10485 
      iprot.readFieldEnd()
10486 
    iprot.readStructEnd()
10487 
 
10488 
  def write(self, oprot):
10489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10491 
      return
10492 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10493 
    if self.success is not None:
1845 vikas 10494 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10495 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10496 
      for iter152 in self.success:
10497 
        iter152.write(oprot)
1845 vikas 10498 
      oprot.writeListEnd()
10499 
      oprot.writeFieldEnd()
3431 rajveer 10500 
    if self.utx is not None:
1845 vikas 10501 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10502 
      self.utx.write(oprot)
10503 
      oprot.writeFieldEnd()
10504 
    oprot.writeFieldStop()
10505 
    oprot.writeStructEnd()
10506 
 
3431 rajveer 10507 
  def validate(self):
10508 
    return
10509 
 
10510 
 
1845 vikas 10511 
  def __repr__(self):
10512 
    L = ['%s=%r' % (key, value)
10513 
      for key, value in self.__dict__.iteritems()]
10514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10515 
 
10516 
  def __eq__(self, other):
10517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10518 
 
10519 
  def __ne__(self, other):
10520 
    return not (self == other)
10521 
 
559 chandransh 10522 
class getCurrentCart_args:
94 ashish 10523 
  """
10524 
  Attributes:
559 chandransh 10525 
   - userId
10526 
  """
10527 
 
10528 
  thrift_spec = (
10529 
    None, # 0
10530 
    (1, TType.I64, 'userId', None, None, ), # 1
10531 
  )
10532 
 
10533 
  def __init__(self, userId=None,):
10534 
    self.userId = userId
10535 
 
10536 
  def read(self, iprot):
10537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10539 
      return
10540 
    iprot.readStructBegin()
10541 
    while True:
10542 
      (fname, ftype, fid) = iprot.readFieldBegin()
10543 
      if ftype == TType.STOP:
10544 
        break
10545 
      if fid == 1:
10546 
        if ftype == TType.I64:
10547 
          self.userId = iprot.readI64();
10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      else:
10551 
        iprot.skip(ftype)
10552 
      iprot.readFieldEnd()
10553 
    iprot.readStructEnd()
10554 
 
10555 
  def write(self, oprot):
10556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10558 
      return
10559 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10560 
    if self.userId is not None:
559 chandransh 10561 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10562 
      oprot.writeI64(self.userId)
10563 
      oprot.writeFieldEnd()
10564 
    oprot.writeFieldStop()
10565 
    oprot.writeStructEnd()
10566 
 
3431 rajveer 10567 
  def validate(self):
10568 
    return
10569 
 
10570 
 
559 chandransh 10571 
  def __repr__(self):
10572 
    L = ['%s=%r' % (key, value)
10573 
      for key, value in self.__dict__.iteritems()]
10574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10575 
 
10576 
  def __eq__(self, other):
10577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10578 
 
10579 
  def __ne__(self, other):
10580 
    return not (self == other)
10581 
 
10582 
class getCurrentCart_result:
10583 
  """
10584 
  Attributes:
94 ashish 10585 
   - success
559 chandransh 10586 
   - scx
94 ashish 10587 
  """
10588 
 
10589 
  thrift_spec = (
559 chandransh 10590 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10591 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10592 
  )
10593 
 
559 chandransh 10594 
  def __init__(self, success=None, scx=None,):
94 ashish 10595 
    self.success = success
559 chandransh 10596 
    self.scx = scx
94 ashish 10597 
 
10598 
  def read(self, iprot):
10599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10601 
      return
10602 
    iprot.readStructBegin()
10603 
    while True:
10604 
      (fname, ftype, fid) = iprot.readFieldBegin()
10605 
      if ftype == TType.STOP:
10606 
        break
10607 
      if fid == 0:
559 chandransh 10608 
        if ftype == TType.STRUCT:
10609 
          self.success = Cart()
10610 
          self.success.read(iprot)
94 ashish 10611 
        else:
10612 
          iprot.skip(ftype)
10613 
      elif fid == 1:
10614 
        if ftype == TType.STRUCT:
559 chandransh 10615 
          self.scx = ShoppingCartException()
10616 
          self.scx.read(iprot)
94 ashish 10617 
        else:
10618 
          iprot.skip(ftype)
10619 
      else:
10620 
        iprot.skip(ftype)
10621 
      iprot.readFieldEnd()
10622 
    iprot.readStructEnd()
10623 
 
10624 
  def write(self, oprot):
10625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10627 
      return
559 chandransh 10628 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10629 
    if self.success is not None:
559 chandransh 10630 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10631 
      self.success.write(oprot)
94 ashish 10632 
      oprot.writeFieldEnd()
3431 rajveer 10633 
    if self.scx is not None:
559 chandransh 10634 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10635 
      self.scx.write(oprot)
94 ashish 10636 
      oprot.writeFieldEnd()
10637 
    oprot.writeFieldStop()
10638 
    oprot.writeStructEnd()
10639 
 
3431 rajveer 10640 
  def validate(self):
10641 
    return
10642 
 
10643 
 
94 ashish 10644 
  def __repr__(self):
10645 
    L = ['%s=%r' % (key, value)
10646 
      for key, value in self.__dict__.iteritems()]
10647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10648 
 
10649 
  def __eq__(self, other):
10650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10651 
 
10652 
  def __ne__(self, other):
10653 
    return not (self == other)
10654 
 
559 chandransh 10655 
class getCart_args:
504 rajveer 10656 
  """
10657 
  Attributes:
559 chandransh 10658 
   - cartId
504 rajveer 10659 
  """
10660 
 
10661 
  thrift_spec = (
10662 
    None, # 0
559 chandransh 10663 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10664 
  )
10665 
 
559 chandransh 10666 
  def __init__(self, cartId=None,):
10667 
    self.cartId = cartId
504 rajveer 10668 
 
10669 
  def read(self, iprot):
10670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10672 
      return
10673 
    iprot.readStructBegin()
10674 
    while True:
10675 
      (fname, ftype, fid) = iprot.readFieldBegin()
10676 
      if ftype == TType.STOP:
10677 
        break
10678 
      if fid == 1:
10679 
        if ftype == TType.I64:
559 chandransh 10680 
          self.cartId = iprot.readI64();
504 rajveer 10681 
        else:
10682 
          iprot.skip(ftype)
10683 
      else:
10684 
        iprot.skip(ftype)
10685 
      iprot.readFieldEnd()
10686 
    iprot.readStructEnd()
10687 
 
10688 
  def write(self, oprot):
10689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10691 
      return
559 chandransh 10692 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10693 
    if self.cartId is not None:
559 chandransh 10694 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10695 
      oprot.writeI64(self.cartId)
504 rajveer 10696 
      oprot.writeFieldEnd()
10697 
    oprot.writeFieldStop()
10698 
    oprot.writeStructEnd()
10699 
 
3431 rajveer 10700 
  def validate(self):
10701 
    return
10702 
 
10703 
 
504 rajveer 10704 
  def __repr__(self):
10705 
    L = ['%s=%r' % (key, value)
10706 
      for key, value in self.__dict__.iteritems()]
10707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10708 
 
10709 
  def __eq__(self, other):
10710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10711 
 
10712 
  def __ne__(self, other):
10713 
    return not (self == other)
10714 
 
559 chandransh 10715 
class getCart_result:
504 rajveer 10716 
  """
10717 
  Attributes:
10718 
   - success
559 chandransh 10719 
   - scx
504 rajveer 10720 
  """
10721 
 
10722 
  thrift_spec = (
559 chandransh 10723 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10724 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10725 
  )
10726 
 
559 chandransh 10727 
  def __init__(self, success=None, scx=None,):
504 rajveer 10728 
    self.success = success
559 chandransh 10729 
    self.scx = scx
504 rajveer 10730 
 
10731 
  def read(self, iprot):
10732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10734 
      return
10735 
    iprot.readStructBegin()
10736 
    while True:
10737 
      (fname, ftype, fid) = iprot.readFieldBegin()
10738 
      if ftype == TType.STOP:
10739 
        break
10740 
      if fid == 0:
559 chandransh 10741 
        if ftype == TType.STRUCT:
10742 
          self.success = Cart()
10743 
          self.success.read(iprot)
504 rajveer 10744 
        else:
10745 
          iprot.skip(ftype)
10746 
      elif fid == 1:
10747 
        if ftype == TType.STRUCT:
559 chandransh 10748 
          self.scx = ShoppingCartException()
10749 
          self.scx.read(iprot)
504 rajveer 10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      else:
10753 
        iprot.skip(ftype)
10754 
      iprot.readFieldEnd()
10755 
    iprot.readStructEnd()
10756 
 
10757 
  def write(self, oprot):
10758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10760 
      return
559 chandransh 10761 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10762 
    if self.success is not None:
559 chandransh 10763 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10764 
      self.success.write(oprot)
504 rajveer 10765 
      oprot.writeFieldEnd()
3431 rajveer 10766 
    if self.scx is not None:
559 chandransh 10767 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10768 
      self.scx.write(oprot)
504 rajveer 10769 
      oprot.writeFieldEnd()
10770 
    oprot.writeFieldStop()
10771 
    oprot.writeStructEnd()
10772 
 
3431 rajveer 10773 
  def validate(self):
10774 
    return
10775 
 
10776 
 
504 rajveer 10777 
  def __repr__(self):
10778 
    L = ['%s=%r' % (key, value)
10779 
      for key, value in self.__dict__.iteritems()]
10780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10781 
 
10782 
  def __eq__(self, other):
10783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10784 
 
10785 
  def __ne__(self, other):
10786 
    return not (self == other)
10787 
 
559 chandransh 10788 
class getCartsByTime_args:
10789 
  """
10790 
  Attributes:
10791 
   - from_time
10792 
   - to_time
10793 
   - status
10794 
  """
10795 
 
10796 
  thrift_spec = (
10797 
    None, # 0
10798 
    (1, TType.I64, 'from_time', None, None, ), # 1
10799 
    (2, TType.I64, 'to_time', None, None, ), # 2
10800 
    (3, TType.I32, 'status', None, None, ), # 3
10801 
  )
10802 
 
10803 
  def __init__(self, from_time=None, to_time=None, status=None,):
10804 
    self.from_time = from_time
10805 
    self.to_time = to_time
10806 
    self.status = status
10807 
 
10808 
  def read(self, iprot):
10809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10811 
      return
10812 
    iprot.readStructBegin()
10813 
    while True:
10814 
      (fname, ftype, fid) = iprot.readFieldBegin()
10815 
      if ftype == TType.STOP:
10816 
        break
10817 
      if fid == 1:
94 ashish 10818 
        if ftype == TType.I64:
559 chandransh 10819 
          self.from_time = iprot.readI64();
94 ashish 10820 
        else:
10821 
          iprot.skip(ftype)
122 ashish 10822 
      elif fid == 2:
559 chandransh 10823 
        if ftype == TType.I64:
10824 
          self.to_time = iprot.readI64();
122 ashish 10825 
        else:
10826 
          iprot.skip(ftype)
559 chandransh 10827 
      elif fid == 3:
10828 
        if ftype == TType.I32:
10829 
          self.status = iprot.readI32();
10830 
        else:
10831 
          iprot.skip(ftype)
94 ashish 10832 
      else:
10833 
        iprot.skip(ftype)
10834 
      iprot.readFieldEnd()
10835 
    iprot.readStructEnd()
10836 
 
10837 
  def write(self, oprot):
10838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10840 
      return
559 chandransh 10841 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10842 
    if self.from_time is not None:
559 chandransh 10843 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10844 
      oprot.writeI64(self.from_time)
94 ashish 10845 
      oprot.writeFieldEnd()
3431 rajveer 10846 
    if self.to_time is not None:
559 chandransh 10847 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10848 
      oprot.writeI64(self.to_time)
122 ashish 10849 
      oprot.writeFieldEnd()
3431 rajveer 10850 
    if self.status is not None:
559 chandransh 10851 
      oprot.writeFieldBegin('status', TType.I32, 3)
10852 
      oprot.writeI32(self.status)
10853 
      oprot.writeFieldEnd()
94 ashish 10854 
    oprot.writeFieldStop()
10855 
    oprot.writeStructEnd()
10856 
 
3431 rajveer 10857 
  def validate(self):
10858 
    return
10859 
 
10860 
 
94 ashish 10861 
  def __repr__(self):
10862 
    L = ['%s=%r' % (key, value)
10863 
      for key, value in self.__dict__.iteritems()]
10864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10865 
 
10866 
  def __eq__(self, other):
10867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10868 
 
10869 
  def __ne__(self, other):
10870 
    return not (self == other)
10871 
 
559 chandransh 10872 
class getCartsByTime_result:
94 ashish 10873 
  """
10874 
  Attributes:
10875 
   - success
559 chandransh 10876 
   - scx
94 ashish 10877 
  """
10878 
 
10879 
  thrift_spec = (
559 chandransh 10880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10881 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10882 
  )
10883 
 
559 chandransh 10884 
  def __init__(self, success=None, scx=None,):
94 ashish 10885 
    self.success = success
559 chandransh 10886 
    self.scx = scx
94 ashish 10887 
 
10888 
  def read(self, iprot):
10889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10891 
      return
10892 
    iprot.readStructBegin()
10893 
    while True:
10894 
      (fname, ftype, fid) = iprot.readFieldBegin()
10895 
      if ftype == TType.STOP:
10896 
        break
10897 
      if fid == 0:
559 chandransh 10898 
        if ftype == TType.LIST:
10899 
          self.success = []
11592 amit.gupta 10900 
          (_etype156, _size153) = iprot.readListBegin()
10901 
          for _i157 in xrange(_size153):
10902 
            _elem158 = Cart()
10903 
            _elem158.read(iprot)
10904 
            self.success.append(_elem158)
559 chandransh 10905 
          iprot.readListEnd()
94 ashish 10906 
        else:
10907 
          iprot.skip(ftype)
10908 
      elif fid == 1:
10909 
        if ftype == TType.STRUCT:
559 chandransh 10910 
          self.scx = ShoppingCartException()
10911 
          self.scx.read(iprot)
94 ashish 10912 
        else:
10913 
          iprot.skip(ftype)
10914 
      else:
10915 
        iprot.skip(ftype)
10916 
      iprot.readFieldEnd()
10917 
    iprot.readStructEnd()
10918 
 
10919 
  def write(self, oprot):
10920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10922 
      return
559 chandransh 10923 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10924 
    if self.success is not None:
559 chandransh 10925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10927 
      for iter159 in self.success:
10928 
        iter159.write(oprot)
559 chandransh 10929 
      oprot.writeListEnd()
94 ashish 10930 
      oprot.writeFieldEnd()
3431 rajveer 10931 
    if self.scx is not None:
559 chandransh 10932 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10933 
      self.scx.write(oprot)
94 ashish 10934 
      oprot.writeFieldEnd()
10935 
    oprot.writeFieldStop()
10936 
    oprot.writeStructEnd()
10937 
 
3431 rajveer 10938 
  def validate(self):
10939 
    return
10940 
 
10941 
 
94 ashish 10942 
  def __repr__(self):
10943 
    L = ['%s=%r' % (key, value)
10944 
      for key, value in self.__dict__.iteritems()]
10945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10946 
 
10947 
  def __eq__(self, other):
10948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10949 
 
10950 
  def __ne__(self, other):
10951 
    return not (self == other)
10952 
 
559 chandransh 10953 
class addItemToCart_args:
10954 
  """
10955 
  Attributes:
10956 
   - cartId
10957 
   - itemId
10958 
   - quantity
3557 rajveer 10959 
   - sourceId
559 chandransh 10960 
  """
10961 
 
10962 
  thrift_spec = (
10963 
    None, # 0
10964 
    (1, TType.I64, 'cartId', None, None, ), # 1
10965 
    (2, TType.I64, 'itemId', None, None, ), # 2
10966 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10967 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10968 
  )
10969 
 
3557 rajveer 10970 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10971 
    self.cartId = cartId
10972 
    self.itemId = itemId
10973 
    self.quantity = quantity
3557 rajveer 10974 
    self.sourceId = sourceId
559 chandransh 10975 
 
10976 
  def read(self, iprot):
10977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10979 
      return
10980 
    iprot.readStructBegin()
10981 
    while True:
10982 
      (fname, ftype, fid) = iprot.readFieldBegin()
10983 
      if ftype == TType.STOP:
10984 
        break
10985 
      if fid == 1:
10986 
        if ftype == TType.I64:
10987 
          self.cartId = iprot.readI64();
10988 
        else:
10989 
          iprot.skip(ftype)
10990 
      elif fid == 2:
10991 
        if ftype == TType.I64:
10992 
          self.itemId = iprot.readI64();
10993 
        else:
10994 
          iprot.skip(ftype)
10995 
      elif fid == 3:
10996 
        if ftype == TType.I64:
10997 
          self.quantity = iprot.readI64();
10998 
        else:
10999 
          iprot.skip(ftype)
3557 rajveer 11000 
      elif fid == 4:
11001 
        if ftype == TType.I64:
11002 
          self.sourceId = iprot.readI64();
11003 
        else:
11004 
          iprot.skip(ftype)
559 chandransh 11005 
      else:
11006 
        iprot.skip(ftype)
11007 
      iprot.readFieldEnd()
11008 
    iprot.readStructEnd()
11009 
 
11010 
  def write(self, oprot):
11011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11013 
      return
11014 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11015 
    if self.cartId is not None:
559 chandransh 11016 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11017 
      oprot.writeI64(self.cartId)
11018 
      oprot.writeFieldEnd()
3431 rajveer 11019 
    if self.itemId is not None:
559 chandransh 11020 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11021 
      oprot.writeI64(self.itemId)
11022 
      oprot.writeFieldEnd()
3431 rajveer 11023 
    if self.quantity is not None:
559 chandransh 11024 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11025 
      oprot.writeI64(self.quantity)
11026 
      oprot.writeFieldEnd()
3557 rajveer 11027 
    if self.sourceId is not None:
11028 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11029 
      oprot.writeI64(self.sourceId)
11030 
      oprot.writeFieldEnd()
559 chandransh 11031 
    oprot.writeFieldStop()
11032 
    oprot.writeStructEnd()
11033 
 
3431 rajveer 11034 
  def validate(self):
11035 
    return
11036 
 
11037 
 
559 chandransh 11038 
  def __repr__(self):
11039 
    L = ['%s=%r' % (key, value)
11040 
      for key, value in self.__dict__.iteritems()]
11041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11042 
 
11043 
  def __eq__(self, other):
11044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11045 
 
11046 
  def __ne__(self, other):
11047 
    return not (self == other)
11048 
 
11049 
class addItemToCart_result:
11050 
  """
11051 
  Attributes:
2035 rajveer 11052 
   - success
559 chandransh 11053 
   - scx
11054 
  """
11055 
 
11056 
  thrift_spec = (
2035 rajveer 11057 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11058 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11059 
  )
11060 
 
2035 rajveer 11061 
  def __init__(self, success=None, scx=None,):
11062 
    self.success = success
559 chandransh 11063 
    self.scx = scx
11064 
 
11065 
  def read(self, iprot):
11066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11068 
      return
11069 
    iprot.readStructBegin()
11070 
    while True:
11071 
      (fname, ftype, fid) = iprot.readFieldBegin()
11072 
      if ftype == TType.STOP:
11073 
        break
2035 rajveer 11074 
      if fid == 0:
11075 
        if ftype == TType.STRING:
11076 
          self.success = iprot.readString();
11077 
        else:
11078 
          iprot.skip(ftype)
11079 
      elif fid == 1:
559 chandransh 11080 
        if ftype == TType.STRUCT:
11081 
          self.scx = ShoppingCartException()
11082 
          self.scx.read(iprot)
11083 
        else:
11084 
          iprot.skip(ftype)
11085 
      else:
11086 
        iprot.skip(ftype)
11087 
      iprot.readFieldEnd()
11088 
    iprot.readStructEnd()
11089 
 
11090 
  def write(self, oprot):
11091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11093 
      return
11094 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11095 
    if self.success is not None:
2035 rajveer 11096 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11097 
      oprot.writeString(self.success)
11098 
      oprot.writeFieldEnd()
3431 rajveer 11099 
    if self.scx is not None:
559 chandransh 11100 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11101 
      self.scx.write(oprot)
11102 
      oprot.writeFieldEnd()
11103 
    oprot.writeFieldStop()
11104 
    oprot.writeStructEnd()
11105 
 
3431 rajveer 11106 
  def validate(self):
11107 
    return
11108 
 
11109 
 
559 chandransh 11110 
  def __repr__(self):
11111 
    L = ['%s=%r' % (key, value)
11112 
      for key, value in self.__dict__.iteritems()]
11113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11114 
 
11115 
  def __eq__(self, other):
11116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11117 
 
11118 
  def __ne__(self, other):
11119 
    return not (self == other)
11120 
 
11121 
class deleteItemFromCart_args:
11122 
  """
11123 
  Attributes:
11124 
   - cartId
11125 
   - itemId
11126 
  """
11127 
 
11128 
  thrift_spec = (
11129 
    None, # 0
11130 
    (1, TType.I64, 'cartId', None, None, ), # 1
11131 
    (2, TType.I64, 'itemId', None, None, ), # 2
11132 
  )
11133 
 
11134 
  def __init__(self, cartId=None, itemId=None,):
11135 
    self.cartId = cartId
11136 
    self.itemId = itemId
11137 
 
11138 
  def read(self, iprot):
11139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11141 
      return
11142 
    iprot.readStructBegin()
11143 
    while True:
11144 
      (fname, ftype, fid) = iprot.readFieldBegin()
11145 
      if ftype == TType.STOP:
11146 
        break
11147 
      if fid == 1:
11148 
        if ftype == TType.I64:
11149 
          self.cartId = iprot.readI64();
11150 
        else:
11151 
          iprot.skip(ftype)
11152 
      elif fid == 2:
11153 
        if ftype == TType.I64:
11154 
          self.itemId = iprot.readI64();
11155 
        else:
11156 
          iprot.skip(ftype)
11157 
      else:
11158 
        iprot.skip(ftype)
11159 
      iprot.readFieldEnd()
11160 
    iprot.readStructEnd()
11161 
 
11162 
  def write(self, oprot):
11163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11165 
      return
11166 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11167 
    if self.cartId is not None:
559 chandransh 11168 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11169 
      oprot.writeI64(self.cartId)
11170 
      oprot.writeFieldEnd()
3431 rajveer 11171 
    if self.itemId is not None:
559 chandransh 11172 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11173 
      oprot.writeI64(self.itemId)
11174 
      oprot.writeFieldEnd()
11175 
    oprot.writeFieldStop()
11176 
    oprot.writeStructEnd()
11177 
 
3431 rajveer 11178 
  def validate(self):
11179 
    return
11180 
 
11181 
 
559 chandransh 11182 
  def __repr__(self):
11183 
    L = ['%s=%r' % (key, value)
11184 
      for key, value in self.__dict__.iteritems()]
11185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11186 
 
11187 
  def __eq__(self, other):
11188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11189 
 
11190 
  def __ne__(self, other):
11191 
    return not (self == other)
11192 
 
11193 
class deleteItemFromCart_result:
11194 
  """
11195 
  Attributes:
11196 
   - scx
11197 
  """
11198 
 
11199 
  thrift_spec = (
11200 
    None, # 0
11201 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11202 
  )
11203 
 
11204 
  def __init__(self, scx=None,):
11205 
    self.scx = scx
11206 
 
11207 
  def read(self, iprot):
11208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11210 
      return
11211 
    iprot.readStructBegin()
11212 
    while True:
11213 
      (fname, ftype, fid) = iprot.readFieldBegin()
11214 
      if ftype == TType.STOP:
11215 
        break
11216 
      if fid == 1:
11217 
        if ftype == TType.STRUCT:
11218 
          self.scx = ShoppingCartException()
11219 
          self.scx.read(iprot)
11220 
        else:
11221 
          iprot.skip(ftype)
11222 
      else:
11223 
        iprot.skip(ftype)
11224 
      iprot.readFieldEnd()
11225 
    iprot.readStructEnd()
11226 
 
11227 
  def write(self, oprot):
11228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11230 
      return
11231 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11232 
    if self.scx is not None:
559 chandransh 11233 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11234 
      self.scx.write(oprot)
11235 
      oprot.writeFieldEnd()
11236 
    oprot.writeFieldStop()
11237 
    oprot.writeStructEnd()
11238 
 
3431 rajveer 11239 
  def validate(self):
11240 
    return
11241 
 
11242 
 
559 chandransh 11243 
  def __repr__(self):
11244 
    L = ['%s=%r' % (key, value)
11245 
      for key, value in self.__dict__.iteritems()]
11246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11247 
 
11248 
  def __eq__(self, other):
11249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11250 
 
11251 
  def __ne__(self, other):
11252 
    return not (self == other)
11253 
 
11254 
class addAddressToCart_args:
11255 
  """
11256 
  Attributes:
11257 
   - cartId
11258 
   - addressId
11259 
  """
11260 
 
11261 
  thrift_spec = (
11262 
    None, # 0
11263 
    (1, TType.I64, 'cartId', None, None, ), # 1
11264 
    (2, TType.I64, 'addressId', None, None, ), # 2
11265 
  )
11266 
 
11267 
  def __init__(self, cartId=None, addressId=None,):
11268 
    self.cartId = cartId
11269 
    self.addressId = addressId
11270 
 
11271 
  def read(self, iprot):
11272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11274 
      return
11275 
    iprot.readStructBegin()
11276 
    while True:
11277 
      (fname, ftype, fid) = iprot.readFieldBegin()
11278 
      if ftype == TType.STOP:
11279 
        break
11280 
      if fid == 1:
11281 
        if ftype == TType.I64:
11282 
          self.cartId = iprot.readI64();
11283 
        else:
11284 
          iprot.skip(ftype)
11285 
      elif fid == 2:
11286 
        if ftype == TType.I64:
11287 
          self.addressId = iprot.readI64();
11288 
        else:
11289 
          iprot.skip(ftype)
11290 
      else:
11291 
        iprot.skip(ftype)
11292 
      iprot.readFieldEnd()
11293 
    iprot.readStructEnd()
11294 
 
11295 
  def write(self, oprot):
11296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11298 
      return
11299 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11300 
    if self.cartId is not None:
559 chandransh 11301 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11302 
      oprot.writeI64(self.cartId)
11303 
      oprot.writeFieldEnd()
3431 rajveer 11304 
    if self.addressId is not None:
559 chandransh 11305 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11306 
      oprot.writeI64(self.addressId)
11307 
      oprot.writeFieldEnd()
11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
3431 rajveer 11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
559 chandransh 11315 
  def __repr__(self):
11316 
    L = ['%s=%r' % (key, value)
11317 
      for key, value in self.__dict__.iteritems()]
11318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11319 
 
11320 
  def __eq__(self, other):
11321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11322 
 
11323 
  def __ne__(self, other):
11324 
    return not (self == other)
11325 
 
11326 
class addAddressToCart_result:
575 chandransh 11327 
  """
11328 
  Attributes:
11329 
   - scx
11330 
  """
559 chandransh 11331 
 
11332 
  thrift_spec = (
575 chandransh 11333 
    None, # 0
11334 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11335 
  )
11336 
 
575 chandransh 11337 
  def __init__(self, scx=None,):
11338 
    self.scx = scx
11339 
 
559 chandransh 11340 
  def read(self, iprot):
11341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11343 
      return
11344 
    iprot.readStructBegin()
11345 
    while True:
11346 
      (fname, ftype, fid) = iprot.readFieldBegin()
11347 
      if ftype == TType.STOP:
11348 
        break
575 chandransh 11349 
      if fid == 1:
11350 
        if ftype == TType.STRUCT:
11351 
          self.scx = ShoppingCartException()
11352 
          self.scx.read(iprot)
11353 
        else:
11354 
          iprot.skip(ftype)
559 chandransh 11355 
      else:
11356 
        iprot.skip(ftype)
11357 
      iprot.readFieldEnd()
11358 
    iprot.readStructEnd()
11359 
 
11360 
  def write(self, oprot):
11361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11363 
      return
11364 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11365 
    if self.scx is not None:
575 chandransh 11366 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11367 
      self.scx.write(oprot)
11368 
      oprot.writeFieldEnd()
559 chandransh 11369 
    oprot.writeFieldStop()
11370 
    oprot.writeStructEnd()
11371 
 
3431 rajveer 11372 
  def validate(self):
11373 
    return
11374 
 
11375 
 
559 chandransh 11376 
  def __repr__(self):
11377 
    L = ['%s=%r' % (key, value)
11378 
      for key, value in self.__dict__.iteritems()]
11379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11380 
 
11381 
  def __eq__(self, other):
11382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11383 
 
11384 
  def __ne__(self, other):
11385 
    return not (self == other)
11386 
 
5553 rajveer 11387 
class addStoreToCart_args:
11388 
  """
11389 
  Attributes:
11390 
   - cartId
11391 
   - storeId
11392 
  """
11393 
 
11394 
  thrift_spec = (
11395 
    None, # 0
11396 
    (1, TType.I64, 'cartId', None, None, ), # 1
11397 
    (2, TType.I64, 'storeId', None, None, ), # 2
11398 
  )
11399 
 
11400 
  def __init__(self, cartId=None, storeId=None,):
11401 
    self.cartId = cartId
11402 
    self.storeId = storeId
11403 
 
11404 
  def read(self, iprot):
11405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11407 
      return
11408 
    iprot.readStructBegin()
11409 
    while True:
11410 
      (fname, ftype, fid) = iprot.readFieldBegin()
11411 
      if ftype == TType.STOP:
11412 
        break
11413 
      if fid == 1:
11414 
        if ftype == TType.I64:
11415 
          self.cartId = iprot.readI64();
11416 
        else:
11417 
          iprot.skip(ftype)
11418 
      elif fid == 2:
11419 
        if ftype == TType.I64:
11420 
          self.storeId = iprot.readI64();
11421 
        else:
11422 
          iprot.skip(ftype)
11423 
      else:
11424 
        iprot.skip(ftype)
11425 
      iprot.readFieldEnd()
11426 
    iprot.readStructEnd()
11427 
 
11428 
  def write(self, oprot):
11429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11431 
      return
11432 
    oprot.writeStructBegin('addStoreToCart_args')
11433 
    if self.cartId is not None:
11434 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11435 
      oprot.writeI64(self.cartId)
11436 
      oprot.writeFieldEnd()
11437 
    if self.storeId is not None:
11438 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11439 
      oprot.writeI64(self.storeId)
11440 
      oprot.writeFieldEnd()
11441 
    oprot.writeFieldStop()
11442 
    oprot.writeStructEnd()
11443 
 
11444 
  def validate(self):
11445 
    return
11446 
 
11447 
 
11448 
  def __repr__(self):
11449 
    L = ['%s=%r' % (key, value)
11450 
      for key, value in self.__dict__.iteritems()]
11451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11452 
 
11453 
  def __eq__(self, other):
11454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11455 
 
11456 
  def __ne__(self, other):
11457 
    return not (self == other)
11458 
 
11459 
class addStoreToCart_result:
11460 
  """
11461 
  Attributes:
11462 
   - scx
11463 
  """
11464 
 
11465 
  thrift_spec = (
11466 
    None, # 0
11467 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11468 
  )
11469 
 
11470 
  def __init__(self, scx=None,):
11471 
    self.scx = scx
11472 
 
11473 
  def read(self, iprot):
11474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11476 
      return
11477 
    iprot.readStructBegin()
11478 
    while True:
11479 
      (fname, ftype, fid) = iprot.readFieldBegin()
11480 
      if ftype == TType.STOP:
11481 
        break
11482 
      if fid == 1:
11483 
        if ftype == TType.STRUCT:
11484 
          self.scx = ShoppingCartException()
11485 
          self.scx.read(iprot)
11486 
        else:
11487 
          iprot.skip(ftype)
11488 
      else:
11489 
        iprot.skip(ftype)
11490 
      iprot.readFieldEnd()
11491 
    iprot.readStructEnd()
11492 
 
11493 
  def write(self, oprot):
11494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11496 
      return
11497 
    oprot.writeStructBegin('addStoreToCart_result')
11498 
    if self.scx is not None:
11499 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11500 
      self.scx.write(oprot)
11501 
      oprot.writeFieldEnd()
11502 
    oprot.writeFieldStop()
11503 
    oprot.writeStructEnd()
11504 
 
11505 
  def validate(self):
11506 
    return
11507 
 
11508 
 
11509 
  def __repr__(self):
11510 
    L = ['%s=%r' % (key, value)
11511 
      for key, value in self.__dict__.iteritems()]
11512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11513 
 
11514 
  def __eq__(self, other):
11515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11516 
 
11517 
  def __ne__(self, other):
11518 
    return not (self == other)
11519 
 
1976 varun.gupt 11520 
class applyCouponToCart_args:
11521 
  """
11522 
  Attributes:
6922 anupam.sin 11523 
   - cart
1976 varun.gupt 11524 
   - couponCode
11525 
  """
11526 
 
11527 
  thrift_spec = (
11528 
    None, # 0
6922 anupam.sin 11529 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11530 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11531 
  )
11532 
 
6922 anupam.sin 11533 
  def __init__(self, cart=None, couponCode=None,):
11534 
    self.cart = cart
1976 varun.gupt 11535 
    self.couponCode = couponCode
11536 
 
11537 
  def read(self, iprot):
11538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11540 
      return
11541 
    iprot.readStructBegin()
11542 
    while True:
11543 
      (fname, ftype, fid) = iprot.readFieldBegin()
11544 
      if ftype == TType.STOP:
11545 
        break
11546 
      if fid == 1:
6922 anupam.sin 11547 
        if ftype == TType.STRUCT:
11548 
          self.cart = Cart()
11549 
          self.cart.read(iprot)
1976 varun.gupt 11550 
        else:
11551 
          iprot.skip(ftype)
11552 
      elif fid == 2:
11553 
        if ftype == TType.STRING:
11554 
          self.couponCode = iprot.readString();
11555 
        else:
11556 
          iprot.skip(ftype)
11557 
      else:
11558 
        iprot.skip(ftype)
11559 
      iprot.readFieldEnd()
11560 
    iprot.readStructEnd()
11561 
 
11562 
  def write(self, oprot):
11563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11565 
      return
11566 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11567 
    if self.cart is not None:
11568 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11569 
      self.cart.write(oprot)
1976 varun.gupt 11570 
      oprot.writeFieldEnd()
3431 rajveer 11571 
    if self.couponCode is not None:
1976 varun.gupt 11572 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11573 
      oprot.writeString(self.couponCode)
11574 
      oprot.writeFieldEnd()
11575 
    oprot.writeFieldStop()
11576 
    oprot.writeStructEnd()
11577 
 
3431 rajveer 11578 
  def validate(self):
11579 
    return
11580 
 
11581 
 
1976 varun.gupt 11582 
  def __repr__(self):
11583 
    L = ['%s=%r' % (key, value)
11584 
      for key, value in self.__dict__.iteritems()]
11585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11586 
 
11587 
  def __eq__(self, other):
11588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11589 
 
11590 
  def __ne__(self, other):
11591 
    return not (self == other)
11592 
 
11593 
class applyCouponToCart_result:
11594 
  """
11595 
  Attributes:
11596 
   - scx
11597 
  """
11598 
 
11599 
  thrift_spec = (
11600 
    None, # 0
11601 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11602 
  )
11603 
 
11604 
  def __init__(self, scx=None,):
11605 
    self.scx = scx
11606 
 
11607 
  def read(self, iprot):
11608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11610 
      return
11611 
    iprot.readStructBegin()
11612 
    while True:
11613 
      (fname, ftype, fid) = iprot.readFieldBegin()
11614 
      if ftype == TType.STOP:
11615 
        break
11616 
      if fid == 1:
11617 
        if ftype == TType.STRUCT:
11618 
          self.scx = ShoppingCartException()
11619 
          self.scx.read(iprot)
11620 
        else:
11621 
          iprot.skip(ftype)
11622 
      else:
11623 
        iprot.skip(ftype)
11624 
      iprot.readFieldEnd()
11625 
    iprot.readStructEnd()
11626 
 
11627 
  def write(self, oprot):
11628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11630 
      return
11631 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11632 
    if self.scx is not None:
1976 varun.gupt 11633 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11634 
      self.scx.write(oprot)
11635 
      oprot.writeFieldEnd()
11636 
    oprot.writeFieldStop()
11637 
    oprot.writeStructEnd()
11638 
 
3431 rajveer 11639 
  def validate(self):
11640 
    return
11641 
 
11642 
 
1976 varun.gupt 11643 
  def __repr__(self):
11644 
    L = ['%s=%r' % (key, value)
11645 
      for key, value in self.__dict__.iteritems()]
11646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11647 
 
11648 
  def __eq__(self, other):
11649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11650 
 
11651 
  def __ne__(self, other):
11652 
    return not (self == other)
11653 
 
11654 
class removeCoupon_args:
11655 
  """
11656 
  Attributes:
11657 
   - cartId
11658 
  """
11659 
 
11660 
  thrift_spec = (
11661 
    None, # 0
11662 
    (1, TType.I64, 'cartId', None, None, ), # 1
11663 
  )
11664 
 
11665 
  def __init__(self, cartId=None,):
11666 
    self.cartId = cartId
11667 
 
11668 
  def read(self, iprot):
11669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11671 
      return
11672 
    iprot.readStructBegin()
11673 
    while True:
11674 
      (fname, ftype, fid) = iprot.readFieldBegin()
11675 
      if ftype == TType.STOP:
11676 
        break
11677 
      if fid == 1:
11678 
        if ftype == TType.I64:
11679 
          self.cartId = iprot.readI64();
11680 
        else:
11681 
          iprot.skip(ftype)
11682 
      else:
11683 
        iprot.skip(ftype)
11684 
      iprot.readFieldEnd()
11685 
    iprot.readStructEnd()
11686 
 
11687 
  def write(self, oprot):
11688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11690 
      return
11691 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11692 
    if self.cartId is not None:
1976 varun.gupt 11693 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11694 
      oprot.writeI64(self.cartId)
11695 
      oprot.writeFieldEnd()
11696 
    oprot.writeFieldStop()
11697 
    oprot.writeStructEnd()
11698 
 
3431 rajveer 11699 
  def validate(self):
11700 
    return
11701 
 
11702 
 
1976 varun.gupt 11703 
  def __repr__(self):
11704 
    L = ['%s=%r' % (key, value)
11705 
      for key, value in self.__dict__.iteritems()]
11706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11707 
 
11708 
  def __eq__(self, other):
11709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11710 
 
11711 
  def __ne__(self, other):
11712 
    return not (self == other)
11713 
 
11714 
class removeCoupon_result:
11715 
  """
11716 
  Attributes:
11717 
   - scx
11718 
  """
11719 
 
11720 
  thrift_spec = (
11721 
    None, # 0
11722 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11723 
  )
11724 
 
11725 
  def __init__(self, scx=None,):
11726 
    self.scx = scx
11727 
 
11728 
  def read(self, iprot):
11729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11731 
      return
11732 
    iprot.readStructBegin()
11733 
    while True:
11734 
      (fname, ftype, fid) = iprot.readFieldBegin()
11735 
      if ftype == TType.STOP:
11736 
        break
11737 
      if fid == 1:
11738 
        if ftype == TType.STRUCT:
11739 
          self.scx = ShoppingCartException()
11740 
          self.scx.read(iprot)
11741 
        else:
11742 
          iprot.skip(ftype)
11743 
      else:
11744 
        iprot.skip(ftype)
11745 
      iprot.readFieldEnd()
11746 
    iprot.readStructEnd()
11747 
 
11748 
  def write(self, oprot):
11749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11751 
      return
11752 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11753 
    if self.scx is not None:
1976 varun.gupt 11754 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11755 
      self.scx.write(oprot)
11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
1976 varun.gupt 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
3554 varun.gupt 11775 
class deleteDiscountsFromCart_args:
11776 
  """
11777 
  Attributes:
11778 
   - cartId
11779 
  """
11780 
 
11781 
  thrift_spec = (
11782 
    None, # 0
11783 
    (1, TType.I64, 'cartId', None, None, ), # 1
11784 
  )
11785 
 
11786 
  def __init__(self, cartId=None,):
11787 
    self.cartId = cartId
11788 
 
11789 
  def read(self, iprot):
11790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11792 
      return
11793 
    iprot.readStructBegin()
11794 
    while True:
11795 
      (fname, ftype, fid) = iprot.readFieldBegin()
11796 
      if ftype == TType.STOP:
11797 
        break
11798 
      if fid == 1:
11799 
        if ftype == TType.I64:
11800 
          self.cartId = iprot.readI64();
11801 
        else:
11802 
          iprot.skip(ftype)
11803 
      else:
11804 
        iprot.skip(ftype)
11805 
      iprot.readFieldEnd()
11806 
    iprot.readStructEnd()
11807 
 
11808 
  def write(self, oprot):
11809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11811 
      return
11812 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11813 
    if self.cartId is not None:
11814 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11815 
      oprot.writeI64(self.cartId)
11816 
      oprot.writeFieldEnd()
11817 
    oprot.writeFieldStop()
11818 
    oprot.writeStructEnd()
11819 
 
11820 
  def validate(self):
11821 
    return
11822 
 
11823 
 
11824 
  def __repr__(self):
11825 
    L = ['%s=%r' % (key, value)
11826 
      for key, value in self.__dict__.iteritems()]
11827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11828 
 
11829 
  def __eq__(self, other):
11830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11831 
 
11832 
  def __ne__(self, other):
11833 
    return not (self == other)
11834 
 
11835 
class deleteDiscountsFromCart_result:
11836 
  """
11837 
  Attributes:
11838 
   - scx
11839 
  """
11840 
 
11841 
  thrift_spec = (
11842 
    None, # 0
11843 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11844 
  )
11845 
 
11846 
  def __init__(self, scx=None,):
11847 
    self.scx = scx
11848 
 
11849 
  def read(self, iprot):
11850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11852 
      return
11853 
    iprot.readStructBegin()
11854 
    while True:
11855 
      (fname, ftype, fid) = iprot.readFieldBegin()
11856 
      if ftype == TType.STOP:
11857 
        break
11858 
      if fid == 1:
11859 
        if ftype == TType.STRUCT:
11860 
          self.scx = ShoppingCartException()
11861 
          self.scx.read(iprot)
11862 
        else:
11863 
          iprot.skip(ftype)
11864 
      else:
11865 
        iprot.skip(ftype)
11866 
      iprot.readFieldEnd()
11867 
    iprot.readStructEnd()
11868 
 
11869 
  def write(self, oprot):
11870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11872 
      return
11873 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11874 
    if self.scx is not None:
11875 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11876 
      self.scx.write(oprot)
11877 
      oprot.writeFieldEnd()
11878 
    oprot.writeFieldStop()
11879 
    oprot.writeStructEnd()
11880 
 
11881 
  def validate(self):
11882 
    return
11883 
 
11884 
 
11885 
  def __repr__(self):
11886 
    L = ['%s=%r' % (key, value)
11887 
      for key, value in self.__dict__.iteritems()]
11888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11889 
 
11890 
  def __eq__(self, other):
11891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11892 
 
11893 
  def __ne__(self, other):
11894 
    return not (self == other)
11895 
 
11896 
class saveDiscounts_args:
11897 
  """
11898 
  Attributes:
11899 
   - discounts
11900 
  """
11901 
 
11902 
  thrift_spec = (
11903 
    None, # 0
11904 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11905 
  )
11906 
 
11907 
  def __init__(self, discounts=None,):
11908 
    self.discounts = discounts
11909 
 
11910 
  def read(self, iprot):
11911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11913 
      return
11914 
    iprot.readStructBegin()
11915 
    while True:
11916 
      (fname, ftype, fid) = iprot.readFieldBegin()
11917 
      if ftype == TType.STOP:
11918 
        break
11919 
      if fid == 1:
11920 
        if ftype == TType.LIST:
11921 
          self.discounts = []
11592 amit.gupta 11922 
          (_etype163, _size160) = iprot.readListBegin()
11923 
          for _i164 in xrange(_size160):
11924 
            _elem165 = Discount()
11925 
            _elem165.read(iprot)
11926 
            self.discounts.append(_elem165)
3554 varun.gupt 11927 
          iprot.readListEnd()
11928 
        else:
11929 
          iprot.skip(ftype)
11930 
      else:
11931 
        iprot.skip(ftype)
11932 
      iprot.readFieldEnd()
11933 
    iprot.readStructEnd()
11934 
 
11935 
  def write(self, oprot):
11936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11938 
      return
11939 
    oprot.writeStructBegin('saveDiscounts_args')
11940 
    if self.discounts is not None:
11941 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11942 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11943 
      for iter166 in self.discounts:
11944 
        iter166.write(oprot)
3554 varun.gupt 11945 
      oprot.writeListEnd()
11946 
      oprot.writeFieldEnd()
11947 
    oprot.writeFieldStop()
11948 
    oprot.writeStructEnd()
11949 
 
11950 
  def validate(self):
11951 
    return
11952 
 
11953 
 
11954 
  def __repr__(self):
11955 
    L = ['%s=%r' % (key, value)
11956 
      for key, value in self.__dict__.iteritems()]
11957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11958 
 
11959 
  def __eq__(self, other):
11960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11961 
 
11962 
  def __ne__(self, other):
11963 
    return not (self == other)
11964 
 
11965 
class saveDiscounts_result:
11966 
  """
11967 
  Attributes:
11968 
   - scx
11969 
  """
11970 
 
11971 
  thrift_spec = (
11972 
    None, # 0
11973 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11974 
  )
11975 
 
11976 
  def __init__(self, scx=None,):
11977 
    self.scx = scx
11978 
 
11979 
  def read(self, iprot):
11980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11982 
      return
11983 
    iprot.readStructBegin()
11984 
    while True:
11985 
      (fname, ftype, fid) = iprot.readFieldBegin()
11986 
      if ftype == TType.STOP:
11987 
        break
11988 
      if fid == 1:
11989 
        if ftype == TType.STRUCT:
11990 
          self.scx = ShoppingCartException()
11991 
          self.scx.read(iprot)
11992 
        else:
11993 
          iprot.skip(ftype)
11994 
      else:
11995 
        iprot.skip(ftype)
11996 
      iprot.readFieldEnd()
11997 
    iprot.readStructEnd()
11998 
 
11999 
  def write(self, oprot):
12000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12002 
      return
12003 
    oprot.writeStructBegin('saveDiscounts_result')
12004 
    if self.scx is not None:
12005 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12006 
      self.scx.write(oprot)
12007 
      oprot.writeFieldEnd()
12008 
    oprot.writeFieldStop()
12009 
    oprot.writeStructEnd()
12010 
 
12011 
  def validate(self):
12012 
    return
12013 
 
12014 
 
12015 
  def __repr__(self):
12016 
    L = ['%s=%r' % (key, value)
12017 
      for key, value in self.__dict__.iteritems()]
12018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12019 
 
12020 
  def __eq__(self, other):
12021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12022 
 
12023 
  def __ne__(self, other):
12024 
    return not (self == other)
12025 
 
690 chandransh 12026 
class createOrders_args:
559 chandransh 12027 
  """
12028 
  Attributes:
12029 
   - cartId
2815 vikas 12030 
   - sessionSource
12031 
   - sessionStartTime
3858 vikas 12032 
   - firstSource
12033 
   - firstSourceTime
5326 rajveer 12034 
   - userId
6389 rajveer 12035 
   - schemeId
11526 amit.gupta 12036 
   - orderSource
559 chandransh 12037 
  """
12038 
 
12039 
  thrift_spec = (
12040 
    None, # 0
12041 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12042 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12043 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12044 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12045 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12046 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12047 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12048 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12049 
  )
12050 
 
11526 amit.gupta 12051 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12052 
    self.cartId = cartId
2815 vikas 12053 
    self.sessionSource = sessionSource
12054 
    self.sessionStartTime = sessionStartTime
3858 vikas 12055 
    self.firstSource = firstSource
12056 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12057 
    self.userId = userId
6389 rajveer 12058 
    self.schemeId = schemeId
11526 amit.gupta 12059 
    self.orderSource = orderSource
559 chandransh 12060 
 
12061 
  def read(self, iprot):
12062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12064 
      return
12065 
    iprot.readStructBegin()
12066 
    while True:
12067 
      (fname, ftype, fid) = iprot.readFieldBegin()
12068 
      if ftype == TType.STOP:
12069 
        break
12070 
      if fid == 1:
12071 
        if ftype == TType.I64:
12072 
          self.cartId = iprot.readI64();
12073 
        else:
12074 
          iprot.skip(ftype)
2815 vikas 12075 
      elif fid == 2:
12076 
        if ftype == TType.STRING:
12077 
          self.sessionSource = iprot.readString();
12078 
        else:
12079 
          iprot.skip(ftype)
12080 
      elif fid == 3:
12081 
        if ftype == TType.I64:
12082 
          self.sessionStartTime = iprot.readI64();
12083 
        else:
12084 
          iprot.skip(ftype)
3858 vikas 12085 
      elif fid == 4:
12086 
        if ftype == TType.STRING:
12087 
          self.firstSource = iprot.readString();
12088 
        else:
12089 
          iprot.skip(ftype)
12090 
      elif fid == 5:
12091 
        if ftype == TType.I64:
12092 
          self.firstSourceTime = iprot.readI64();
12093 
        else:
12094 
          iprot.skip(ftype)
5326 rajveer 12095 
      elif fid == 6:
12096 
        if ftype == TType.I64:
12097 
          self.userId = iprot.readI64();
12098 
        else:
12099 
          iprot.skip(ftype)
6389 rajveer 12100 
      elif fid == 7:
12101 
        if ftype == TType.I64:
12102 
          self.schemeId = iprot.readI64();
12103 
        else:
12104 
          iprot.skip(ftype)
11526 amit.gupta 12105 
      elif fid == 8:
12106 
        if ftype == TType.I64:
12107 
          self.orderSource = iprot.readI64();
12108 
        else:
12109 
          iprot.skip(ftype)
559 chandransh 12110 
      else:
12111 
        iprot.skip(ftype)
12112 
      iprot.readFieldEnd()
12113 
    iprot.readStructEnd()
12114 
 
12115 
  def write(self, oprot):
12116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12118 
      return
690 chandransh 12119 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12120 
    if self.cartId is not None:
559 chandransh 12121 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12122 
      oprot.writeI64(self.cartId)
12123 
      oprot.writeFieldEnd()
3431 rajveer 12124 
    if self.sessionSource is not None:
2815 vikas 12125 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12126 
      oprot.writeString(self.sessionSource)
12127 
      oprot.writeFieldEnd()
3431 rajveer 12128 
    if self.sessionStartTime is not None:
2815 vikas 12129 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12130 
      oprot.writeI64(self.sessionStartTime)
12131 
      oprot.writeFieldEnd()
3858 vikas 12132 
    if self.firstSource is not None:
12133 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12134 
      oprot.writeString(self.firstSource)
12135 
      oprot.writeFieldEnd()
12136 
    if self.firstSourceTime is not None:
12137 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12138 
      oprot.writeI64(self.firstSourceTime)
12139 
      oprot.writeFieldEnd()
5326 rajveer 12140 
    if self.userId is not None:
12141 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12142 
      oprot.writeI64(self.userId)
12143 
      oprot.writeFieldEnd()
6389 rajveer 12144 
    if self.schemeId is not None:
12145 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12146 
      oprot.writeI64(self.schemeId)
12147 
      oprot.writeFieldEnd()
11526 amit.gupta 12148 
    if self.orderSource is not None:
12149 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12150 
      oprot.writeI64(self.orderSource)
12151 
      oprot.writeFieldEnd()
559 chandransh 12152 
    oprot.writeFieldStop()
12153 
    oprot.writeStructEnd()
12154 
 
3431 rajveer 12155 
  def validate(self):
12156 
    return
12157 
 
12158 
 
559 chandransh 12159 
  def __repr__(self):
12160 
    L = ['%s=%r' % (key, value)
12161 
      for key, value in self.__dict__.iteritems()]
12162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12163 
 
12164 
  def __eq__(self, other):
12165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12166 
 
12167 
  def __ne__(self, other):
12168 
    return not (self == other)
12169 
 
690 chandransh 12170 
class createOrders_result:
559 chandransh 12171 
  """
12172 
  Attributes:
94 ashish 12173 
   - success
559 chandransh 12174 
   - scx
94 ashish 12175 
  """
12176 
 
12177 
  thrift_spec = (
575 chandransh 12178 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12179 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12180 
  )
12181 
 
559 chandransh 12182 
  def __init__(self, success=None, scx=None,):
94 ashish 12183 
    self.success = success
559 chandransh 12184 
    self.scx = scx
94 ashish 12185 
 
12186 
  def read(self, iprot):
12187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12189 
      return
12190 
    iprot.readStructBegin()
12191 
    while True:
12192 
      (fname, ftype, fid) = iprot.readFieldBegin()
12193 
      if ftype == TType.STOP:
12194 
        break
12195 
      if fid == 0:
575 chandransh 12196 
        if ftype == TType.I64:
12197 
          self.success = iprot.readI64();
94 ashish 12198 
        else:
12199 
          iprot.skip(ftype)
12200 
      elif fid == 1:
12201 
        if ftype == TType.STRUCT:
559 chandransh 12202 
          self.scx = ShoppingCartException()
12203 
          self.scx.read(iprot)
94 ashish 12204 
        else:
12205 
          iprot.skip(ftype)
12206 
      else:
12207 
        iprot.skip(ftype)
12208 
      iprot.readFieldEnd()
12209 
    iprot.readStructEnd()
12210 
 
12211 
  def write(self, oprot):
12212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12214 
      return
690 chandransh 12215 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12216 
    if self.success is not None:
575 chandransh 12217 
      oprot.writeFieldBegin('success', TType.I64, 0)
12218 
      oprot.writeI64(self.success)
94 ashish 12219 
      oprot.writeFieldEnd()
3431 rajveer 12220 
    if self.scx is not None:
559 chandransh 12221 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12222 
      self.scx.write(oprot)
94 ashish 12223 
      oprot.writeFieldEnd()
12224 
    oprot.writeFieldStop()
12225 
    oprot.writeStructEnd()
12226 
 
3431 rajveer 12227 
  def validate(self):
12228 
    return
12229 
 
12230 
 
94 ashish 12231 
  def __repr__(self):
12232 
    L = ['%s=%r' % (key, value)
12233 
      for key, value in self.__dict__.iteritems()]
12234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12235 
 
12236 
  def __eq__(self, other):
12237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12238 
 
12239 
  def __ne__(self, other):
12240 
    return not (self == other)
12241 
 
559 chandransh 12242 
class validateCart_args:
94 ashish 12243 
  """
12244 
  Attributes:
559 chandransh 12245 
   - cartId
3557 rajveer 12246 
   - sourceId
94 ashish 12247 
  """
12248 
 
12249 
  thrift_spec = (
12250 
    None, # 0
559 chandransh 12251 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12252 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12253 
  )
12254 
 
3557 rajveer 12255 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12256 
    self.cartId = cartId
3557 rajveer 12257 
    self.sourceId = sourceId
94 ashish 12258 
 
12259 
  def read(self, iprot):
12260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12262 
      return
12263 
    iprot.readStructBegin()
12264 
    while True:
12265 
      (fname, ftype, fid) = iprot.readFieldBegin()
12266 
      if ftype == TType.STOP:
12267 
        break
12268 
      if fid == 1:
12269 
        if ftype == TType.I64:
559 chandransh 12270 
          self.cartId = iprot.readI64();
94 ashish 12271 
        else:
12272 
          iprot.skip(ftype)
3557 rajveer 12273 
      elif fid == 2:
12274 
        if ftype == TType.I64:
12275 
          self.sourceId = iprot.readI64();
12276 
        else:
12277 
          iprot.skip(ftype)
94 ashish 12278 
      else:
12279 
        iprot.skip(ftype)
12280 
      iprot.readFieldEnd()
12281 
    iprot.readStructEnd()
12282 
 
12283 
  def write(self, oprot):
12284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12286 
      return
559 chandransh 12287 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12288 
    if self.cartId is not None:
559 chandransh 12289 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12290 
      oprot.writeI64(self.cartId)
94 ashish 12291 
      oprot.writeFieldEnd()
3557 rajveer 12292 
    if self.sourceId is not None:
12293 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12294 
      oprot.writeI64(self.sourceId)
12295 
      oprot.writeFieldEnd()
94 ashish 12296 
    oprot.writeFieldStop()
12297 
    oprot.writeStructEnd()
12298 
 
3431 rajveer 12299 
  def validate(self):
12300 
    return
12301 
 
12302 
 
94 ashish 12303 
  def __repr__(self):
12304 
    L = ['%s=%r' % (key, value)
12305 
      for key, value in self.__dict__.iteritems()]
12306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12307 
 
12308 
  def __eq__(self, other):
12309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12310 
 
12311 
  def __ne__(self, other):
12312 
    return not (self == other)
12313 
 
559 chandransh 12314 
class validateCart_result:
94 ashish 12315 
  """
12316 
  Attributes:
12317 
   - success
575 chandransh 12318 
   - scex
94 ashish 12319 
  """
12320 
 
12321 
  thrift_spec = (
6736 amit.gupta 12322 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12323 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12324 
  )
12325 
 
575 chandransh 12326 
  def __init__(self, success=None, scex=None,):
94 ashish 12327 
    self.success = success
575 chandransh 12328 
    self.scex = scex
94 ashish 12329 
 
12330 
  def read(self, iprot):
12331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12333 
      return
12334 
    iprot.readStructBegin()
12335 
    while True:
12336 
      (fname, ftype, fid) = iprot.readFieldBegin()
12337 
      if ftype == TType.STOP:
12338 
        break
12339 
      if fid == 0:
6736 amit.gupta 12340 
        if ftype == TType.LIST:
12341 
          self.success = []
11592 amit.gupta 12342 
          (_etype170, _size167) = iprot.readListBegin()
12343 
          for _i171 in xrange(_size167):
12344 
            _elem172 = iprot.readString();
12345 
            self.success.append(_elem172)
6736 amit.gupta 12346 
          iprot.readListEnd()
94 ashish 12347 
        else:
12348 
          iprot.skip(ftype)
575 chandransh 12349 
      elif fid == 1:
12350 
        if ftype == TType.STRUCT:
12351 
          self.scex = ShoppingCartException()
12352 
          self.scex.read(iprot)
12353 
        else:
12354 
          iprot.skip(ftype)
94 ashish 12355 
      else:
12356 
        iprot.skip(ftype)
12357 
      iprot.readFieldEnd()
12358 
    iprot.readStructEnd()
12359 
 
12360 
  def write(self, oprot):
12361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12363 
      return
559 chandransh 12364 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12365 
    if self.success is not None:
6736 amit.gupta 12366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12367 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12368 
      for iter173 in self.success:
12369 
        oprot.writeString(iter173)
6736 amit.gupta 12370 
      oprot.writeListEnd()
94 ashish 12371 
      oprot.writeFieldEnd()
3431 rajveer 12372 
    if self.scex is not None:
575 chandransh 12373 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12374 
      self.scex.write(oprot)
12375 
      oprot.writeFieldEnd()
559 chandransh 12376 
    oprot.writeFieldStop()
12377 
    oprot.writeStructEnd()
12378 
 
3431 rajveer 12379 
  def validate(self):
12380 
    return
12381 
 
12382 
 
559 chandransh 12383 
  def __repr__(self):
12384 
    L = ['%s=%r' % (key, value)
12385 
      for key, value in self.__dict__.iteritems()]
12386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12387 
 
12388 
  def __eq__(self, other):
12389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12390 
 
12391 
  def __ne__(self, other):
12392 
    return not (self == other)
12393 
 
11980 amit.gupta 12394 
class validateCartWithDealerCoupon_args:
12395 
  """
12396 
  Attributes:
12397 
   - cartId
12398 
   - sourceId
12399 
   - dealCoupon
12400 
  """
12401 
 
12402 
  thrift_spec = (
12403 
    None, # 0
12404 
    (1, TType.I64, 'cartId', None, None, ), # 1
12405 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12406 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12407 
  )
12408 
 
12409 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12410 
    self.cartId = cartId
12411 
    self.sourceId = sourceId
12412 
    self.dealCoupon = dealCoupon
12413 
 
12414 
  def read(self, iprot):
12415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12417 
      return
12418 
    iprot.readStructBegin()
12419 
    while True:
12420 
      (fname, ftype, fid) = iprot.readFieldBegin()
12421 
      if ftype == TType.STOP:
12422 
        break
12423 
      if fid == 1:
12424 
        if ftype == TType.I64:
12425 
          self.cartId = iprot.readI64();
12426 
        else:
12427 
          iprot.skip(ftype)
12428 
      elif fid == 2:
12429 
        if ftype == TType.I64:
12430 
          self.sourceId = iprot.readI64();
12431 
        else:
12432 
          iprot.skip(ftype)
12433 
      elif fid == 3:
12434 
        if ftype == TType.STRING:
12435 
          self.dealCoupon = iprot.readString();
12436 
        else:
12437 
          iprot.skip(ftype)
12438 
      else:
12439 
        iprot.skip(ftype)
12440 
      iprot.readFieldEnd()
12441 
    iprot.readStructEnd()
12442 
 
12443 
  def write(self, oprot):
12444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12446 
      return
12447 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12448 
    if self.cartId is not None:
12449 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12450 
      oprot.writeI64(self.cartId)
12451 
      oprot.writeFieldEnd()
12452 
    if self.sourceId is not None:
12453 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12454 
      oprot.writeI64(self.sourceId)
12455 
      oprot.writeFieldEnd()
12456 
    if self.dealCoupon is not None:
12457 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12458 
      oprot.writeString(self.dealCoupon)
12459 
      oprot.writeFieldEnd()
12460 
    oprot.writeFieldStop()
12461 
    oprot.writeStructEnd()
12462 
 
12463 
  def validate(self):
12464 
    return
12465 
 
12466 
 
12467 
  def __repr__(self):
12468 
    L = ['%s=%r' % (key, value)
12469 
      for key, value in self.__dict__.iteritems()]
12470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12471 
 
12472 
  def __eq__(self, other):
12473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12474 
 
12475 
  def __ne__(self, other):
12476 
    return not (self == other)
12477 
 
12478 
class validateCartWithDealerCoupon_result:
12479 
  """
12480 
  Attributes:
12481 
   - success
12482 
   - scex
12483 
  """
12484 
 
12485 
  thrift_spec = (
12486 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12487 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12488 
  )
12489 
 
12490 
  def __init__(self, success=None, scex=None,):
12491 
    self.success = success
12492 
    self.scex = scex
12493 
 
12494 
  def read(self, iprot):
12495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12497 
      return
12498 
    iprot.readStructBegin()
12499 
    while True:
12500 
      (fname, ftype, fid) = iprot.readFieldBegin()
12501 
      if ftype == TType.STOP:
12502 
        break
12503 
      if fid == 0:
12504 
        if ftype == TType.LIST:
12505 
          self.success = []
12506 
          (_etype177, _size174) = iprot.readListBegin()
12507 
          for _i178 in xrange(_size174):
12508 
            _elem179 = iprot.readString();
12509 
            self.success.append(_elem179)
12510 
          iprot.readListEnd()
12511 
        else:
12512 
          iprot.skip(ftype)
12513 
      elif fid == 1:
12514 
        if ftype == TType.STRUCT:
12515 
          self.scex = ShoppingCartException()
12516 
          self.scex.read(iprot)
12517 
        else:
12518 
          iprot.skip(ftype)
12519 
      else:
12520 
        iprot.skip(ftype)
12521 
      iprot.readFieldEnd()
12522 
    iprot.readStructEnd()
12523 
 
12524 
  def write(self, oprot):
12525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12527 
      return
12528 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12529 
    if self.success is not None:
12530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12531 
      oprot.writeListBegin(TType.STRING, len(self.success))
12532 
      for iter180 in self.success:
12533 
        oprot.writeString(iter180)
12534 
      oprot.writeListEnd()
12535 
      oprot.writeFieldEnd()
12536 
    if self.scex is not None:
12537 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12538 
      self.scex.write(oprot)
12539 
      oprot.writeFieldEnd()
12540 
    oprot.writeFieldStop()
12541 
    oprot.writeStructEnd()
12542 
 
12543 
  def validate(self):
12544 
    return
12545 
 
12546 
 
12547 
  def __repr__(self):
12548 
    L = ['%s=%r' % (key, value)
12549 
      for key, value in self.__dict__.iteritems()]
12550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12551 
 
12552 
  def __eq__(self, other):
12553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12554 
 
12555 
  def __ne__(self, other):
12556 
    return not (self == other)
12557 
 
690 chandransh 12558 
class mergeCart_args:
575 chandransh 12559 
  """
12560 
  Attributes:
690 chandransh 12561 
   - fromCartId
12562 
   - toCartId
12563 
  """
12564 
 
12565 
  thrift_spec = (
12566 
    None, # 0
12567 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12568 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12569 
  )
12570 
 
12571 
  def __init__(self, fromCartId=None, toCartId=None,):
12572 
    self.fromCartId = fromCartId
12573 
    self.toCartId = toCartId
12574 
 
12575 
  def read(self, iprot):
12576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12578 
      return
12579 
    iprot.readStructBegin()
12580 
    while True:
12581 
      (fname, ftype, fid) = iprot.readFieldBegin()
12582 
      if ftype == TType.STOP:
12583 
        break
12584 
      if fid == 1:
12585 
        if ftype == TType.I64:
12586 
          self.fromCartId = iprot.readI64();
12587 
        else:
12588 
          iprot.skip(ftype)
12589 
      elif fid == 2:
12590 
        if ftype == TType.I64:
12591 
          self.toCartId = iprot.readI64();
12592 
        else:
12593 
          iprot.skip(ftype)
12594 
      else:
12595 
        iprot.skip(ftype)
12596 
      iprot.readFieldEnd()
12597 
    iprot.readStructEnd()
12598 
 
12599 
  def write(self, oprot):
12600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12602 
      return
12603 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12604 
    if self.fromCartId is not None:
690 chandransh 12605 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12606 
      oprot.writeI64(self.fromCartId)
12607 
      oprot.writeFieldEnd()
3431 rajveer 12608 
    if self.toCartId is not None:
690 chandransh 12609 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12610 
      oprot.writeI64(self.toCartId)
12611 
      oprot.writeFieldEnd()
12612 
    oprot.writeFieldStop()
12613 
    oprot.writeStructEnd()
12614 
 
3431 rajveer 12615 
  def validate(self):
12616 
    return
12617 
 
12618 
 
690 chandransh 12619 
  def __repr__(self):
12620 
    L = ['%s=%r' % (key, value)
12621 
      for key, value in self.__dict__.iteritems()]
12622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12623 
 
12624 
  def __eq__(self, other):
12625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12626 
 
12627 
  def __ne__(self, other):
12628 
    return not (self == other)
12629 
 
12630 
class mergeCart_result:
12631 
 
12632 
  thrift_spec = (
12633 
  )
12634 
 
12635 
  def read(self, iprot):
12636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12638 
      return
12639 
    iprot.readStructBegin()
12640 
    while True:
12641 
      (fname, ftype, fid) = iprot.readFieldBegin()
12642 
      if ftype == TType.STOP:
12643 
        break
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
12653 
    oprot.writeStructBegin('mergeCart_result')
12654 
    oprot.writeFieldStop()
12655 
    oprot.writeStructEnd()
12656 
 
3431 rajveer 12657 
  def validate(self):
12658 
    return
12659 
 
12660 
 
690 chandransh 12661 
  def __repr__(self):
12662 
    L = ['%s=%r' % (key, value)
12663 
      for key, value in self.__dict__.iteritems()]
12664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12665 
 
12666 
  def __eq__(self, other):
12667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12668 
 
12669 
  def __ne__(self, other):
12670 
    return not (self == other)
12671 
 
12672 
class checkOut_args:
12673 
  """
12674 
  Attributes:
575 chandransh 12675 
   - cartId
12676 
  """
12677 
 
12678 
  thrift_spec = (
12679 
    None, # 0
12680 
    (1, TType.I64, 'cartId', None, None, ), # 1
12681 
  )
12682 
 
12683 
  def __init__(self, cartId=None,):
12684 
    self.cartId = cartId
12685 
 
12686 
  def read(self, iprot):
12687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12689 
      return
12690 
    iprot.readStructBegin()
12691 
    while True:
12692 
      (fname, ftype, fid) = iprot.readFieldBegin()
12693 
      if ftype == TType.STOP:
12694 
        break
12695 
      if fid == 1:
12696 
        if ftype == TType.I64:
12697 
          self.cartId = iprot.readI64();
12698 
        else:
12699 
          iprot.skip(ftype)
12700 
      else:
12701 
        iprot.skip(ftype)
12702 
      iprot.readFieldEnd()
12703 
    iprot.readStructEnd()
12704 
 
12705 
  def write(self, oprot):
12706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12708 
      return
690 chandransh 12709 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12710 
    if self.cartId is not None:
575 chandransh 12711 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12712 
      oprot.writeI64(self.cartId)
12713 
      oprot.writeFieldEnd()
12714 
    oprot.writeFieldStop()
12715 
    oprot.writeStructEnd()
12716 
 
3431 rajveer 12717 
  def validate(self):
12718 
    return
12719 
 
12720 
 
575 chandransh 12721 
  def __repr__(self):
12722 
    L = ['%s=%r' % (key, value)
12723 
      for key, value in self.__dict__.iteritems()]
12724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12725 
 
12726 
  def __eq__(self, other):
12727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12728 
 
12729 
  def __ne__(self, other):
12730 
    return not (self == other)
12731 
 
690 chandransh 12732 
class checkOut_result:
575 chandransh 12733 
  """
12734 
  Attributes:
12735 
   - success
12736 
   - scex
12737 
  """
12738 
 
12739 
  thrift_spec = (
12740 
    (0, TType.BOOL, 'success', None, None, ), # 0
12741 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12742 
  )
12743 
 
12744 
  def __init__(self, success=None, scex=None,):
12745 
    self.success = success
12746 
    self.scex = scex
12747 
 
12748 
  def read(self, iprot):
12749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12751 
      return
12752 
    iprot.readStructBegin()
12753 
    while True:
12754 
      (fname, ftype, fid) = iprot.readFieldBegin()
12755 
      if ftype == TType.STOP:
12756 
        break
12757 
      if fid == 0:
12758 
        if ftype == TType.BOOL:
12759 
          self.success = iprot.readBool();
12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      elif fid == 1:
12763 
        if ftype == TType.STRUCT:
12764 
          self.scex = ShoppingCartException()
12765 
          self.scex.read(iprot)
12766 
        else:
12767 
          iprot.skip(ftype)
12768 
      else:
12769 
        iprot.skip(ftype)
12770 
      iprot.readFieldEnd()
12771 
    iprot.readStructEnd()
12772 
 
12773 
  def write(self, oprot):
12774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12776 
      return
690 chandransh 12777 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12778 
    if self.success is not None:
575 chandransh 12779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12780 
      oprot.writeBool(self.success)
12781 
      oprot.writeFieldEnd()
3431 rajveer 12782 
    if self.scex is not None:
575 chandransh 12783 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12784 
      self.scex.write(oprot)
12785 
      oprot.writeFieldEnd()
12786 
    oprot.writeFieldStop()
12787 
    oprot.writeStructEnd()
12788 
 
3431 rajveer 12789 
  def validate(self):
12790 
    return
12791 
 
12792 
 
575 chandransh 12793 
  def __repr__(self):
12794 
    L = ['%s=%r' % (key, value)
12795 
      for key, value in self.__dict__.iteritems()]
12796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12797 
 
12798 
  def __eq__(self, other):
12799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12800 
 
12801 
  def __ne__(self, other):
12802 
    return not (self == other)
12803 
 
690 chandransh 12804 
class resetCart_args:
559 chandransh 12805 
  """
12806 
  Attributes:
690 chandransh 12807 
   - cartId
12808 
   - items
559 chandransh 12809 
  """
12810 
 
12811 
  thrift_spec = (
12812 
    None, # 0
690 chandransh 12813 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12814 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12815 
  )
12816 
 
690 chandransh 12817 
  def __init__(self, cartId=None, items=None,):
12818 
    self.cartId = cartId
12819 
    self.items = items
559 chandransh 12820 
 
12821 
  def read(self, iprot):
12822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12824 
      return
12825 
    iprot.readStructBegin()
12826 
    while True:
12827 
      (fname, ftype, fid) = iprot.readFieldBegin()
12828 
      if ftype == TType.STOP:
12829 
        break
12830 
      if fid == 1:
12831 
        if ftype == TType.I64:
690 chandransh 12832 
          self.cartId = iprot.readI64();
559 chandransh 12833 
        else:
12834 
          iprot.skip(ftype)
12835 
      elif fid == 2:
690 chandransh 12836 
        if ftype == TType.MAP:
12837 
          self.items = {}
11980 amit.gupta 12838 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12839 
          for _i185 in xrange(_size181):
12840 
            _key186 = iprot.readI64();
12841 
            _val187 = iprot.readDouble();
12842 
            self.items[_key186] = _val187
690 chandransh 12843 
          iprot.readMapEnd()
559 chandransh 12844 
        else:
12845 
          iprot.skip(ftype)
12846 
      else:
12847 
        iprot.skip(ftype)
12848 
      iprot.readFieldEnd()
12849 
    iprot.readStructEnd()
12850 
 
12851 
  def write(self, oprot):
12852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12854 
      return
690 chandransh 12855 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12856 
    if self.cartId is not None:
690 chandransh 12857 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12858 
      oprot.writeI64(self.cartId)
94 ashish 12859 
      oprot.writeFieldEnd()
3431 rajveer 12860 
    if self.items is not None:
690 chandransh 12861 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12862 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12863 
      for kiter188,viter189 in self.items.items():
12864 
        oprot.writeI64(kiter188)
12865 
        oprot.writeDouble(viter189)
690 chandransh 12866 
      oprot.writeMapEnd()
559 chandransh 12867 
      oprot.writeFieldEnd()
94 ashish 12868 
    oprot.writeFieldStop()
12869 
    oprot.writeStructEnd()
12870 
 
3431 rajveer 12871 
  def validate(self):
12872 
    return
12873 
 
12874 
 
94 ashish 12875 
  def __repr__(self):
12876 
    L = ['%s=%r' % (key, value)
12877 
      for key, value in self.__dict__.iteritems()]
12878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12879 
 
12880 
  def __eq__(self, other):
12881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12882 
 
12883 
  def __ne__(self, other):
12884 
    return not (self == other)
12885 
 
690 chandransh 12886 
class resetCart_result:
12887 
  """
12888 
  Attributes:
12889 
   - success
12890 
   - scex
12891 
  """
559 chandransh 12892 
 
12893 
  thrift_spec = (
690 chandransh 12894 
    (0, TType.BOOL, 'success', None, None, ), # 0
12895 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12896 
  )
12897 
 
690 chandransh 12898 
  def __init__(self, success=None, scex=None,):
12899 
    self.success = success
12900 
    self.scex = scex
12901 
 
559 chandransh 12902 
  def read(self, iprot):
12903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12905 
      return
12906 
    iprot.readStructBegin()
12907 
    while True:
12908 
      (fname, ftype, fid) = iprot.readFieldBegin()
12909 
      if ftype == TType.STOP:
12910 
        break
690 chandransh 12911 
      if fid == 0:
12912 
        if ftype == TType.BOOL:
12913 
          self.success = iprot.readBool();
12914 
        else:
12915 
          iprot.skip(ftype)
12916 
      elif fid == 1:
12917 
        if ftype == TType.STRUCT:
12918 
          self.scex = ShoppingCartException()
12919 
          self.scex.read(iprot)
12920 
        else:
12921 
          iprot.skip(ftype)
559 chandransh 12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
690 chandransh 12931 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12932 
    if self.success is not None:
690 chandransh 12933 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12934 
      oprot.writeBool(self.success)
12935 
      oprot.writeFieldEnd()
3431 rajveer 12936 
    if self.scex is not None:
690 chandransh 12937 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12938 
      self.scex.write(oprot)
12939 
      oprot.writeFieldEnd()
559 chandransh 12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
3431 rajveer 12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
559 chandransh 12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
2981 rajveer 12958 
class getUserCount_args:
94 ashish 12959 
  """
12960 
  Attributes:
2981 rajveer 12961 
   - userType
559 chandransh 12962 
  """
12963 
 
12964 
  thrift_spec = (
12965 
    None, # 0
2981 rajveer 12966 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12967 
  )
12968 
 
2981 rajveer 12969 
  def __init__(self, userType=None,):
12970 
    self.userType = userType
559 chandransh 12971 
 
12972 
  def read(self, iprot):
12973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12975 
      return
12976 
    iprot.readStructBegin()
12977 
    while True:
12978 
      (fname, ftype, fid) = iprot.readFieldBegin()
12979 
      if ftype == TType.STOP:
12980 
        break
12981 
      if fid == 1:
2981 rajveer 12982 
        if ftype == TType.I32:
12983 
          self.userType = iprot.readI32();
559 chandransh 12984 
        else:
12985 
          iprot.skip(ftype)
12986 
      else:
12987 
        iprot.skip(ftype)
12988 
      iprot.readFieldEnd()
12989 
    iprot.readStructEnd()
12990 
 
12991 
  def write(self, oprot):
12992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12994 
      return
2981 rajveer 12995 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12996 
    if self.userType is not None:
2981 rajveer 12997 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12998 
      oprot.writeI32(self.userType)
559 chandransh 12999 
      oprot.writeFieldEnd()
13000 
    oprot.writeFieldStop()
13001 
    oprot.writeStructEnd()
13002 
 
3431 rajveer 13003 
  def validate(self):
13004 
    return
13005 
 
13006 
 
559 chandransh 13007 
  def __repr__(self):
13008 
    L = ['%s=%r' % (key, value)
13009 
      for key, value in self.__dict__.iteritems()]
13010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13011 
 
13012 
  def __eq__(self, other):
13013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13014 
 
13015 
  def __ne__(self, other):
13016 
    return not (self == other)
13017 
 
2981 rajveer 13018 
class getUserCount_result:
94 ashish 13019 
  """
13020 
  Attributes:
13021 
   - success
13022 
  """
13023 
 
13024 
  thrift_spec = (
2981 rajveer 13025 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13026 
  )
13027 
 
2981 rajveer 13028 
  def __init__(self, success=None,):
94 ashish 13029 
    self.success = success
13030 
 
13031 
  def read(self, iprot):
13032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13034 
      return
13035 
    iprot.readStructBegin()
13036 
    while True:
13037 
      (fname, ftype, fid) = iprot.readFieldBegin()
13038 
      if ftype == TType.STOP:
13039 
        break
13040 
      if fid == 0:
2981 rajveer 13041 
        if ftype == TType.I64:
13042 
          self.success = iprot.readI64();
94 ashish 13043 
        else:
13044 
          iprot.skip(ftype)
13045 
      else:
13046 
        iprot.skip(ftype)
13047 
      iprot.readFieldEnd()
13048 
    iprot.readStructEnd()
13049 
 
13050 
  def write(self, oprot):
13051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13053 
      return
2981 rajveer 13054 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13055 
    if self.success is not None:
2981 rajveer 13056 
      oprot.writeFieldBegin('success', TType.I64, 0)
13057 
      oprot.writeI64(self.success)
94 ashish 13058 
      oprot.writeFieldEnd()
13059 
    oprot.writeFieldStop()
13060 
    oprot.writeStructEnd()
13061 
 
3431 rajveer 13062 
  def validate(self):
13063 
    return
13064 
 
13065 
 
94 ashish 13066 
  def __repr__(self):
13067 
    L = ['%s=%r' % (key, value)
13068 
      for key, value in self.__dict__.iteritems()]
13069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13070 
 
13071 
  def __eq__(self, other):
13072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13073 
 
13074 
  def __ne__(self, other):
13075 
    return not (self == other)
13076 
 
2981 rajveer 13077 
class getAllUsers_args:
94 ashish 13078 
  """
13079 
  Attributes:
2981 rajveer 13080 
   - userType
13081 
   - startDate
13082 
   - endDate
94 ashish 13083 
  """
13084 
 
13085 
  thrift_spec = (
13086 
    None, # 0
2981 rajveer 13087 
    (1, TType.I32, 'userType', None, None, ), # 1
13088 
    (2, TType.I64, 'startDate', None, None, ), # 2
13089 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13090 
  )
13091 
 
2981 rajveer 13092 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13093 
    self.userType = userType
13094 
    self.startDate = startDate
13095 
    self.endDate = endDate
94 ashish 13096 
 
13097 
  def read(self, iprot):
13098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13100 
      return
13101 
    iprot.readStructBegin()
13102 
    while True:
13103 
      (fname, ftype, fid) = iprot.readFieldBegin()
13104 
      if ftype == TType.STOP:
13105 
        break
13106 
      if fid == 1:
2981 rajveer 13107 
        if ftype == TType.I32:
13108 
          self.userType = iprot.readI32();
94 ashish 13109 
        else:
13110 
          iprot.skip(ftype)
13111 
      elif fid == 2:
559 chandransh 13112 
        if ftype == TType.I64:
2981 rajveer 13113 
          self.startDate = iprot.readI64();
94 ashish 13114 
        else:
13115 
          iprot.skip(ftype)
2981 rajveer 13116 
      elif fid == 3:
13117 
        if ftype == TType.I64:
13118 
          self.endDate = iprot.readI64();
13119 
        else:
13120 
          iprot.skip(ftype)
94 ashish 13121 
      else:
13122 
        iprot.skip(ftype)
13123 
      iprot.readFieldEnd()
13124 
    iprot.readStructEnd()
13125 
 
13126 
  def write(self, oprot):
13127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13129 
      return
2981 rajveer 13130 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13131 
    if self.userType is not None:
2981 rajveer 13132 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13133 
      oprot.writeI32(self.userType)
94 ashish 13134 
      oprot.writeFieldEnd()
3431 rajveer 13135 
    if self.startDate is not None:
2981 rajveer 13136 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13137 
      oprot.writeI64(self.startDate)
94 ashish 13138 
      oprot.writeFieldEnd()
3431 rajveer 13139 
    if self.endDate is not None:
2981 rajveer 13140 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13141 
      oprot.writeI64(self.endDate)
13142 
      oprot.writeFieldEnd()
94 ashish 13143 
    oprot.writeFieldStop()
13144 
    oprot.writeStructEnd()
13145 
 
3431 rajveer 13146 
  def validate(self):
13147 
    return
13148 
 
13149 
 
94 ashish 13150 
  def __repr__(self):
13151 
    L = ['%s=%r' % (key, value)
13152 
      for key, value in self.__dict__.iteritems()]
13153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13154 
 
13155 
  def __eq__(self, other):
13156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13157 
 
13158 
  def __ne__(self, other):
13159 
    return not (self == other)
13160 
 
2981 rajveer 13161 
class getAllUsers_result:
94 ashish 13162 
  """
13163 
  Attributes:
13164 
   - success
13165 
  """
13166 
 
13167 
  thrift_spec = (
2981 rajveer 13168 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13169 
  )
13170 
 
2981 rajveer 13171 
  def __init__(self, success=None,):
94 ashish 13172 
    self.success = success
13173 
 
13174 
  def read(self, iprot):
13175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13177 
      return
13178 
    iprot.readStructBegin()
13179 
    while True:
13180 
      (fname, ftype, fid) = iprot.readFieldBegin()
13181 
      if ftype == TType.STOP:
13182 
        break
13183 
      if fid == 0:
2981 rajveer 13184 
        if ftype == TType.LIST:
13185 
          self.success = []
11980 amit.gupta 13186 
          (_etype193, _size190) = iprot.readListBegin()
13187 
          for _i194 in xrange(_size190):
13188 
            _elem195 = User()
13189 
            _elem195.read(iprot)
13190 
            self.success.append(_elem195)
2981 rajveer 13191 
          iprot.readListEnd()
94 ashish 13192 
        else:
13193 
          iprot.skip(ftype)
13194 
      else:
13195 
        iprot.skip(ftype)
13196 
      iprot.readFieldEnd()
13197 
    iprot.readStructEnd()
13198 
 
13199 
  def write(self, oprot):
13200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13202 
      return
2981 rajveer 13203 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13204 
    if self.success is not None:
2981 rajveer 13205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13207 
      for iter196 in self.success:
13208 
        iter196.write(oprot)
2981 rajveer 13209 
      oprot.writeListEnd()
94 ashish 13210 
      oprot.writeFieldEnd()
13211 
    oprot.writeFieldStop()
13212 
    oprot.writeStructEnd()
13213 
 
3431 rajveer 13214 
  def validate(self):
13215 
    return
13216 
 
13217 
 
94 ashish 13218 
  def __repr__(self):
13219 
    L = ['%s=%r' % (key, value)
13220 
      for key, value in self.__dict__.iteritems()]
13221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13222 
 
13223 
  def __eq__(self, other):
13224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13225 
 
13226 
  def __ne__(self, other):
13227 
    return not (self == other)
13228 
 
2981 rajveer 13229 
class getMyResearchItems_args:
559 chandransh 13230 
  """
13231 
  Attributes:
772 rajveer 13232 
   - userId
559 chandransh 13233 
  """
13234 
 
13235 
  thrift_spec = (
13236 
    None, # 0
772 rajveer 13237 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13238 
  )
13239 
 
772 rajveer 13240 
  def __init__(self, userId=None,):
13241 
    self.userId = userId
559 chandransh 13242 
 
13243 
  def read(self, iprot):
13244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13246 
      return
13247 
    iprot.readStructBegin()
13248 
    while True:
13249 
      (fname, ftype, fid) = iprot.readFieldBegin()
13250 
      if ftype == TType.STOP:
13251 
        break
13252 
      if fid == 1:
13253 
        if ftype == TType.I64:
772 rajveer 13254 
          self.userId = iprot.readI64();
559 chandransh 13255 
        else:
13256 
          iprot.skip(ftype)
13257 
      else:
13258 
        iprot.skip(ftype)
13259 
      iprot.readFieldEnd()
13260 
    iprot.readStructEnd()
13261 
 
13262 
  def write(self, oprot):
13263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13265 
      return
2981 rajveer 13266 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13267 
    if self.userId is not None:
772 rajveer 13268 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13269 
      oprot.writeI64(self.userId)
559 chandransh 13270 
      oprot.writeFieldEnd()
13271 
    oprot.writeFieldStop()
13272 
    oprot.writeStructEnd()
13273 
 
3431 rajveer 13274 
  def validate(self):
13275 
    return
13276 
 
13277 
 
559 chandransh 13278 
  def __repr__(self):
13279 
    L = ['%s=%r' % (key, value)
13280 
      for key, value in self.__dict__.iteritems()]
13281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13282 
 
13283 
  def __eq__(self, other):
13284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13285 
 
13286 
  def __ne__(self, other):
13287 
    return not (self == other)
13288 
 
2981 rajveer 13289 
class getMyResearchItems_result:
559 chandransh 13290 
  """
13291 
  Attributes:
130 ashish 13292 
   - success
559 chandransh 13293 
   - scx
130 ashish 13294 
  """
13295 
 
13296 
  thrift_spec = (
2981 rajveer 13297 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13298 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13299 
  )
13300 
 
559 chandransh 13301 
  def __init__(self, success=None, scx=None,):
130 ashish 13302 
    self.success = success
559 chandransh 13303 
    self.scx = scx
130 ashish 13304 
 
13305 
  def read(self, iprot):
13306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13308 
      return
13309 
    iprot.readStructBegin()
13310 
    while True:
13311 
      (fname, ftype, fid) = iprot.readFieldBegin()
13312 
      if ftype == TType.STOP:
13313 
        break
13314 
      if fid == 0:
2981 rajveer 13315 
        if ftype == TType.LIST:
13316 
          self.success = []
11980 amit.gupta 13317 
          (_etype200, _size197) = iprot.readListBegin()
13318 
          for _i201 in xrange(_size197):
13319 
            _elem202 = iprot.readI64();
13320 
            self.success.append(_elem202)
2981 rajveer 13321 
          iprot.readListEnd()
130 ashish 13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      elif fid == 1:
13325 
        if ftype == TType.STRUCT:
559 chandransh 13326 
          self.scx = WidgetException()
13327 
          self.scx.read(iprot)
130 ashish 13328 
        else:
13329 
          iprot.skip(ftype)
13330 
      else:
13331 
        iprot.skip(ftype)
13332 
      iprot.readFieldEnd()
13333 
    iprot.readStructEnd()
13334 
 
13335 
  def write(self, oprot):
13336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13338 
      return
2981 rajveer 13339 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13340 
    if self.success is not None:
2981 rajveer 13341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13342 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13343 
      for iter203 in self.success:
13344 
        oprot.writeI64(iter203)
2981 rajveer 13345 
      oprot.writeListEnd()
130 ashish 13346 
      oprot.writeFieldEnd()
3431 rajveer 13347 
    if self.scx is not None:
559 chandransh 13348 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13349 
      self.scx.write(oprot)
130 ashish 13350 
      oprot.writeFieldEnd()
13351 
    oprot.writeFieldStop()
13352 
    oprot.writeStructEnd()
13353 
 
3431 rajveer 13354 
  def validate(self):
13355 
    return
13356 
 
13357 
 
130 ashish 13358 
  def __repr__(self):
13359 
    L = ['%s=%r' % (key, value)
13360 
      for key, value in self.__dict__.iteritems()]
13361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13362 
 
13363 
  def __eq__(self, other):
13364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13365 
 
13366 
  def __ne__(self, other):
13367 
    return not (self == other)
13368 
 
2981 rajveer 13369 
class updateMyResearch_args:
130 ashish 13370 
  """
13371 
  Attributes:
2981 rajveer 13372 
   - userId
13373 
   - itemId
130 ashish 13374 
  """
13375 
 
13376 
  thrift_spec = (
13377 
    None, # 0
2981 rajveer 13378 
    (1, TType.I64, 'userId', None, None, ), # 1
13379 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13380 
  )
13381 
 
2981 rajveer 13382 
  def __init__(self, userId=None, itemId=None,):
13383 
    self.userId = userId
13384 
    self.itemId = itemId
130 ashish 13385 
 
13386 
  def read(self, iprot):
13387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13389 
      return
13390 
    iprot.readStructBegin()
13391 
    while True:
13392 
      (fname, ftype, fid) = iprot.readFieldBegin()
13393 
      if ftype == TType.STOP:
13394 
        break
13395 
      if fid == 1:
559 chandransh 13396 
        if ftype == TType.I64:
2981 rajveer 13397 
          self.userId = iprot.readI64();
130 ashish 13398 
        else:
13399 
          iprot.skip(ftype)
13400 
      elif fid == 2:
559 chandransh 13401 
        if ftype == TType.I64:
2981 rajveer 13402 
          self.itemId = iprot.readI64();
559 chandransh 13403 
        else:
13404 
          iprot.skip(ftype)
130 ashish 13405 
      else:
13406 
        iprot.skip(ftype)
13407 
      iprot.readFieldEnd()
13408 
    iprot.readStructEnd()
13409 
 
13410 
  def write(self, oprot):
13411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13413 
      return
2981 rajveer 13414 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13415 
    if self.userId is not None:
2981 rajveer 13416 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13417 
      oprot.writeI64(self.userId)
130 ashish 13418 
      oprot.writeFieldEnd()
3431 rajveer 13419 
    if self.itemId is not None:
2981 rajveer 13420 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13421 
      oprot.writeI64(self.itemId)
130 ashish 13422 
      oprot.writeFieldEnd()
13423 
    oprot.writeFieldStop()
13424 
    oprot.writeStructEnd()
13425 
 
3431 rajveer 13426 
  def validate(self):
13427 
    return
13428 
 
13429 
 
130 ashish 13430 
  def __repr__(self):
13431 
    L = ['%s=%r' % (key, value)
13432 
      for key, value in self.__dict__.iteritems()]
13433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13434 
 
13435 
  def __eq__(self, other):
13436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13437 
 
13438 
  def __ne__(self, other):
13439 
    return not (self == other)
13440 
 
2981 rajveer 13441 
class updateMyResearch_result:
13442 
  """
13443 
  Attributes:
13444 
   - success
13445 
   - scx
13446 
  """
559 chandransh 13447 
 
13448 
  thrift_spec = (
2981 rajveer 13449 
    (0, TType.BOOL, 'success', None, None, ), # 0
13450 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13451 
  )
13452 
 
2981 rajveer 13453 
  def __init__(self, success=None, scx=None,):
13454 
    self.success = success
13455 
    self.scx = scx
13456 
 
559 chandransh 13457 
  def read(self, iprot):
13458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13460 
      return
13461 
    iprot.readStructBegin()
13462 
    while True:
13463 
      (fname, ftype, fid) = iprot.readFieldBegin()
13464 
      if ftype == TType.STOP:
13465 
        break
2981 rajveer 13466 
      if fid == 0:
13467 
        if ftype == TType.BOOL:
13468 
          self.success = iprot.readBool();
13469 
        else:
13470 
          iprot.skip(ftype)
13471 
      elif fid == 1:
13472 
        if ftype == TType.STRUCT:
13473 
          self.scx = WidgetException()
13474 
          self.scx.read(iprot)
13475 
        else:
13476 
          iprot.skip(ftype)
559 chandransh 13477 
      else:
13478 
        iprot.skip(ftype)
13479 
      iprot.readFieldEnd()
13480 
    iprot.readStructEnd()
13481 
 
13482 
  def write(self, oprot):
13483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13485 
      return
2981 rajveer 13486 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13487 
    if self.success is not None:
2981 rajveer 13488 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13489 
      oprot.writeBool(self.success)
13490 
      oprot.writeFieldEnd()
3431 rajveer 13491 
    if self.scx is not None:
2981 rajveer 13492 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13493 
      self.scx.write(oprot)
13494 
      oprot.writeFieldEnd()
559 chandransh 13495 
    oprot.writeFieldStop()
13496 
    oprot.writeStructEnd()
13497 
 
3431 rajveer 13498 
  def validate(self):
13499 
    return
13500 
 
13501 
 
559 chandransh 13502 
  def __repr__(self):
13503 
    L = ['%s=%r' % (key, value)
13504 
      for key, value in self.__dict__.iteritems()]
13505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13506 
 
13507 
  def __eq__(self, other):
13508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13509 
 
13510 
  def __ne__(self, other):
13511 
    return not (self == other)
13512 
 
2981 rajveer 13513 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13514 
  """
13515 
  Attributes:
2981 rajveer 13516 
   - userId
13517 
   - itemId
1596 ankur.sing 13518 
  """
559 chandransh 13519 
 
1596 ankur.sing 13520 
  thrift_spec = (
13521 
    None, # 0
2981 rajveer 13522 
    (1, TType.I64, 'userId', None, None, ), # 1
13523 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13524 
  )
13525 
 
2981 rajveer 13526 
  def __init__(self, userId=None, itemId=None,):
13527 
    self.userId = userId
13528 
    self.itemId = itemId
1596 ankur.sing 13529 
 
13530 
  def read(self, iprot):
13531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13533 
      return
13534 
    iprot.readStructBegin()
13535 
    while True:
13536 
      (fname, ftype, fid) = iprot.readFieldBegin()
13537 
      if ftype == TType.STOP:
13538 
        break
13539 
      if fid == 1:
2981 rajveer 13540 
        if ftype == TType.I64:
13541 
          self.userId = iprot.readI64();
1596 ankur.sing 13542 
        else:
13543 
          iprot.skip(ftype)
2981 rajveer 13544 
      elif fid == 2:
13545 
        if ftype == TType.I64:
13546 
          self.itemId = iprot.readI64();
13547 
        else:
13548 
          iprot.skip(ftype)
1596 ankur.sing 13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
2981 rajveer 13558 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13559 
    if self.userId is not None:
2981 rajveer 13560 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13561 
      oprot.writeI64(self.userId)
1596 ankur.sing 13562 
      oprot.writeFieldEnd()
3431 rajveer 13563 
    if self.itemId is not None:
2981 rajveer 13564 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13565 
      oprot.writeI64(self.itemId)
13566 
      oprot.writeFieldEnd()
1596 ankur.sing 13567 
    oprot.writeFieldStop()
13568 
    oprot.writeStructEnd()
13569 
 
3431 rajveer 13570 
  def validate(self):
13571 
    return
13572 
 
13573 
 
1596 ankur.sing 13574 
  def __repr__(self):
13575 
    L = ['%s=%r' % (key, value)
13576 
      for key, value in self.__dict__.iteritems()]
13577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13578 
 
13579 
  def __eq__(self, other):
13580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13581 
 
13582 
  def __ne__(self, other):
13583 
    return not (self == other)
13584 
 
2981 rajveer 13585 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13586 
  """
13587 
  Attributes:
2981 rajveer 13588 
   - scx
1596 ankur.sing 13589 
  """
13590 
 
13591 
  thrift_spec = (
2981 rajveer 13592 
    None, # 0
13593 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13594 
  )
13595 
 
2981 rajveer 13596 
  def __init__(self, scx=None,):
13597 
    self.scx = scx
1596 ankur.sing 13598 
 
13599 
  def read(self, iprot):
13600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13602 
      return
13603 
    iprot.readStructBegin()
13604 
    while True:
13605 
      (fname, ftype, fid) = iprot.readFieldBegin()
13606 
      if ftype == TType.STOP:
13607 
        break
2981 rajveer 13608 
      if fid == 1:
13609 
        if ftype == TType.STRUCT:
13610 
          self.scx = WidgetException()
13611 
          self.scx.read(iprot)
1596 ankur.sing 13612 
        else:
13613 
          iprot.skip(ftype)
13614 
      else:
13615 
        iprot.skip(ftype)
13616 
      iprot.readFieldEnd()
13617 
    iprot.readStructEnd()
13618 
 
13619 
  def write(self, oprot):
13620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13622 
      return
2981 rajveer 13623 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13624 
    if self.scx is not None:
2981 rajveer 13625 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13626 
      self.scx.write(oprot)
1596 ankur.sing 13627 
      oprot.writeFieldEnd()
13628 
    oprot.writeFieldStop()
13629 
    oprot.writeStructEnd()
13630 
 
3431 rajveer 13631 
  def validate(self):
13632 
    return
13633 
 
13634 
 
1596 ankur.sing 13635 
  def __repr__(self):
13636 
    L = ['%s=%r' % (key, value)
13637 
      for key, value in self.__dict__.iteritems()]
13638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13639 
 
13640 
  def __eq__(self, other):
13641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13642 
 
13643 
  def __ne__(self, other):
13644 
    return not (self == other)
13645 
 
2981 rajveer 13646 
class getBrowseHistoryItems_args:
1673 ankur.sing 13647 
  """
13648 
  Attributes:
2981 rajveer 13649 
   - userId
1673 ankur.sing 13650 
  """
1596 ankur.sing 13651 
 
1673 ankur.sing 13652 
  thrift_spec = (
13653 
    None, # 0
2981 rajveer 13654 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13655 
  )
13656 
 
2981 rajveer 13657 
  def __init__(self, userId=None,):
13658 
    self.userId = userId
1673 ankur.sing 13659 
 
13660 
  def read(self, iprot):
13661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13663 
      return
13664 
    iprot.readStructBegin()
13665 
    while True:
13666 
      (fname, ftype, fid) = iprot.readFieldBegin()
13667 
      if ftype == TType.STOP:
13668 
        break
13669 
      if fid == 1:
1891 ankur.sing 13670 
        if ftype == TType.I64:
2981 rajveer 13671 
          self.userId = iprot.readI64();
1891 ankur.sing 13672 
        else:
13673 
          iprot.skip(ftype)
1673 ankur.sing 13674 
      else:
13675 
        iprot.skip(ftype)
13676 
      iprot.readFieldEnd()
13677 
    iprot.readStructEnd()
13678 
 
13679 
  def write(self, oprot):
13680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13682 
      return
2981 rajveer 13683 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13684 
    if self.userId is not None:
2981 rajveer 13685 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13686 
      oprot.writeI64(self.userId)
1673 ankur.sing 13687 
      oprot.writeFieldEnd()
13688 
    oprot.writeFieldStop()
13689 
    oprot.writeStructEnd()
13690 
 
3431 rajveer 13691 
  def validate(self):
13692 
    return
13693 
 
13694 
 
1673 ankur.sing 13695 
  def __repr__(self):
13696 
    L = ['%s=%r' % (key, value)
13697 
      for key, value in self.__dict__.iteritems()]
13698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13699 
 
13700 
  def __eq__(self, other):
13701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13702 
 
13703 
  def __ne__(self, other):
13704 
    return not (self == other)
13705 
 
2981 rajveer 13706 
class getBrowseHistoryItems_result:
1673 ankur.sing 13707 
  """
13708 
  Attributes:
13709 
   - success
2981 rajveer 13710 
   - scx
1673 ankur.sing 13711 
  """
13712 
 
13713 
  thrift_spec = (
2981 rajveer 13714 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13715 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13716 
  )
13717 
 
2981 rajveer 13718 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13719 
    self.success = success
2981 rajveer 13720 
    self.scx = scx
1673 ankur.sing 13721 
 
13722 
  def read(self, iprot):
13723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13725 
      return
13726 
    iprot.readStructBegin()
13727 
    while True:
13728 
      (fname, ftype, fid) = iprot.readFieldBegin()
13729 
      if ftype == TType.STOP:
13730 
        break
13731 
      if fid == 0:
13732 
        if ftype == TType.LIST:
13733 
          self.success = []
11980 amit.gupta 13734 
          (_etype207, _size204) = iprot.readListBegin()
13735 
          for _i208 in xrange(_size204):
13736 
            _elem209 = iprot.readI64();
13737 
            self.success.append(_elem209)
1673 ankur.sing 13738 
          iprot.readListEnd()
13739 
        else:
13740 
          iprot.skip(ftype)
2981 rajveer 13741 
      elif fid == 1:
13742 
        if ftype == TType.STRUCT:
13743 
          self.scx = WidgetException()
13744 
          self.scx.read(iprot)
13745 
        else:
13746 
          iprot.skip(ftype)
1673 ankur.sing 13747 
      else:
13748 
        iprot.skip(ftype)
13749 
      iprot.readFieldEnd()
13750 
    iprot.readStructEnd()
13751 
 
13752 
  def write(self, oprot):
13753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13755 
      return
2981 rajveer 13756 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13757 
    if self.success is not None:
1673 ankur.sing 13758 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13759 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13760 
      for iter210 in self.success:
13761 
        oprot.writeI64(iter210)
1673 ankur.sing 13762 
      oprot.writeListEnd()
13763 
      oprot.writeFieldEnd()
3431 rajveer 13764 
    if self.scx is not None:
2981 rajveer 13765 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13766 
      self.scx.write(oprot)
2642 varun.gupt 13767 
      oprot.writeFieldEnd()
13768 
    oprot.writeFieldStop()
13769 
    oprot.writeStructEnd()
13770 
 
3431 rajveer 13771 
  def validate(self):
13772 
    return
13773 
 
13774 
 
2642 varun.gupt 13775 
  def __repr__(self):
13776 
    L = ['%s=%r' % (key, value)
13777 
      for key, value in self.__dict__.iteritems()]
13778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13779 
 
13780 
  def __eq__(self, other):
13781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13782 
 
13783 
  def __ne__(self, other):
13784 
    return not (self == other)
13785 
 
2981 rajveer 13786 
class updateBrowseHistory_args:
2642 varun.gupt 13787 
  """
13788 
  Attributes:
2981 rajveer 13789 
   - userId
13790 
   - itemId
2642 varun.gupt 13791 
  """
13792 
 
13793 
  thrift_spec = (
13794 
    None, # 0
2981 rajveer 13795 
    (1, TType.I64, 'userId', None, None, ), # 1
13796 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13797 
  )
13798 
 
2981 rajveer 13799 
  def __init__(self, userId=None, itemId=None,):
13800 
    self.userId = userId
13801 
    self.itemId = itemId
2642 varun.gupt 13802 
 
13803 
  def read(self, iprot):
13804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13806 
      return
13807 
    iprot.readStructBegin()
13808 
    while True:
13809 
      (fname, ftype, fid) = iprot.readFieldBegin()
13810 
      if ftype == TType.STOP:
13811 
        break
13812 
      if fid == 1:
13813 
        if ftype == TType.I64:
2981 rajveer 13814 
          self.userId = iprot.readI64();
2642 varun.gupt 13815 
        else:
13816 
          iprot.skip(ftype)
13817 
      elif fid == 2:
13818 
        if ftype == TType.I64:
2981 rajveer 13819 
          self.itemId = iprot.readI64();
2642 varun.gupt 13820 
        else:
13821 
          iprot.skip(ftype)
13822 
      else:
13823 
        iprot.skip(ftype)
13824 
      iprot.readFieldEnd()
13825 
    iprot.readStructEnd()
13826 
 
13827 
  def write(self, oprot):
13828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13830 
      return
2981 rajveer 13831 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13832 
    if self.userId is not None:
2981 rajveer 13833 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13834 
      oprot.writeI64(self.userId)
2642 varun.gupt 13835 
      oprot.writeFieldEnd()
3431 rajveer 13836 
    if self.itemId is not None:
2981 rajveer 13837 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13838 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13839 
      oprot.writeFieldEnd()
13840 
    oprot.writeFieldStop()
13841 
    oprot.writeStructEnd()
13842 
 
3431 rajveer 13843 
  def validate(self):
13844 
    return
13845 
 
13846 
 
2642 varun.gupt 13847 
  def __repr__(self):
13848 
    L = ['%s=%r' % (key, value)
13849 
      for key, value in self.__dict__.iteritems()]
13850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13851 
 
13852 
  def __eq__(self, other):
13853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13854 
 
13855 
  def __ne__(self, other):
13856 
    return not (self == other)
13857 
 
2981 rajveer 13858 
class updateBrowseHistory_result:
2642 varun.gupt 13859 
 
13860 
  thrift_spec = (
13861 
  )
13862 
 
13863 
  def read(self, iprot):
13864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13866 
      return
13867 
    iprot.readStructBegin()
13868 
    while True:
13869 
      (fname, ftype, fid) = iprot.readFieldBegin()
13870 
      if ftype == TType.STOP:
13871 
        break
13872 
      else:
13873 
        iprot.skip(ftype)
13874 
      iprot.readFieldEnd()
13875 
    iprot.readStructEnd()
13876 
 
13877 
  def write(self, oprot):
13878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13880 
      return
2981 rajveer 13881 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13882 
    oprot.writeFieldStop()
13883 
    oprot.writeStructEnd()
13884 
 
3431 rajveer 13885 
  def validate(self):
13886 
    return
13887 
 
13888 
 
2642 varun.gupt 13889 
  def __repr__(self):
13890 
    L = ['%s=%r' % (key, value)
13891 
      for key, value in self.__dict__.iteritems()]
13892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13893 
 
13894 
  def __eq__(self, other):
13895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13896 
 
13897 
  def __ne__(self, other):
13898 
    return not (self == other)
13899 
 
3385 varun.gupt 13900 
class getCartsWithCouponCount_args:
13901 
  """
13902 
  Attributes:
13903 
   - couponCode
13904 
  """
2642 varun.gupt 13905 
 
3385 varun.gupt 13906 
  thrift_spec = (
13907 
    None, # 0
13908 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13909 
  )
13910 
 
13911 
  def __init__(self, couponCode=None,):
13912 
    self.couponCode = couponCode
13913 
 
13914 
  def read(self, iprot):
13915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13917 
      return
13918 
    iprot.readStructBegin()
13919 
    while True:
13920 
      (fname, ftype, fid) = iprot.readFieldBegin()
13921 
      if ftype == TType.STOP:
13922 
        break
13923 
      if fid == 1:
13924 
        if ftype == TType.STRING:
13925 
          self.couponCode = iprot.readString();
13926 
        else:
13927 
          iprot.skip(ftype)
13928 
      else:
13929 
        iprot.skip(ftype)
13930 
      iprot.readFieldEnd()
13931 
    iprot.readStructEnd()
13932 
 
13933 
  def write(self, oprot):
13934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13936 
      return
13937 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13938 
    if self.couponCode is not None:
3385 varun.gupt 13939 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13940 
      oprot.writeString(self.couponCode)
13941 
      oprot.writeFieldEnd()
13942 
    oprot.writeFieldStop()
13943 
    oprot.writeStructEnd()
13944 
 
3431 rajveer 13945 
  def validate(self):
13946 
    return
13947 
 
13948 
 
3385 varun.gupt 13949 
  def __repr__(self):
13950 
    L = ['%s=%r' % (key, value)
13951 
      for key, value in self.__dict__.iteritems()]
13952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13953 
 
13954 
  def __eq__(self, other):
13955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13956 
 
13957 
  def __ne__(self, other):
13958 
    return not (self == other)
13959 
 
13960 
class getCartsWithCouponCount_result:
13961 
  """
13962 
  Attributes:
13963 
   - success
13964 
  """
13965 
 
13966 
  thrift_spec = (
13967 
    (0, TType.I64, 'success', None, None, ), # 0
13968 
  )
13969 
 
13970 
  def __init__(self, success=None,):
13971 
    self.success = success
13972 
 
13973 
  def read(self, iprot):
13974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13976 
      return
13977 
    iprot.readStructBegin()
13978 
    while True:
13979 
      (fname, ftype, fid) = iprot.readFieldBegin()
13980 
      if ftype == TType.STOP:
13981 
        break
13982 
      if fid == 0:
13983 
        if ftype == TType.I64:
13984 
          self.success = iprot.readI64();
13985 
        else:
13986 
          iprot.skip(ftype)
13987 
      else:
13988 
        iprot.skip(ftype)
13989 
      iprot.readFieldEnd()
13990 
    iprot.readStructEnd()
13991 
 
13992 
  def write(self, oprot):
13993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13995 
      return
13996 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13997 
    if self.success is not None:
3385 varun.gupt 13998 
      oprot.writeFieldBegin('success', TType.I64, 0)
13999 
      oprot.writeI64(self.success)
14000 
      oprot.writeFieldEnd()
14001 
    oprot.writeFieldStop()
14002 
    oprot.writeStructEnd()
14003 
 
3431 rajveer 14004 
  def validate(self):
14005 
    return
14006 
 
14007 
 
3385 varun.gupt 14008 
  def __repr__(self):
14009 
    L = ['%s=%r' % (key, value)
14010 
      for key, value in self.__dict__.iteritems()]
14011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14012 
 
14013 
  def __eq__(self, other):
14014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14015 
 
14016 
  def __ne__(self, other):
14017 
    return not (self == other)
3499 mandeep.dh 14018 
 
14019 
class increaseTrustLevel_args:
14020 
  """
14021 
  Attributes:
14022 
   - userId
14023 
   - trustLevelDelta
14024 
  """
14025 
 
14026 
  thrift_spec = (
14027 
    None, # 0
14028 
    (1, TType.I64, 'userId', None, None, ), # 1
14029 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14030 
  )
14031 
 
14032 
  def __init__(self, userId=None, trustLevelDelta=None,):
14033 
    self.userId = userId
14034 
    self.trustLevelDelta = trustLevelDelta
14035 
 
14036 
  def read(self, iprot):
14037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14039 
      return
14040 
    iprot.readStructBegin()
14041 
    while True:
14042 
      (fname, ftype, fid) = iprot.readFieldBegin()
14043 
      if ftype == TType.STOP:
14044 
        break
14045 
      if fid == 1:
14046 
        if ftype == TType.I64:
14047 
          self.userId = iprot.readI64();
14048 
        else:
14049 
          iprot.skip(ftype)
14050 
      elif fid == 2:
14051 
        if ftype == TType.DOUBLE:
14052 
          self.trustLevelDelta = iprot.readDouble();
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      else:
14056 
        iprot.skip(ftype)
14057 
      iprot.readFieldEnd()
14058 
    iprot.readStructEnd()
14059 
 
14060 
  def write(self, oprot):
14061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14063 
      return
14064 
    oprot.writeStructBegin('increaseTrustLevel_args')
14065 
    if self.userId is not None:
14066 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14067 
      oprot.writeI64(self.userId)
14068 
      oprot.writeFieldEnd()
14069 
    if self.trustLevelDelta is not None:
14070 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14071 
      oprot.writeDouble(self.trustLevelDelta)
14072 
      oprot.writeFieldEnd()
14073 
    oprot.writeFieldStop()
14074 
    oprot.writeStructEnd()
14075 
 
14076 
  def validate(self):
14077 
    return
14078 
 
14079 
 
14080 
  def __repr__(self):
14081 
    L = ['%s=%r' % (key, value)
14082 
      for key, value in self.__dict__.iteritems()]
14083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14084 
 
14085 
  def __eq__(self, other):
14086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14087 
 
14088 
  def __ne__(self, other):
14089 
    return not (self == other)
4668 varun.gupt 14090 
 
5407 amar.kumar 14091 
class getTrustLevel_args:
14092 
  """
14093 
  Attributes:
14094 
   - userId
14095 
  """
14096 
 
14097 
  thrift_spec = (
14098 
    None, # 0
14099 
    (1, TType.I64, 'userId', None, None, ), # 1
14100 
  )
14101 
 
14102 
  def __init__(self, userId=None,):
14103 
    self.userId = userId
14104 
 
14105 
  def read(self, iprot):
14106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14108 
      return
14109 
    iprot.readStructBegin()
14110 
    while True:
14111 
      (fname, ftype, fid) = iprot.readFieldBegin()
14112 
      if ftype == TType.STOP:
14113 
        break
14114 
      if fid == 1:
14115 
        if ftype == TType.I64:
14116 
          self.userId = iprot.readI64();
14117 
        else:
14118 
          iprot.skip(ftype)
14119 
      else:
14120 
        iprot.skip(ftype)
14121 
      iprot.readFieldEnd()
14122 
    iprot.readStructEnd()
14123 
 
14124 
  def write(self, oprot):
14125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14127 
      return
14128 
    oprot.writeStructBegin('getTrustLevel_args')
14129 
    if self.userId is not None:
14130 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14131 
      oprot.writeI64(self.userId)
14132 
      oprot.writeFieldEnd()
14133 
    oprot.writeFieldStop()
14134 
    oprot.writeStructEnd()
14135 
 
14136 
  def validate(self):
14137 
    return
14138 
 
14139 
 
14140 
  def __repr__(self):
14141 
    L = ['%s=%r' % (key, value)
14142 
      for key, value in self.__dict__.iteritems()]
14143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14144 
 
14145 
  def __eq__(self, other):
14146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14147 
 
14148 
  def __ne__(self, other):
14149 
    return not (self == other)
14150 
 
14151 
class getTrustLevel_result:
14152 
  """
14153 
  Attributes:
14154 
   - success
14155 
  """
14156 
 
14157 
  thrift_spec = (
14158 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14159 
  )
14160 
 
14161 
  def __init__(self, success=None,):
14162 
    self.success = success
14163 
 
14164 
  def read(self, iprot):
14165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14167 
      return
14168 
    iprot.readStructBegin()
14169 
    while True:
14170 
      (fname, ftype, fid) = iprot.readFieldBegin()
14171 
      if ftype == TType.STOP:
14172 
        break
14173 
      if fid == 0:
14174 
        if ftype == TType.DOUBLE:
14175 
          self.success = iprot.readDouble();
14176 
        else:
14177 
          iprot.skip(ftype)
14178 
      else:
14179 
        iprot.skip(ftype)
14180 
      iprot.readFieldEnd()
14181 
    iprot.readStructEnd()
14182 
 
14183 
  def write(self, oprot):
14184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14186 
      return
14187 
    oprot.writeStructBegin('getTrustLevel_result')
14188 
    if self.success is not None:
14189 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14190 
      oprot.writeDouble(self.success)
14191 
      oprot.writeFieldEnd()
14192 
    oprot.writeFieldStop()
14193 
    oprot.writeStructEnd()
14194 
 
14195 
  def validate(self):
14196 
    return
14197 
 
14198 
 
14199 
  def __repr__(self):
14200 
    L = ['%s=%r' % (key, value)
14201 
      for key, value in self.__dict__.iteritems()]
14202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14203 
 
14204 
  def __eq__(self, other):
14205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14206 
 
14207 
  def __ne__(self, other):
14208 
    return not (self == other)
14209 
 
4668 varun.gupt 14210 
class showCODOption_args:
14211 
  """
14212 
  Attributes:
14213 
   - cartId
14214 
   - sourceId
14215 
   - pincode
14216 
  """
14217 
 
14218 
  thrift_spec = (
14219 
    None, # 0
14220 
    (1, TType.I64, 'cartId', None, None, ), # 1
14221 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14222 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14223 
  )
14224 
 
14225 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14226 
    self.cartId = cartId
14227 
    self.sourceId = sourceId
14228 
    self.pincode = pincode
14229 
 
14230 
  def read(self, iprot):
14231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14233 
      return
14234 
    iprot.readStructBegin()
14235 
    while True:
14236 
      (fname, ftype, fid) = iprot.readFieldBegin()
14237 
      if ftype == TType.STOP:
14238 
        break
14239 
      if fid == 1:
14240 
        if ftype == TType.I64:
14241 
          self.cartId = iprot.readI64();
14242 
        else:
14243 
          iprot.skip(ftype)
14244 
      elif fid == 2:
14245 
        if ftype == TType.I64:
14246 
          self.sourceId = iprot.readI64();
14247 
        else:
14248 
          iprot.skip(ftype)
14249 
      elif fid == 3:
14250 
        if ftype == TType.STRING:
14251 
          self.pincode = iprot.readString();
14252 
        else:
14253 
          iprot.skip(ftype)
14254 
      else:
14255 
        iprot.skip(ftype)
14256 
      iprot.readFieldEnd()
14257 
    iprot.readStructEnd()
14258 
 
14259 
  def write(self, oprot):
14260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14262 
      return
14263 
    oprot.writeStructBegin('showCODOption_args')
14264 
    if self.cartId is not None:
14265 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14266 
      oprot.writeI64(self.cartId)
14267 
      oprot.writeFieldEnd()
14268 
    if self.sourceId is not None:
14269 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14270 
      oprot.writeI64(self.sourceId)
14271 
      oprot.writeFieldEnd()
14272 
    if self.pincode is not None:
14273 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14274 
      oprot.writeString(self.pincode)
14275 
      oprot.writeFieldEnd()
14276 
    oprot.writeFieldStop()
14277 
    oprot.writeStructEnd()
14278 
 
14279 
  def validate(self):
14280 
    return
14281 
 
14282 
 
14283 
  def __repr__(self):
14284 
    L = ['%s=%r' % (key, value)
14285 
      for key, value in self.__dict__.iteritems()]
14286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14287 
 
14288 
  def __eq__(self, other):
14289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14290 
 
14291 
  def __ne__(self, other):
14292 
    return not (self == other)
14293 
 
14294 
class showCODOption_result:
14295 
  """
14296 
  Attributes:
14297 
   - success
14298 
  """
14299 
 
14300 
  thrift_spec = (
14301 
    (0, TType.BOOL, 'success', None, None, ), # 0
14302 
  )
14303 
 
14304 
  def __init__(self, success=None,):
14305 
    self.success = success
14306 
 
14307 
  def read(self, iprot):
14308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14310 
      return
14311 
    iprot.readStructBegin()
14312 
    while True:
14313 
      (fname, ftype, fid) = iprot.readFieldBegin()
14314 
      if ftype == TType.STOP:
14315 
        break
14316 
      if fid == 0:
14317 
        if ftype == TType.BOOL:
14318 
          self.success = iprot.readBool();
14319 
        else:
14320 
          iprot.skip(ftype)
14321 
      else:
14322 
        iprot.skip(ftype)
14323 
      iprot.readFieldEnd()
14324 
    iprot.readStructEnd()
14325 
 
14326 
  def write(self, oprot):
14327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14329 
      return
14330 
    oprot.writeStructBegin('showCODOption_result')
14331 
    if self.success is not None:
14332 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14333 
      oprot.writeBool(self.success)
14334 
      oprot.writeFieldEnd()
14335 
    oprot.writeFieldStop()
14336 
    oprot.writeStructEnd()
14337 
 
14338 
  def validate(self):
14339 
    return
14340 
 
14341 
 
14342 
  def __repr__(self):
14343 
    L = ['%s=%r' % (key, value)
14344 
      for key, value in self.__dict__.iteritems()]
14345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14346 
 
14347 
  def __eq__(self, other):
14348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14349 
 
14350 
  def __ne__(self, other):
14351 
    return not (self == other)
5623 anupam.sin 14352 
 
14353 
class getUserEmails_args:
14354 
  """
14355 
  Attributes:
14356 
   - startDate
14357 
   - endDate
14358 
  """
14359 
 
14360 
  thrift_spec = (
14361 
    None, # 0
14362 
    (1, TType.I64, 'startDate', None, None, ), # 1
14363 
    (2, TType.I64, 'endDate', None, None, ), # 2
14364 
  )
14365 
 
14366 
  def __init__(self, startDate=None, endDate=None,):
14367 
    self.startDate = startDate
14368 
    self.endDate = endDate
14369 
 
14370 
  def read(self, iprot):
14371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14373 
      return
14374 
    iprot.readStructBegin()
14375 
    while True:
14376 
      (fname, ftype, fid) = iprot.readFieldBegin()
14377 
      if ftype == TType.STOP:
14378 
        break
14379 
      if fid == 1:
14380 
        if ftype == TType.I64:
14381 
          self.startDate = iprot.readI64();
14382 
        else:
14383 
          iprot.skip(ftype)
14384 
      elif fid == 2:
14385 
        if ftype == TType.I64:
14386 
          self.endDate = iprot.readI64();
14387 
        else:
14388 
          iprot.skip(ftype)
14389 
      else:
14390 
        iprot.skip(ftype)
14391 
      iprot.readFieldEnd()
14392 
    iprot.readStructEnd()
14393 
 
14394 
  def write(self, oprot):
14395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14397 
      return
14398 
    oprot.writeStructBegin('getUserEmails_args')
14399 
    if self.startDate is not None:
14400 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14401 
      oprot.writeI64(self.startDate)
14402 
      oprot.writeFieldEnd()
14403 
    if self.endDate is not None:
14404 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14405 
      oprot.writeI64(self.endDate)
14406 
      oprot.writeFieldEnd()
14407 
    oprot.writeFieldStop()
14408 
    oprot.writeStructEnd()
14409 
 
14410 
  def validate(self):
14411 
    return
14412 
 
14413 
 
14414 
  def __repr__(self):
14415 
    L = ['%s=%r' % (key, value)
14416 
      for key, value in self.__dict__.iteritems()]
14417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14418 
 
14419 
  def __eq__(self, other):
14420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14421 
 
14422 
  def __ne__(self, other):
14423 
    return not (self == other)
14424 
 
14425 
class getUserEmails_result:
14426 
  """
14427 
  Attributes:
14428 
   - success
14429 
  """
14430 
 
14431 
  thrift_spec = (
14432 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14433 
  )
14434 
 
14435 
  def __init__(self, success=None,):
14436 
    self.success = success
14437 
 
14438 
  def read(self, iprot):
14439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14441 
      return
14442 
    iprot.readStructBegin()
14443 
    while True:
14444 
      (fname, ftype, fid) = iprot.readFieldBegin()
14445 
      if ftype == TType.STOP:
14446 
        break
14447 
      if fid == 0:
14448 
        if ftype == TType.LIST:
14449 
          self.success = []
11980 amit.gupta 14450 
          (_etype214, _size211) = iprot.readListBegin()
14451 
          for _i215 in xrange(_size211):
14452 
            _elem216 = iprot.readString();
14453 
            self.success.append(_elem216)
5623 anupam.sin 14454 
          iprot.readListEnd()
14455 
        else:
14456 
          iprot.skip(ftype)
14457 
      else:
14458 
        iprot.skip(ftype)
14459 
      iprot.readFieldEnd()
14460 
    iprot.readStructEnd()
14461 
 
14462 
  def write(self, oprot):
14463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14465 
      return
14466 
    oprot.writeStructBegin('getUserEmails_result')
14467 
    if self.success is not None:
14468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14469 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14470 
      for iter217 in self.success:
14471 
        oprot.writeString(iter217)
5623 anupam.sin 14472 
      oprot.writeListEnd()
14473 
      oprot.writeFieldEnd()
14474 
    oprot.writeFieldStop()
14475 
    oprot.writeStructEnd()
14476 
 
14477 
  def validate(self):
14478 
    return
14479 
 
14480 
 
14481 
  def __repr__(self):
14482 
    L = ['%s=%r' % (key, value)
14483 
      for key, value in self.__dict__.iteritems()]
14484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14485 
 
14486 
  def __eq__(self, other):
14487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14488 
 
14489 
  def __ne__(self, other):
14490 
    return not (self == other)
6821 amar.kumar 14491 
 
6903 anupam.sin 14492 
class insureItem_args:
14493 
  """
14494 
  Attributes:
14495 
   - itemId
14496 
   - cartId
14497 
   - toInsure
9299 kshitij.so 14498 
   - insurerType
6903 anupam.sin 14499 
  """
14500 
 
14501 
  thrift_spec = (
14502 
    None, # 0
14503 
    (1, TType.I64, 'itemId', None, None, ), # 1
14504 
    (2, TType.I64, 'cartId', None, None, ), # 2
14505 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14506 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14507 
  )
14508 
 
9299 kshitij.so 14509 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14510 
    self.itemId = itemId
14511 
    self.cartId = cartId
14512 
    self.toInsure = toInsure
9299 kshitij.so 14513 
    self.insurerType = insurerType
6903 anupam.sin 14514 
 
14515 
  def read(self, iprot):
14516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14518 
      return
14519 
    iprot.readStructBegin()
14520 
    while True:
14521 
      (fname, ftype, fid) = iprot.readFieldBegin()
14522 
      if ftype == TType.STOP:
14523 
        break
14524 
      if fid == 1:
14525 
        if ftype == TType.I64:
14526 
          self.itemId = iprot.readI64();
14527 
        else:
14528 
          iprot.skip(ftype)
14529 
      elif fid == 2:
14530 
        if ftype == TType.I64:
14531 
          self.cartId = iprot.readI64();
14532 
        else:
14533 
          iprot.skip(ftype)
14534 
      elif fid == 3:
14535 
        if ftype == TType.BOOL:
14536 
          self.toInsure = iprot.readBool();
14537 
        else:
14538 
          iprot.skip(ftype)
9299 kshitij.so 14539 
      elif fid == 4:
14540 
        if ftype == TType.I32:
14541 
          self.insurerType = iprot.readI32();
14542 
        else:
14543 
          iprot.skip(ftype)
6903 anupam.sin 14544 
      else:
14545 
        iprot.skip(ftype)
14546 
      iprot.readFieldEnd()
14547 
    iprot.readStructEnd()
14548 
 
14549 
  def write(self, oprot):
14550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14552 
      return
14553 
    oprot.writeStructBegin('insureItem_args')
14554 
    if self.itemId is not None:
14555 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14556 
      oprot.writeI64(self.itemId)
14557 
      oprot.writeFieldEnd()
14558 
    if self.cartId is not None:
14559 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14560 
      oprot.writeI64(self.cartId)
14561 
      oprot.writeFieldEnd()
14562 
    if self.toInsure is not None:
14563 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14564 
      oprot.writeBool(self.toInsure)
14565 
      oprot.writeFieldEnd()
9299 kshitij.so 14566 
    if self.insurerType is not None:
14567 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14568 
      oprot.writeI32(self.insurerType)
14569 
      oprot.writeFieldEnd()
6903 anupam.sin 14570 
    oprot.writeFieldStop()
14571 
    oprot.writeStructEnd()
14572 
 
14573 
  def validate(self):
14574 
    return
14575 
 
14576 
 
14577 
  def __repr__(self):
14578 
    L = ['%s=%r' % (key, value)
14579 
      for key, value in self.__dict__.iteritems()]
14580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14581 
 
14582 
  def __eq__(self, other):
14583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14584 
 
14585 
  def __ne__(self, other):
14586 
    return not (self == other)
14587 
 
14588 
class insureItem_result:
14589 
  """
14590 
  Attributes:
14591 
   - success
14592 
  """
14593 
 
14594 
  thrift_spec = (
14595 
    (0, TType.BOOL, 'success', None, None, ), # 0
14596 
  )
14597 
 
14598 
  def __init__(self, success=None,):
14599 
    self.success = success
14600 
 
14601 
  def read(self, iprot):
14602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14604 
      return
14605 
    iprot.readStructBegin()
14606 
    while True:
14607 
      (fname, ftype, fid) = iprot.readFieldBegin()
14608 
      if ftype == TType.STOP:
14609 
        break
14610 
      if fid == 0:
14611 
        if ftype == TType.BOOL:
14612 
          self.success = iprot.readBool();
14613 
        else:
14614 
          iprot.skip(ftype)
14615 
      else:
14616 
        iprot.skip(ftype)
14617 
      iprot.readFieldEnd()
14618 
    iprot.readStructEnd()
14619 
 
14620 
  def write(self, oprot):
14621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14623 
      return
14624 
    oprot.writeStructBegin('insureItem_result')
14625 
    if self.success is not None:
14626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14627 
      oprot.writeBool(self.success)
14628 
      oprot.writeFieldEnd()
14629 
    oprot.writeFieldStop()
14630 
    oprot.writeStructEnd()
14631 
 
14632 
  def validate(self):
14633 
    return
14634 
 
14635 
 
14636 
  def __repr__(self):
14637 
    L = ['%s=%r' % (key, value)
14638 
      for key, value in self.__dict__.iteritems()]
14639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14640 
 
14641 
  def __eq__(self, other):
14642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14643 
 
14644 
  def __ne__(self, other):
14645 
    return not (self == other)
14646 
 
14647 
class cancelInsurance_args:
14648 
  """
14649 
  Attributes:
14650 
   - cartId
14651 
  """
14652 
 
14653 
  thrift_spec = (
14654 
    None, # 0
14655 
    (1, TType.I64, 'cartId', None, None, ), # 1
14656 
  )
14657 
 
14658 
  def __init__(self, cartId=None,):
14659 
    self.cartId = cartId
14660 
 
14661 
  def read(self, iprot):
14662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14664 
      return
14665 
    iprot.readStructBegin()
14666 
    while True:
14667 
      (fname, ftype, fid) = iprot.readFieldBegin()
14668 
      if ftype == TType.STOP:
14669 
        break
14670 
      if fid == 1:
14671 
        if ftype == TType.I64:
14672 
          self.cartId = iprot.readI64();
14673 
        else:
14674 
          iprot.skip(ftype)
14675 
      else:
14676 
        iprot.skip(ftype)
14677 
      iprot.readFieldEnd()
14678 
    iprot.readStructEnd()
14679 
 
14680 
  def write(self, oprot):
14681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14683 
      return
14684 
    oprot.writeStructBegin('cancelInsurance_args')
14685 
    if self.cartId is not None:
14686 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14687 
      oprot.writeI64(self.cartId)
14688 
      oprot.writeFieldEnd()
14689 
    oprot.writeFieldStop()
14690 
    oprot.writeStructEnd()
14691 
 
14692 
  def validate(self):
14693 
    return
14694 
 
14695 
 
14696 
  def __repr__(self):
14697 
    L = ['%s=%r' % (key, value)
14698 
      for key, value in self.__dict__.iteritems()]
14699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14700 
 
14701 
  def __eq__(self, other):
14702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14703 
 
14704 
  def __ne__(self, other):
14705 
    return not (self == other)
14706 
 
14707 
class cancelInsurance_result:
14708 
  """
14709 
  Attributes:
14710 
   - success
14711 
  """
14712 
 
14713 
  thrift_spec = (
14714 
    (0, TType.BOOL, 'success', None, None, ), # 0
14715 
  )
14716 
 
14717 
  def __init__(self, success=None,):
14718 
    self.success = success
14719 
 
14720 
  def read(self, iprot):
14721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14723 
      return
14724 
    iprot.readStructBegin()
14725 
    while True:
14726 
      (fname, ftype, fid) = iprot.readFieldBegin()
14727 
      if ftype == TType.STOP:
14728 
        break
14729 
      if fid == 0:
14730 
        if ftype == TType.BOOL:
14731 
          self.success = iprot.readBool();
14732 
        else:
14733 
          iprot.skip(ftype)
14734 
      else:
14735 
        iprot.skip(ftype)
14736 
      iprot.readFieldEnd()
14737 
    iprot.readStructEnd()
14738 
 
14739 
  def write(self, oprot):
14740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14742 
      return
14743 
    oprot.writeStructBegin('cancelInsurance_result')
14744 
    if self.success is not None:
14745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14746 
      oprot.writeBool(self.success)
14747 
      oprot.writeFieldEnd()
14748 
    oprot.writeFieldStop()
14749 
    oprot.writeStructEnd()
14750 
 
14751 
  def validate(self):
14752 
    return
14753 
 
14754 
 
14755 
  def __repr__(self):
14756 
    L = ['%s=%r' % (key, value)
14757 
      for key, value in self.__dict__.iteritems()]
14758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14759 
 
14760 
  def __eq__(self, other):
14761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14762 
 
14763 
  def __ne__(self, other):
14764 
    return not (self == other)
14765 
 
14766 
class storeInsuranceSpecificDetails_args:
14767 
  """
14768 
  Attributes:
14769 
   - addressId
14770 
   - dob
14771 
   - guardianName
14772 
  """
14773 
 
14774 
  thrift_spec = (
14775 
    None, # 0
14776 
    (1, TType.I64, 'addressId', None, None, ), # 1
14777 
    (2, TType.STRING, 'dob', None, None, ), # 2
14778 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14779 
  )
14780 
 
14781 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14782 
    self.addressId = addressId
14783 
    self.dob = dob
14784 
    self.guardianName = guardianName
14785 
 
14786 
  def read(self, iprot):
14787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14789 
      return
14790 
    iprot.readStructBegin()
14791 
    while True:
14792 
      (fname, ftype, fid) = iprot.readFieldBegin()
14793 
      if ftype == TType.STOP:
14794 
        break
14795 
      if fid == 1:
14796 
        if ftype == TType.I64:
14797 
          self.addressId = iprot.readI64();
14798 
        else:
14799 
          iprot.skip(ftype)
14800 
      elif fid == 2:
14801 
        if ftype == TType.STRING:
14802 
          self.dob = iprot.readString();
14803 
        else:
14804 
          iprot.skip(ftype)
14805 
      elif fid == 3:
14806 
        if ftype == TType.STRING:
14807 
          self.guardianName = iprot.readString();
14808 
        else:
14809 
          iprot.skip(ftype)
14810 
      else:
14811 
        iprot.skip(ftype)
14812 
      iprot.readFieldEnd()
14813 
    iprot.readStructEnd()
14814 
 
14815 
  def write(self, oprot):
14816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14818 
      return
14819 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14820 
    if self.addressId is not None:
14821 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14822 
      oprot.writeI64(self.addressId)
14823 
      oprot.writeFieldEnd()
14824 
    if self.dob is not None:
14825 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14826 
      oprot.writeString(self.dob)
14827 
      oprot.writeFieldEnd()
14828 
    if self.guardianName is not None:
14829 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14830 
      oprot.writeString(self.guardianName)
14831 
      oprot.writeFieldEnd()
14832 
    oprot.writeFieldStop()
14833 
    oprot.writeStructEnd()
14834 
 
14835 
  def validate(self):
14836 
    return
14837 
 
14838 
 
14839 
  def __repr__(self):
14840 
    L = ['%s=%r' % (key, value)
14841 
      for key, value in self.__dict__.iteritems()]
14842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14843 
 
14844 
  def __eq__(self, other):
14845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14846 
 
14847 
  def __ne__(self, other):
14848 
    return not (self == other)
14849 
 
14850 
class storeInsuranceSpecificDetails_result:
14851 
  """
14852 
  Attributes:
14853 
   - success
14854 
  """
14855 
 
14856 
  thrift_spec = (
14857 
    (0, TType.BOOL, 'success', None, None, ), # 0
14858 
  )
14859 
 
14860 
  def __init__(self, success=None,):
14861 
    self.success = success
14862 
 
14863 
  def read(self, iprot):
14864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14866 
      return
14867 
    iprot.readStructBegin()
14868 
    while True:
14869 
      (fname, ftype, fid) = iprot.readFieldBegin()
14870 
      if ftype == TType.STOP:
14871 
        break
14872 
      if fid == 0:
14873 
        if ftype == TType.BOOL:
14874 
          self.success = iprot.readBool();
14875 
        else:
14876 
          iprot.skip(ftype)
14877 
      else:
14878 
        iprot.skip(ftype)
14879 
      iprot.readFieldEnd()
14880 
    iprot.readStructEnd()
14881 
 
14882 
  def write(self, oprot):
14883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14885 
      return
14886 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14887 
    if self.success is not None:
14888 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14889 
      oprot.writeBool(self.success)
14890 
      oprot.writeFieldEnd()
14891 
    oprot.writeFieldStop()
14892 
    oprot.writeStructEnd()
14893 
 
14894 
  def validate(self):
14895 
    return
14896 
 
14897 
 
14898 
  def __repr__(self):
14899 
    L = ['%s=%r' % (key, value)
14900 
      for key, value in self.__dict__.iteritems()]
14901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14902 
 
14903 
  def __eq__(self, other):
14904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14905 
 
14906 
  def __ne__(self, other):
14907 
    return not (self == other)
14908 
 
14909 
class isInsuranceDetailPresent_args:
14910 
  """
14911 
  Attributes:
14912 
   - addressId
14913 
  """
14914 
 
14915 
  thrift_spec = (
14916 
    None, # 0
14917 
    (1, TType.I64, 'addressId', None, None, ), # 1
14918 
  )
14919 
 
14920 
  def __init__(self, addressId=None,):
14921 
    self.addressId = addressId
14922 
 
14923 
  def read(self, iprot):
14924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14926 
      return
14927 
    iprot.readStructBegin()
14928 
    while True:
14929 
      (fname, ftype, fid) = iprot.readFieldBegin()
14930 
      if ftype == TType.STOP:
14931 
        break
14932 
      if fid == 1:
14933 
        if ftype == TType.I64:
14934 
          self.addressId = iprot.readI64();
14935 
        else:
14936 
          iprot.skip(ftype)
14937 
      else:
14938 
        iprot.skip(ftype)
14939 
      iprot.readFieldEnd()
14940 
    iprot.readStructEnd()
14941 
 
14942 
  def write(self, oprot):
14943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14945 
      return
14946 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14947 
    if self.addressId is not None:
14948 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14949 
      oprot.writeI64(self.addressId)
14950 
      oprot.writeFieldEnd()
14951 
    oprot.writeFieldStop()
14952 
    oprot.writeStructEnd()
14953 
 
14954 
  def validate(self):
14955 
    return
14956 
 
14957 
 
14958 
  def __repr__(self):
14959 
    L = ['%s=%r' % (key, value)
14960 
      for key, value in self.__dict__.iteritems()]
14961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14962 
 
14963 
  def __eq__(self, other):
14964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14965 
 
14966 
  def __ne__(self, other):
14967 
    return not (self == other)
14968 
 
14969 
class isInsuranceDetailPresent_result:
14970 
  """
14971 
  Attributes:
14972 
   - success
14973 
  """
14974 
 
14975 
  thrift_spec = (
14976 
    (0, TType.BOOL, 'success', None, None, ), # 0
14977 
  )
14978 
 
14979 
  def __init__(self, success=None,):
14980 
    self.success = success
14981 
 
14982 
  def read(self, iprot):
14983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14985 
      return
14986 
    iprot.readStructBegin()
14987 
    while True:
14988 
      (fname, ftype, fid) = iprot.readFieldBegin()
14989 
      if ftype == TType.STOP:
14990 
        break
14991 
      if fid == 0:
14992 
        if ftype == TType.BOOL:
14993 
          self.success = iprot.readBool();
14994 
        else:
14995 
          iprot.skip(ftype)
14996 
      else:
14997 
        iprot.skip(ftype)
14998 
      iprot.readFieldEnd()
14999 
    iprot.readStructEnd()
15000 
 
15001 
  def write(self, oprot):
15002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15004 
      return
15005 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15006 
    if self.success is not None:
15007 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15008 
      oprot.writeBool(self.success)
15009 
      oprot.writeFieldEnd()
15010 
    oprot.writeFieldStop()
15011 
    oprot.writeStructEnd()
15012 
 
15013 
  def validate(self):
15014 
    return
15015 
 
15016 
 
15017 
  def __repr__(self):
15018 
    L = ['%s=%r' % (key, value)
15019 
      for key, value in self.__dict__.iteritems()]
15020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15021 
 
15022 
  def __eq__(self, other):
15023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15024 
 
15025 
  def __ne__(self, other):
15026 
    return not (self == other)
15027 
 
9791 rajveer 15028 
class getProductsAddedToCart_args:
6821 amar.kumar 15029 
  """
15030 
  Attributes:
15031 
   - startDate
15032 
   - endDate
15033 
  """
15034 
 
15035 
  thrift_spec = (
15036 
    None, # 0
9791 rajveer 15037 
    (1, TType.I64, 'startDate', None, None, ), # 1
15038 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15039 
  )
15040 
 
9791 rajveer 15041 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15042 
    self.startDate = startDate
15043 
    self.endDate = endDate
15044 
 
15045 
  def read(self, iprot):
15046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15048 
      return
15049 
    iprot.readStructBegin()
15050 
    while True:
15051 
      (fname, ftype, fid) = iprot.readFieldBegin()
15052 
      if ftype == TType.STOP:
15053 
        break
15054 
      if fid == 1:
15055 
        if ftype == TType.I64:
9791 rajveer 15056 
          self.startDate = iprot.readI64();
6821 amar.kumar 15057 
        else:
15058 
          iprot.skip(ftype)
15059 
      elif fid == 2:
15060 
        if ftype == TType.I64:
15061 
          self.endDate = iprot.readI64();
15062 
        else:
15063 
          iprot.skip(ftype)
15064 
      else:
15065 
        iprot.skip(ftype)
15066 
      iprot.readFieldEnd()
15067 
    iprot.readStructEnd()
15068 
 
15069 
  def write(self, oprot):
15070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15072 
      return
9791 rajveer 15073 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15074 
    if self.startDate is not None:
9791 rajveer 15075 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15076 
      oprot.writeI64(self.startDate)
15077 
      oprot.writeFieldEnd()
15078 
    if self.endDate is not None:
9791 rajveer 15079 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15080 
      oprot.writeI64(self.endDate)
15081 
      oprot.writeFieldEnd()
15082 
    oprot.writeFieldStop()
15083 
    oprot.writeStructEnd()
15084 
 
15085 
  def validate(self):
15086 
    return
15087 
 
15088 
 
15089 
  def __repr__(self):
15090 
    L = ['%s=%r' % (key, value)
15091 
      for key, value in self.__dict__.iteritems()]
15092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15093 
 
15094 
  def __eq__(self, other):
15095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15096 
 
15097 
  def __ne__(self, other):
15098 
    return not (self == other)
15099 
 
9791 rajveer 15100 
class getProductsAddedToCart_result:
6821 amar.kumar 15101 
  """
15102 
  Attributes:
15103 
   - success
15104 
  """
15105 
 
15106 
  thrift_spec = (
9791 rajveer 15107 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15108 
  )
15109 
 
15110 
  def __init__(self, success=None,):
15111 
    self.success = success
15112 
 
15113 
  def read(self, iprot):
15114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15116 
      return
15117 
    iprot.readStructBegin()
15118 
    while True:
15119 
      (fname, ftype, fid) = iprot.readFieldBegin()
15120 
      if ftype == TType.STOP:
15121 
        break
15122 
      if fid == 0:
9791 rajveer 15123 
        if ftype == TType.LIST:
15124 
          self.success = []
11980 amit.gupta 15125 
          (_etype221, _size218) = iprot.readListBegin()
15126 
          for _i222 in xrange(_size218):
15127 
            _elem223 = iprot.readI64();
15128 
            self.success.append(_elem223)
9791 rajveer 15129 
          iprot.readListEnd()
6821 amar.kumar 15130 
        else:
15131 
          iprot.skip(ftype)
15132 
      else:
15133 
        iprot.skip(ftype)
15134 
      iprot.readFieldEnd()
15135 
    iprot.readStructEnd()
15136 
 
15137 
  def write(self, oprot):
15138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15140 
      return
9791 rajveer 15141 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15142 
    if self.success is not None:
9791 rajveer 15143 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15144 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15145 
      for iter224 in self.success:
15146 
        oprot.writeI64(iter224)
9791 rajveer 15147 
      oprot.writeListEnd()
6821 amar.kumar 15148 
      oprot.writeFieldEnd()
15149 
    oprot.writeFieldStop()
15150 
    oprot.writeStructEnd()
15151 
 
15152 
  def validate(self):
15153 
    return
15154 
 
15155 
 
15156 
  def __repr__(self):
15157 
    L = ['%s=%r' % (key, value)
15158 
      for key, value in self.__dict__.iteritems()]
15159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15160 
 
15161 
  def __eq__(self, other):
15162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15163 
 
15164 
  def __ne__(self, other):
15165 
    return not (self == other)
11592 amit.gupta 15166 
 
15167 
class validateCartPlus_args:
15168 
  """
15169 
  Attributes:
15170 
   - cartId
15171 
   - sourceId
11980 amit.gupta 15172 
   - dealerCoupon
11592 amit.gupta 15173 
  """
15174 
 
15175 
  thrift_spec = (
15176 
    None, # 0
15177 
    (1, TType.I64, 'cartId', None, None, ), # 1
15178 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15179 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15180 
  )
15181 
 
11980 amit.gupta 15182 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15183 
    self.cartId = cartId
15184 
    self.sourceId = sourceId
11980 amit.gupta 15185 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15186 
 
15187 
  def read(self, iprot):
15188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15190 
      return
15191 
    iprot.readStructBegin()
15192 
    while True:
15193 
      (fname, ftype, fid) = iprot.readFieldBegin()
15194 
      if ftype == TType.STOP:
15195 
        break
15196 
      if fid == 1:
15197 
        if ftype == TType.I64:
15198 
          self.cartId = iprot.readI64();
15199 
        else:
15200 
          iprot.skip(ftype)
15201 
      elif fid == 2:
15202 
        if ftype == TType.I64:
15203 
          self.sourceId = iprot.readI64();
15204 
        else:
15205 
          iprot.skip(ftype)
11980 amit.gupta 15206 
      elif fid == 3:
15207 
        if ftype == TType.STRING:
15208 
          self.dealerCoupon = iprot.readString();
15209 
        else:
15210 
          iprot.skip(ftype)
11592 amit.gupta 15211 
      else:
15212 
        iprot.skip(ftype)
15213 
      iprot.readFieldEnd()
15214 
    iprot.readStructEnd()
15215 
 
15216 
  def write(self, oprot):
15217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15219 
      return
15220 
    oprot.writeStructBegin('validateCartPlus_args')
15221 
    if self.cartId is not None:
15222 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15223 
      oprot.writeI64(self.cartId)
15224 
      oprot.writeFieldEnd()
15225 
    if self.sourceId is not None:
15226 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15227 
      oprot.writeI64(self.sourceId)
15228 
      oprot.writeFieldEnd()
11980 amit.gupta 15229 
    if self.dealerCoupon is not None:
15230 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15231 
      oprot.writeString(self.dealerCoupon)
15232 
      oprot.writeFieldEnd()
11592 amit.gupta 15233 
    oprot.writeFieldStop()
15234 
    oprot.writeStructEnd()
15235 
 
15236 
  def validate(self):
15237 
    return
15238 
 
15239 
 
15240 
  def __repr__(self):
15241 
    L = ['%s=%r' % (key, value)
15242 
      for key, value in self.__dict__.iteritems()]
15243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15244 
 
15245 
  def __eq__(self, other):
15246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15247 
 
15248 
  def __ne__(self, other):
15249 
    return not (self == other)
15250 
 
15251 
class validateCartPlus_result:
15252 
  """
15253 
  Attributes:
15254 
   - success
15255 
   - scex
15256 
  """
15257 
 
15258 
  thrift_spec = (
15259 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15260 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15261 
  )
15262 
 
15263 
  def __init__(self, success=None, scex=None,):
15264 
    self.success = success
15265 
    self.scex = scex
15266 
 
15267 
  def read(self, iprot):
15268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15270 
      return
15271 
    iprot.readStructBegin()
15272 
    while True:
15273 
      (fname, ftype, fid) = iprot.readFieldBegin()
15274 
      if ftype == TType.STOP:
15275 
        break
15276 
      if fid == 0:
15277 
        if ftype == TType.STRUCT:
15278 
          self.success = CartPlus()
15279 
          self.success.read(iprot)
15280 
        else:
15281 
          iprot.skip(ftype)
15282 
      elif fid == 1:
15283 
        if ftype == TType.STRUCT:
15284 
          self.scex = ShoppingCartException()
15285 
          self.scex.read(iprot)
15286 
        else:
15287 
          iprot.skip(ftype)
15288 
      else:
15289 
        iprot.skip(ftype)
15290 
      iprot.readFieldEnd()
15291 
    iprot.readStructEnd()
15292 
 
15293 
  def write(self, oprot):
15294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15296 
      return
15297 
    oprot.writeStructBegin('validateCartPlus_result')
15298 
    if self.success is not None:
15299 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15300 
      self.success.write(oprot)
15301 
      oprot.writeFieldEnd()
15302 
    if self.scex is not None:
15303 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15304 
      self.scex.write(oprot)
15305 
      oprot.writeFieldEnd()
15306 
    oprot.writeFieldStop()
15307 
    oprot.writeStructEnd()
15308 
 
15309 
  def validate(self):
15310 
    return
15311 
 
15312 
 
15313 
  def __repr__(self):
15314 
    L = ['%s=%r' % (key, value)
15315 
      for key, value in self.__dict__.iteritems()]
15316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15317 
 
15318 
  def __eq__(self, other):
15319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15320 
 
15321 
  def __ne__(self, other):
15322 
    return not (self == other)
11679 vikram.rag 15323 
 
15324 
class isPrivateDealUser_args:
15325 
  """
15326 
  Attributes:
15327 
   - userId
15328 
  """
15329 
 
15330 
  thrift_spec = (
15331 
    None, # 0
15332 
    (1, TType.I64, 'userId', None, None, ), # 1
15333 
  )
15334 
 
15335 
  def __init__(self, userId=None,):
15336 
    self.userId = userId
15337 
 
15338 
  def read(self, iprot):
15339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15341 
      return
15342 
    iprot.readStructBegin()
15343 
    while True:
15344 
      (fname, ftype, fid) = iprot.readFieldBegin()
15345 
      if ftype == TType.STOP:
15346 
        break
15347 
      if fid == 1:
15348 
        if ftype == TType.I64:
15349 
          self.userId = iprot.readI64();
15350 
        else:
15351 
          iprot.skip(ftype)
15352 
      else:
15353 
        iprot.skip(ftype)
15354 
      iprot.readFieldEnd()
15355 
    iprot.readStructEnd()
15356 
 
15357 
  def write(self, oprot):
15358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15360 
      return
15361 
    oprot.writeStructBegin('isPrivateDealUser_args')
15362 
    if self.userId is not None:
15363 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15364 
      oprot.writeI64(self.userId)
15365 
      oprot.writeFieldEnd()
15366 
    oprot.writeFieldStop()
15367 
    oprot.writeStructEnd()
15368 
 
15369 
  def validate(self):
15370 
    return
15371 
 
15372 
 
15373 
  def __repr__(self):
15374 
    L = ['%s=%r' % (key, value)
15375 
      for key, value in self.__dict__.iteritems()]
15376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15377 
 
15378 
  def __eq__(self, other):
15379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15380 
 
15381 
  def __ne__(self, other):
15382 
    return not (self == other)
15383 
 
15384 
class isPrivateDealUser_result:
15385 
  """
15386 
  Attributes:
15387 
   - success
15388 
  """
15389 
 
15390 
  thrift_spec = (
15391 
    (0, TType.BOOL, 'success', None, None, ), # 0
15392 
  )
15393 
 
15394 
  def __init__(self, success=None,):
15395 
    self.success = success
15396 
 
15397 
  def read(self, iprot):
15398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15400 
      return
15401 
    iprot.readStructBegin()
15402 
    while True:
15403 
      (fname, ftype, fid) = iprot.readFieldBegin()
15404 
      if ftype == TType.STOP:
15405 
        break
15406 
      if fid == 0:
15407 
        if ftype == TType.BOOL:
15408 
          self.success = iprot.readBool();
15409 
        else:
15410 
          iprot.skip(ftype)
15411 
      else:
15412 
        iprot.skip(ftype)
15413 
      iprot.readFieldEnd()
15414 
    iprot.readStructEnd()
15415 
 
15416 
  def write(self, oprot):
15417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15419 
      return
15420 
    oprot.writeStructBegin('isPrivateDealUser_result')
15421 
    if self.success is not None:
15422 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15423 
      oprot.writeBool(self.success)
15424 
      oprot.writeFieldEnd()
15425 
    oprot.writeFieldStop()
15426 
    oprot.writeStructEnd()
15427 
 
15428 
  def validate(self):
15429 
    return
15430 
 
15431 
 
15432 
  def __repr__(self):
15433 
    L = ['%s=%r' % (key, value)
15434 
      for key, value in self.__dict__.iteritems()]
15435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15436 
 
15437 
  def __eq__(self, other):
15438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15439 
 
15440 
  def __ne__(self, other):
15441 
    return not (self == other)
11890 kshitij.so 15442 
 
15443 
class addPrivateDealUser_args:
15444 
  """
15445 
  Attributes:
15446 
   - userId
15447 
  """
15448 
 
15449 
  thrift_spec = (
15450 
    None, # 0
15451 
    (1, TType.I64, 'userId', None, None, ), # 1
15452 
  )
15453 
 
15454 
  def __init__(self, userId=None,):
15455 
    self.userId = userId
15456 
 
15457 
  def read(self, iprot):
15458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15460 
      return
15461 
    iprot.readStructBegin()
15462 
    while True:
15463 
      (fname, ftype, fid) = iprot.readFieldBegin()
15464 
      if ftype == TType.STOP:
15465 
        break
15466 
      if fid == 1:
15467 
        if ftype == TType.I64:
15468 
          self.userId = iprot.readI64();
15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      else:
15472 
        iprot.skip(ftype)
15473 
      iprot.readFieldEnd()
15474 
    iprot.readStructEnd()
15475 
 
15476 
  def write(self, oprot):
15477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15479 
      return
15480 
    oprot.writeStructBegin('addPrivateDealUser_args')
15481 
    if self.userId is not None:
15482 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15483 
      oprot.writeI64(self.userId)
15484 
      oprot.writeFieldEnd()
15485 
    oprot.writeFieldStop()
15486 
    oprot.writeStructEnd()
15487 
 
15488 
  def validate(self):
15489 
    return
15490 
 
15491 
 
15492 
  def __repr__(self):
15493 
    L = ['%s=%r' % (key, value)
15494 
      for key, value in self.__dict__.iteritems()]
15495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15496 
 
15497 
  def __eq__(self, other):
15498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15499 
 
15500 
  def __ne__(self, other):
15501 
    return not (self == other)
15502 
 
15503 
class addPrivateDealUser_result:
15504 
  """
15505 
  Attributes:
15506 
   - success
15507 
  """
15508 
 
15509 
  thrift_spec = (
15510 
    (0, TType.BOOL, 'success', None, None, ), # 0
15511 
  )
15512 
 
15513 
  def __init__(self, success=None,):
15514 
    self.success = success
15515 
 
15516 
  def read(self, iprot):
15517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15519 
      return
15520 
    iprot.readStructBegin()
15521 
    while True:
15522 
      (fname, ftype, fid) = iprot.readFieldBegin()
15523 
      if ftype == TType.STOP:
15524 
        break
15525 
      if fid == 0:
15526 
        if ftype == TType.BOOL:
15527 
          self.success = iprot.readBool();
15528 
        else:
15529 
          iprot.skip(ftype)
15530 
      else:
15531 
        iprot.skip(ftype)
15532 
      iprot.readFieldEnd()
15533 
    iprot.readStructEnd()
15534 
 
15535 
  def write(self, oprot):
15536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15538 
      return
15539 
    oprot.writeStructBegin('addPrivateDealUser_result')
15540 
    if self.success is not None:
15541 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15542 
      oprot.writeBool(self.success)
15543 
      oprot.writeFieldEnd()
15544 
    oprot.writeFieldStop()
15545 
    oprot.writeStructEnd()
15546 
 
15547 
  def validate(self):
15548 
    return
15549 
 
15550 
 
15551 
  def __repr__(self):
15552 
    L = ['%s=%r' % (key, value)
15553 
      for key, value in self.__dict__.iteritems()]
15554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15555 
 
15556 
  def __eq__(self, other):
15557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15558 
 
15559 
  def __ne__(self, other):
15560 
    return not (self == other)
15561 
 
15562 
class changePrivateDealUserStatus_args:
15563 
  """
15564 
  Attributes:
15565 
   - userId
15566 
   - isActive
15567 
  """
15568 
 
15569 
  thrift_spec = (
15570 
    None, # 0
15571 
    (1, TType.I64, 'userId', None, None, ), # 1
15572 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15573 
  )
15574 
 
15575 
  def __init__(self, userId=None, isActive=None,):
15576 
    self.userId = userId
15577 
    self.isActive = isActive
15578 
 
15579 
  def read(self, iprot):
15580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15582 
      return
15583 
    iprot.readStructBegin()
15584 
    while True:
15585 
      (fname, ftype, fid) = iprot.readFieldBegin()
15586 
      if ftype == TType.STOP:
15587 
        break
15588 
      if fid == 1:
15589 
        if ftype == TType.I64:
15590 
          self.userId = iprot.readI64();
15591 
        else:
15592 
          iprot.skip(ftype)
15593 
      elif fid == 2:
15594 
        if ftype == TType.BOOL:
15595 
          self.isActive = iprot.readBool();
15596 
        else:
15597 
          iprot.skip(ftype)
15598 
      else:
15599 
        iprot.skip(ftype)
15600 
      iprot.readFieldEnd()
15601 
    iprot.readStructEnd()
15602 
 
15603 
  def write(self, oprot):
15604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15606 
      return
15607 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15608 
    if self.userId is not None:
15609 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15610 
      oprot.writeI64(self.userId)
15611 
      oprot.writeFieldEnd()
15612 
    if self.isActive is not None:
15613 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15614 
      oprot.writeBool(self.isActive)
15615 
      oprot.writeFieldEnd()
15616 
    oprot.writeFieldStop()
15617 
    oprot.writeStructEnd()
15618 
 
15619 
  def validate(self):
15620 
    return
15621 
 
15622 
 
15623 
  def __repr__(self):
15624 
    L = ['%s=%r' % (key, value)
15625 
      for key, value in self.__dict__.iteritems()]
15626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15627 
 
15628 
  def __eq__(self, other):
15629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15630 
 
15631 
  def __ne__(self, other):
15632 
    return not (self == other)
15633 
 
15634 
class changePrivateDealUserStatus_result:
15635 
  """
15636 
  Attributes:
15637 
   - success
15638 
  """
15639 
 
15640 
  thrift_spec = (
15641 
    (0, TType.BOOL, 'success', None, None, ), # 0
15642 
  )
15643 
 
15644 
  def __init__(self, success=None,):
15645 
    self.success = success
15646 
 
15647 
  def read(self, iprot):
15648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15650 
      return
15651 
    iprot.readStructBegin()
15652 
    while True:
15653 
      (fname, ftype, fid) = iprot.readFieldBegin()
15654 
      if ftype == TType.STOP:
15655 
        break
15656 
      if fid == 0:
15657 
        if ftype == TType.BOOL:
15658 
          self.success = iprot.readBool();
15659 
        else:
15660 
          iprot.skip(ftype)
15661 
      else:
15662 
        iprot.skip(ftype)
15663 
      iprot.readFieldEnd()
15664 
    iprot.readStructEnd()
15665 
 
15666 
  def write(self, oprot):
15667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15669 
      return
15670 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15671 
    if self.success is not None:
15672 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15673 
      oprot.writeBool(self.success)
15674 
      oprot.writeFieldEnd()
15675 
    oprot.writeFieldStop()
15676 
    oprot.writeStructEnd()
15677 
 
15678 
  def validate(self):
15679 
    return
15680 
 
15681 
 
15682 
  def __repr__(self):
15683 
    L = ['%s=%r' % (key, value)
15684 
      for key, value in self.__dict__.iteritems()]
15685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15686 
 
15687 
  def __eq__(self, other):
15688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15689 
 
15690 
  def __ne__(self, other):
15691 
    return not (self == other)
15692 
 
15693 
class getPrivateDealUser_args:
15694 
  """
15695 
  Attributes:
15696 
   - userId
15697 
  """
15698 
 
15699 
  thrift_spec = (
15700 
    None, # 0
15701 
    (1, TType.I64, 'userId', None, None, ), # 1
15702 
  )
15703 
 
15704 
  def __init__(self, userId=None,):
15705 
    self.userId = userId
15706 
 
15707 
  def read(self, iprot):
15708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15710 
      return
15711 
    iprot.readStructBegin()
15712 
    while True:
15713 
      (fname, ftype, fid) = iprot.readFieldBegin()
15714 
      if ftype == TType.STOP:
15715 
        break
15716 
      if fid == 1:
15717 
        if ftype == TType.I64:
15718 
          self.userId = iprot.readI64();
15719 
        else:
15720 
          iprot.skip(ftype)
15721 
      else:
15722 
        iprot.skip(ftype)
15723 
      iprot.readFieldEnd()
15724 
    iprot.readStructEnd()
15725 
 
15726 
  def write(self, oprot):
15727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15729 
      return
15730 
    oprot.writeStructBegin('getPrivateDealUser_args')
15731 
    if self.userId is not None:
15732 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15733 
      oprot.writeI64(self.userId)
15734 
      oprot.writeFieldEnd()
15735 
    oprot.writeFieldStop()
15736 
    oprot.writeStructEnd()
15737 
 
15738 
  def validate(self):
15739 
    return
15740 
 
15741 
 
15742 
  def __repr__(self):
15743 
    L = ['%s=%r' % (key, value)
15744 
      for key, value in self.__dict__.iteritems()]
15745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15746 
 
15747 
  def __eq__(self, other):
15748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15749 
 
15750 
  def __ne__(self, other):
15751 
    return not (self == other)
15752 
 
15753 
class getPrivateDealUser_result:
15754 
  """
15755 
  Attributes:
15756 
   - success
15757 
  """
15758 
 
15759 
  thrift_spec = (
15760 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15761 
  )
15762 
 
15763 
  def __init__(self, success=None,):
15764 
    self.success = success
15765 
 
15766 
  def read(self, iprot):
15767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15769 
      return
15770 
    iprot.readStructBegin()
15771 
    while True:
15772 
      (fname, ftype, fid) = iprot.readFieldBegin()
15773 
      if ftype == TType.STOP:
15774 
        break
15775 
      if fid == 0:
15776 
        if ftype == TType.STRUCT:
15777 
          self.success = PrivateDealUser()
15778 
          self.success.read(iprot)
15779 
        else:
15780 
          iprot.skip(ftype)
15781 
      else:
15782 
        iprot.skip(ftype)
15783 
      iprot.readFieldEnd()
15784 
    iprot.readStructEnd()
15785 
 
15786 
  def write(self, oprot):
15787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15789 
      return
15790 
    oprot.writeStructBegin('getPrivateDealUser_result')
15791 
    if self.success is not None:
15792 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15793 
      self.success.write(oprot)
15794 
      oprot.writeFieldEnd()
15795 
    oprot.writeFieldStop()
15796 
    oprot.writeStructEnd()
15797 
 
15798 
  def validate(self):
15799 
    return
15800 
 
15801 
 
15802 
  def __repr__(self):
15803 
    L = ['%s=%r' % (key, value)
15804 
      for key, value in self.__dict__.iteritems()]
15805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15806 
 
15807 
  def __eq__(self, other):
15808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15809 
 
15810 
  def __ne__(self, other):
15811 
    return not (self == other)
12696 amit.gupta 15812 
 
15813 
class registerCounter_args:
15814 
  """
15815 
  Attributes:
15816 
   - counter
15817 
   - userId
15818 
  """
15819 
 
15820 
  thrift_spec = (
15821 
    None, # 0
15822 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15823 
    (2, TType.I64, 'userId', None, None, ), # 2
15824 
  )
15825 
 
15826 
  def __init__(self, counter=None, userId=None,):
15827 
    self.counter = counter
15828 
    self.userId = userId
15829 
 
15830 
  def read(self, iprot):
15831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15833 
      return
15834 
    iprot.readStructBegin()
15835 
    while True:
15836 
      (fname, ftype, fid) = iprot.readFieldBegin()
15837 
      if ftype == TType.STOP:
15838 
        break
15839 
      if fid == 1:
15840 
        if ftype == TType.STRUCT:
15841 
          self.counter = Counter()
15842 
          self.counter.read(iprot)
15843 
        else:
15844 
          iprot.skip(ftype)
15845 
      elif fid == 2:
15846 
        if ftype == TType.I64:
15847 
          self.userId = iprot.readI64();
15848 
        else:
15849 
          iprot.skip(ftype)
15850 
      else:
15851 
        iprot.skip(ftype)
15852 
      iprot.readFieldEnd()
15853 
    iprot.readStructEnd()
15854 
 
15855 
  def write(self, oprot):
15856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15858 
      return
15859 
    oprot.writeStructBegin('registerCounter_args')
15860 
    if self.counter is not None:
15861 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15862 
      self.counter.write(oprot)
15863 
      oprot.writeFieldEnd()
15864 
    if self.userId is not None:
15865 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15866 
      oprot.writeI64(self.userId)
15867 
      oprot.writeFieldEnd()
15868 
    oprot.writeFieldStop()
15869 
    oprot.writeStructEnd()
15870 
 
15871 
  def validate(self):
15872 
    return
15873 
 
15874 
 
15875 
  def __repr__(self):
15876 
    L = ['%s=%r' % (key, value)
15877 
      for key, value in self.__dict__.iteritems()]
15878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15879 
 
15880 
  def __eq__(self, other):
15881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15882 
 
15883 
  def __ne__(self, other):
15884 
    return not (self == other)
15885 
 
15886 
class registerCounter_result:
15887 
  """
15888 
  Attributes:
15889 
   - success
15890 
  """
15891 
 
15892 
  thrift_spec = (
15893 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15894 
  )
15895 
 
15896 
  def __init__(self, success=None,):
15897 
    self.success = success
15898 
 
15899 
  def read(self, iprot):
15900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15902 
      return
15903 
    iprot.readStructBegin()
15904 
    while True:
15905 
      (fname, ftype, fid) = iprot.readFieldBegin()
15906 
      if ftype == TType.STOP:
15907 
        break
15908 
      if fid == 0:
15909 
        if ftype == TType.MAP:
15910 
          self.success = {}
15911 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15912 
          for _i229 in xrange(_size225):
15913 
            _key230 = iprot.readString();
15914 
            _val231 = iprot.readString();
15915 
            self.success[_key230] = _val231
15916 
          iprot.readMapEnd()
15917 
        else:
15918 
          iprot.skip(ftype)
15919 
      else:
15920 
        iprot.skip(ftype)
15921 
      iprot.readFieldEnd()
15922 
    iprot.readStructEnd()
15923 
 
15924 
  def write(self, oprot):
15925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15927 
      return
15928 
    oprot.writeStructBegin('registerCounter_result')
15929 
    if self.success is not None:
15930 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15931 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15932 
      for kiter232,viter233 in self.success.items():
15933 
        oprot.writeString(kiter232)
15934 
        oprot.writeString(viter233)
15935 
      oprot.writeMapEnd()
15936 
      oprot.writeFieldEnd()
15937 
    oprot.writeFieldStop()
15938 
    oprot.writeStructEnd()
15939 
 
15940 
  def validate(self):
15941 
    return
15942 
 
15943 
 
15944 
  def __repr__(self):
15945 
    L = ['%s=%r' % (key, value)
15946 
      for key, value in self.__dict__.iteritems()]
15947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15948 
 
15949 
  def __eq__(self, other):
15950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15951 
 
15952 
  def __ne__(self, other):
15953 
    return not (self == other)
12722 amit.gupta 15954 
 
15955 
class searchCounter_args:
15956 
  """
15957 
  Attributes:
15958 
   - type1
15959 
   - searchString
15960 
  """
15961 
 
15962 
  thrift_spec = (
15963 
    None, # 0
15964 
    (1, TType.STRING, 'type1', None, None, ), # 1
15965 
    (2, TType.STRING, 'searchString', None, None, ), # 2
15966 
  )
15967 
 
15968 
  def __init__(self, type1=None, searchString=None,):
15969 
    self.type1 = type1
15970 
    self.searchString = searchString
15971 
 
15972 
  def read(self, iprot):
15973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15975 
      return
15976 
    iprot.readStructBegin()
15977 
    while True:
15978 
      (fname, ftype, fid) = iprot.readFieldBegin()
15979 
      if ftype == TType.STOP:
15980 
        break
15981 
      if fid == 1:
15982 
        if ftype == TType.STRING:
15983 
          self.type1 = iprot.readString();
15984 
        else:
15985 
          iprot.skip(ftype)
15986 
      elif fid == 2:
15987 
        if ftype == TType.STRING:
15988 
          self.searchString = iprot.readString();
15989 
        else:
15990 
          iprot.skip(ftype)
15991 
      else:
15992 
        iprot.skip(ftype)
15993 
      iprot.readFieldEnd()
15994 
    iprot.readStructEnd()
15995 
 
15996 
  def write(self, oprot):
15997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15999 
      return
16000 
    oprot.writeStructBegin('searchCounter_args')
16001 
    if self.type1 is not None:
16002 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16003 
      oprot.writeString(self.type1)
16004 
      oprot.writeFieldEnd()
16005 
    if self.searchString is not None:
16006 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16007 
      oprot.writeString(self.searchString)
16008 
      oprot.writeFieldEnd()
16009 
    oprot.writeFieldStop()
16010 
    oprot.writeStructEnd()
16011 
 
16012 
  def validate(self):
16013 
    return
16014 
 
16015 
 
16016 
  def __repr__(self):
16017 
    L = ['%s=%r' % (key, value)
16018 
      for key, value in self.__dict__.iteritems()]
16019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16020 
 
16021 
  def __eq__(self, other):
16022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16023 
 
16024 
  def __ne__(self, other):
16025 
    return not (self == other)
16026 
 
16027 
class searchCounter_result:
16028 
  """
16029 
  Attributes:
16030 
   - success
16031 
  """
16032 
 
16033 
  thrift_spec = (
16034 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16035 
  )
16036 
 
16037 
  def __init__(self, success=None,):
16038 
    self.success = success
16039 
 
16040 
  def read(self, iprot):
16041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16043 
      return
16044 
    iprot.readStructBegin()
16045 
    while True:
16046 
      (fname, ftype, fid) = iprot.readFieldBegin()
16047 
      if ftype == TType.STOP:
16048 
        break
16049 
      if fid == 0:
16050 
        if ftype == TType.LIST:
16051 
          self.success = []
16052 
          (_etype237, _size234) = iprot.readListBegin()
16053 
          for _i238 in xrange(_size234):
16054 
            _elem239 = Counter()
16055 
            _elem239.read(iprot)
16056 
            self.success.append(_elem239)
16057 
          iprot.readListEnd()
16058 
        else:
16059 
          iprot.skip(ftype)
16060 
      else:
16061 
        iprot.skip(ftype)
16062 
      iprot.readFieldEnd()
16063 
    iprot.readStructEnd()
16064 
 
16065 
  def write(self, oprot):
16066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16068 
      return
16069 
    oprot.writeStructBegin('searchCounter_result')
16070 
    if self.success is not None:
16071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16072 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16073 
      for iter240 in self.success:
16074 
        iter240.write(oprot)
16075 
      oprot.writeListEnd()
16076 
      oprot.writeFieldEnd()
16077 
    oprot.writeFieldStop()
16078 
    oprot.writeStructEnd()
16079 
 
16080 
  def validate(self):
16081 
    return
16082 
 
16083 
 
16084 
  def __repr__(self):
16085 
    L = ['%s=%r' % (key, value)
16086 
      for key, value in self.__dict__.iteritems()]
16087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16088 
 
16089 
  def __eq__(self, other):
16090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16091 
 
16092 
  def __ne__(self, other):
16093 
    return not (self == other)
16094 
 
16095 
class getAllUsersByCounter_args:
16096 
  """
16097 
  Attributes:
16098 
   - counterId
16099 
  """
16100 
 
16101 
  thrift_spec = (
16102 
    None, # 0
16103 
    (1, TType.I64, 'counterId', None, None, ), # 1
16104 
  )
16105 
 
16106 
  def __init__(self, counterId=None,):
16107 
    self.counterId = counterId
16108 
 
16109 
  def read(self, iprot):
16110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16112 
      return
16113 
    iprot.readStructBegin()
16114 
    while True:
16115 
      (fname, ftype, fid) = iprot.readFieldBegin()
16116 
      if ftype == TType.STOP:
16117 
        break
16118 
      if fid == 1:
16119 
        if ftype == TType.I64:
16120 
          self.counterId = iprot.readI64();
16121 
        else:
16122 
          iprot.skip(ftype)
16123 
      else:
16124 
        iprot.skip(ftype)
16125 
      iprot.readFieldEnd()
16126 
    iprot.readStructEnd()
16127 
 
16128 
  def write(self, oprot):
16129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16131 
      return
16132 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16133 
    if self.counterId is not None:
16134 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16135 
      oprot.writeI64(self.counterId)
16136 
      oprot.writeFieldEnd()
16137 
    oprot.writeFieldStop()
16138 
    oprot.writeStructEnd()
16139 
 
16140 
  def validate(self):
16141 
    return
16142 
 
16143 
 
16144 
  def __repr__(self):
16145 
    L = ['%s=%r' % (key, value)
16146 
      for key, value in self.__dict__.iteritems()]
16147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16148 
 
16149 
  def __eq__(self, other):
16150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16151 
 
16152 
  def __ne__(self, other):
16153 
    return not (self == other)
16154 
 
16155 
class getAllUsersByCounter_result:
16156 
  """
16157 
  Attributes:
16158 
   - success
16159 
  """
16160 
 
16161 
  thrift_spec = (
16162 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16163 
  )
16164 
 
16165 
  def __init__(self, success=None,):
16166 
    self.success = success
16167 
 
16168 
  def read(self, iprot):
16169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16171 
      return
16172 
    iprot.readStructBegin()
16173 
    while True:
16174 
      (fname, ftype, fid) = iprot.readFieldBegin()
16175 
      if ftype == TType.STOP:
16176 
        break
16177 
      if fid == 0:
16178 
        if ftype == TType.LIST:
16179 
          self.success = []
16180 
          (_etype244, _size241) = iprot.readListBegin()
16181 
          for _i245 in xrange(_size241):
16182 
            _elem246 = User()
16183 
            _elem246.read(iprot)
16184 
            self.success.append(_elem246)
16185 
          iprot.readListEnd()
16186 
        else:
16187 
          iprot.skip(ftype)
16188 
      else:
16189 
        iprot.skip(ftype)
16190 
      iprot.readFieldEnd()
16191 
    iprot.readStructEnd()
16192 
 
16193 
  def write(self, oprot):
16194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16196 
      return
16197 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16198 
    if self.success is not None:
16199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16201 
      for iter247 in self.success:
16202 
        iter247.write(oprot)
16203 
      oprot.writeListEnd()
16204 
      oprot.writeFieldEnd()
16205 
    oprot.writeFieldStop()
16206 
    oprot.writeStructEnd()
16207 
 
16208 
  def validate(self):
16209 
    return
16210 
 
16211 
 
16212 
  def __repr__(self):
16213 
    L = ['%s=%r' % (key, value)
16214 
      for key, value in self.__dict__.iteritems()]
16215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16216 
 
16217 
  def __eq__(self, other):
16218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16219 
 
16220 
  def __ne__(self, other):
16221 
    return not (self == other)
15251 manish.sha 16222 
 
16223 
class getActiveAccessTokenForUser_args:
16224 
  """
16225 
  Attributes:
16226 
   - userId
16227 
   - source
16228 
  """
16229 
 
16230 
  thrift_spec = (
16231 
    None, # 0
16232 
    (1, TType.I64, 'userId', None, None, ), # 1
16233 
    (2, TType.STRING, 'source', None, None, ), # 2
16234 
  )
16235 
 
16236 
  def __init__(self, userId=None, source=None,):
16237 
    self.userId = userId
16238 
    self.source = source
16239 
 
16240 
  def read(self, iprot):
16241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16243 
      return
16244 
    iprot.readStructBegin()
16245 
    while True:
16246 
      (fname, ftype, fid) = iprot.readFieldBegin()
16247 
      if ftype == TType.STOP:
16248 
        break
16249 
      if fid == 1:
16250 
        if ftype == TType.I64:
16251 
          self.userId = iprot.readI64();
16252 
        else:
16253 
          iprot.skip(ftype)
16254 
      elif fid == 2:
16255 
        if ftype == TType.STRING:
16256 
          self.source = iprot.readString();
16257 
        else:
16258 
          iprot.skip(ftype)
16259 
      else:
16260 
        iprot.skip(ftype)
16261 
      iprot.readFieldEnd()
16262 
    iprot.readStructEnd()
16263 
 
16264 
  def write(self, oprot):
16265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16267 
      return
16268 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16269 
    if self.userId is not None:
16270 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16271 
      oprot.writeI64(self.userId)
16272 
      oprot.writeFieldEnd()
16273 
    if self.source is not None:
16274 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16275 
      oprot.writeString(self.source)
16276 
      oprot.writeFieldEnd()
16277 
    oprot.writeFieldStop()
16278 
    oprot.writeStructEnd()
16279 
 
16280 
  def validate(self):
16281 
    return
16282 
 
16283 
 
16284 
  def __repr__(self):
16285 
    L = ['%s=%r' % (key, value)
16286 
      for key, value in self.__dict__.iteritems()]
16287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16288 
 
16289 
  def __eq__(self, other):
16290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16291 
 
16292 
  def __ne__(self, other):
16293 
    return not (self == other)
16294 
 
16295 
class getActiveAccessTokenForUser_result:
16296 
  """
16297 
  Attributes:
16298 
   - success
16299 
  """
16300 
 
16301 
  thrift_spec = (
16302 
    (0, TType.STRING, 'success', None, None, ), # 0
16303 
  )
16304 
 
16305 
  def __init__(self, success=None,):
16306 
    self.success = success
16307 
 
16308 
  def read(self, iprot):
16309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16311 
      return
16312 
    iprot.readStructBegin()
16313 
    while True:
16314 
      (fname, ftype, fid) = iprot.readFieldBegin()
16315 
      if ftype == TType.STOP:
16316 
        break
16317 
      if fid == 0:
16318 
        if ftype == TType.STRING:
16319 
          self.success = iprot.readString();
16320 
        else:
16321 
          iprot.skip(ftype)
16322 
      else:
16323 
        iprot.skip(ftype)
16324 
      iprot.readFieldEnd()
16325 
    iprot.readStructEnd()
16326 
 
16327 
  def write(self, oprot):
16328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16330 
      return
16331 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16332 
    if self.success is not None:
16333 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16334 
      oprot.writeString(self.success)
16335 
      oprot.writeFieldEnd()
16336 
    oprot.writeFieldStop()
16337 
    oprot.writeStructEnd()
16338 
 
16339 
  def validate(self):
16340 
    return
16341 
 
16342 
 
16343 
  def __repr__(self):
16344 
    L = ['%s=%r' % (key, value)
16345 
      for key, value in self.__dict__.iteritems()]
16346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16347 
 
16348 
  def __eq__(self, other):
16349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16350 
 
16351 
  def __ne__(self, other):
16352 
    return not (self == other)
16353 
 
16354 
class validateAccessToken_args:
16355 
  """
16356 
  Attributes:
16357 
   - accessToken
16358 
  """
16359 
 
16360 
  thrift_spec = (
16361 
    None, # 0
16362 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16363 
  )
16364 
 
16365 
  def __init__(self, accessToken=None,):
16366 
    self.accessToken = accessToken
16367 
 
16368 
  def read(self, iprot):
16369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16371 
      return
16372 
    iprot.readStructBegin()
16373 
    while True:
16374 
      (fname, ftype, fid) = iprot.readFieldBegin()
16375 
      if ftype == TType.STOP:
16376 
        break
16377 
      if fid == 1:
16378 
        if ftype == TType.STRING:
16379 
          self.accessToken = iprot.readString();
16380 
        else:
16381 
          iprot.skip(ftype)
16382 
      else:
16383 
        iprot.skip(ftype)
16384 
      iprot.readFieldEnd()
16385 
    iprot.readStructEnd()
16386 
 
16387 
  def write(self, oprot):
16388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16390 
      return
16391 
    oprot.writeStructBegin('validateAccessToken_args')
16392 
    if self.accessToken is not None:
16393 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16394 
      oprot.writeString(self.accessToken)
16395 
      oprot.writeFieldEnd()
16396 
    oprot.writeFieldStop()
16397 
    oprot.writeStructEnd()
16398 
 
16399 
  def validate(self):
16400 
    return
16401 
 
16402 
 
16403 
  def __repr__(self):
16404 
    L = ['%s=%r' % (key, value)
16405 
      for key, value in self.__dict__.iteritems()]
16406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16407 
 
16408 
  def __eq__(self, other):
16409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16410 
 
16411 
  def __ne__(self, other):
16412 
    return not (self == other)
16413 
 
16414 
class validateAccessToken_result:
16415 
  """
16416 
  Attributes:
16417 
   - success
16418 
  """
16419 
 
16420 
  thrift_spec = (
16421 
    (0, TType.BOOL, 'success', None, None, ), # 0
16422 
  )
16423 
 
16424 
  def __init__(self, success=None,):
16425 
    self.success = success
16426 
 
16427 
  def read(self, iprot):
16428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16430 
      return
16431 
    iprot.readStructBegin()
16432 
    while True:
16433 
      (fname, ftype, fid) = iprot.readFieldBegin()
16434 
      if ftype == TType.STOP:
16435 
        break
16436 
      if fid == 0:
16437 
        if ftype == TType.BOOL:
16438 
          self.success = iprot.readBool();
16439 
        else:
16440 
          iprot.skip(ftype)
16441 
      else:
16442 
        iprot.skip(ftype)
16443 
      iprot.readFieldEnd()
16444 
    iprot.readStructEnd()
16445 
 
16446 
  def write(self, oprot):
16447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16449 
      return
16450 
    oprot.writeStructBegin('validateAccessToken_result')
16451 
    if self.success is not None:
16452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16453 
      oprot.writeBool(self.success)
16454 
      oprot.writeFieldEnd()
16455 
    oprot.writeFieldStop()
16456 
    oprot.writeStructEnd()
16457 
 
16458 
  def validate(self):
16459 
    return
16460 
 
16461 
 
16462 
  def __repr__(self):
16463 
    L = ['%s=%r' % (key, value)
16464 
      for key, value in self.__dict__.iteritems()]
16465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16466 
 
16467 
  def __eq__(self, other):
16468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16469 
 
16470 
  def __ne__(self, other):
16471 
    return not (self == other)
17782 amit.gupta 16472 
 
16473 
class addItemsToCart_args:
16474 
  """
16475 
  Attributes:
16476 
   - cartId
16477 
   - itemQty
16478 
   - couponCode
16479 
  """
16480 
 
16481 
  thrift_spec = (
16482 
    None, # 0
16483 
    (1, TType.I64, 'cartId', None, None, ), # 1
16484 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16485 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16486 
  )
16487 
 
16488 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16489 
    self.cartId = cartId
16490 
    self.itemQty = itemQty
16491 
    self.couponCode = couponCode
16492 
 
16493 
  def read(self, iprot):
16494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16496 
      return
16497 
    iprot.readStructBegin()
16498 
    while True:
16499 
      (fname, ftype, fid) = iprot.readFieldBegin()
16500 
      if ftype == TType.STOP:
16501 
        break
16502 
      if fid == 1:
16503 
        if ftype == TType.I64:
16504 
          self.cartId = iprot.readI64();
16505 
        else:
16506 
          iprot.skip(ftype)
16507 
      elif fid == 2:
16508 
        if ftype == TType.LIST:
16509 
          self.itemQty = []
16510 
          (_etype251, _size248) = iprot.readListBegin()
16511 
          for _i252 in xrange(_size248):
16512 
            _elem253 = ItemQuantity()
16513 
            _elem253.read(iprot)
16514 
            self.itemQty.append(_elem253)
16515 
          iprot.readListEnd()
16516 
        else:
16517 
          iprot.skip(ftype)
16518 
      elif fid == 3:
16519 
        if ftype == TType.STRING:
16520 
          self.couponCode = iprot.readString();
16521 
        else:
16522 
          iprot.skip(ftype)
16523 
      else:
16524 
        iprot.skip(ftype)
16525 
      iprot.readFieldEnd()
16526 
    iprot.readStructEnd()
16527 
 
16528 
  def write(self, oprot):
16529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16531 
      return
16532 
    oprot.writeStructBegin('addItemsToCart_args')
16533 
    if self.cartId is not None:
16534 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16535 
      oprot.writeI64(self.cartId)
16536 
      oprot.writeFieldEnd()
16537 
    if self.itemQty is not None:
16538 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16539 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16540 
      for iter254 in self.itemQty:
16541 
        iter254.write(oprot)
16542 
      oprot.writeListEnd()
16543 
      oprot.writeFieldEnd()
16544 
    if self.couponCode is not None:
16545 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16546 
      oprot.writeString(self.couponCode)
16547 
      oprot.writeFieldEnd()
16548 
    oprot.writeFieldStop()
16549 
    oprot.writeStructEnd()
16550 
 
16551 
  def validate(self):
16552 
    return
16553 
 
16554 
 
16555 
  def __repr__(self):
16556 
    L = ['%s=%r' % (key, value)
16557 
      for key, value in self.__dict__.iteritems()]
16558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16559 
 
16560 
  def __eq__(self, other):
16561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16562 
 
16563 
  def __ne__(self, other):
16564 
    return not (self == other)
16565 
 
16566 
class addItemsToCart_result:
16567 
  """
16568 
  Attributes:
16569 
   - success
16570 
  """
16571 
 
16572 
  thrift_spec = (
16573 
    (0, TType.BOOL, 'success', None, None, ), # 0
16574 
  )
16575 
 
16576 
  def __init__(self, success=None,):
16577 
    self.success = success
16578 
 
16579 
  def read(self, iprot):
16580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16582 
      return
16583 
    iprot.readStructBegin()
16584 
    while True:
16585 
      (fname, ftype, fid) = iprot.readFieldBegin()
16586 
      if ftype == TType.STOP:
16587 
        break
16588 
      if fid == 0:
16589 
        if ftype == TType.BOOL:
16590 
          self.success = iprot.readBool();
16591 
        else:
16592 
          iprot.skip(ftype)
16593 
      else:
16594 
        iprot.skip(ftype)
16595 
      iprot.readFieldEnd()
16596 
    iprot.readStructEnd()
16597 
 
16598 
  def write(self, oprot):
16599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16601 
      return
16602 
    oprot.writeStructBegin('addItemsToCart_result')
16603 
    if self.success is not None:
16604 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16605 
      oprot.writeBool(self.success)
16606 
      oprot.writeFieldEnd()
16607 
    oprot.writeFieldStop()
16608 
    oprot.writeStructEnd()
16609 
 
16610 
  def validate(self):
16611 
    return
16612 
 
16613 
 
16614 
  def __repr__(self):
16615 
    L = ['%s=%r' % (key, value)
16616 
      for key, value in self.__dict__.iteritems()]
16617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16618 
 
16619 
  def __eq__(self, other):
16620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16621 
 
16622 
  def __ne__(self, other):
16623 
    return not (self == other)
16624 
 
16625 
class validateCartNew_args:
16626 
  """
16627 
  Attributes:
16628 
   - cartId
16629 
   - pinCode
16630 
   - sourceId
16631 
  """
16632 
 
16633 
  thrift_spec = (
16634 
    None, # 0
16635 
    (1, TType.I64, 'cartId', None, None, ), # 1
16636 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16637 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16638 
  )
16639 
 
16640 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16641 
    self.cartId = cartId
16642 
    self.pinCode = pinCode
16643 
    self.sourceId = sourceId
16644 
 
16645 
  def read(self, iprot):
16646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16648 
      return
16649 
    iprot.readStructBegin()
16650 
    while True:
16651 
      (fname, ftype, fid) = iprot.readFieldBegin()
16652 
      if ftype == TType.STOP:
16653 
        break
16654 
      if fid == 1:
16655 
        if ftype == TType.I64:
16656 
          self.cartId = iprot.readI64();
16657 
        else:
16658 
          iprot.skip(ftype)
16659 
      elif fid == 2:
16660 
        if ftype == TType.STRING:
16661 
          self.pinCode = iprot.readString();
16662 
        else:
16663 
          iprot.skip(ftype)
16664 
      elif fid == 3:
16665 
        if ftype == TType.I64:
16666 
          self.sourceId = iprot.readI64();
16667 
        else:
16668 
          iprot.skip(ftype)
16669 
      else:
16670 
        iprot.skip(ftype)
16671 
      iprot.readFieldEnd()
16672 
    iprot.readStructEnd()
16673 
 
16674 
  def write(self, oprot):
16675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16677 
      return
16678 
    oprot.writeStructBegin('validateCartNew_args')
16679 
    if self.cartId is not None:
16680 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16681 
      oprot.writeI64(self.cartId)
16682 
      oprot.writeFieldEnd()
16683 
    if self.pinCode is not None:
16684 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
16685 
      oprot.writeString(self.pinCode)
16686 
      oprot.writeFieldEnd()
16687 
    if self.sourceId is not None:
16688 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
16689 
      oprot.writeI64(self.sourceId)
16690 
      oprot.writeFieldEnd()
16691 
    oprot.writeFieldStop()
16692 
    oprot.writeStructEnd()
16693 
 
16694 
  def validate(self):
16695 
    return
16696 
 
16697 
 
16698 
  def __repr__(self):
16699 
    L = ['%s=%r' % (key, value)
16700 
      for key, value in self.__dict__.iteritems()]
16701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16702 
 
16703 
  def __eq__(self, other):
16704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16705 
 
16706 
  def __ne__(self, other):
16707 
    return not (self == other)
16708 
 
16709 
class validateCartNew_result:
16710 
  """
16711 
  Attributes:
16712 
   - success
16713 
  """
16714 
 
16715 
  thrift_spec = (
16716 
    (0, TType.STRING, 'success', None, None, ), # 0
16717 
  )
16718 
 
16719 
  def __init__(self, success=None,):
16720 
    self.success = success
16721 
 
16722 
  def read(self, iprot):
16723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16725 
      return
16726 
    iprot.readStructBegin()
16727 
    while True:
16728 
      (fname, ftype, fid) = iprot.readFieldBegin()
16729 
      if ftype == TType.STOP:
16730 
        break
16731 
      if fid == 0:
16732 
        if ftype == TType.STRING:
16733 
          self.success = iprot.readString();
16734 
        else:
16735 
          iprot.skip(ftype)
16736 
      else:
16737 
        iprot.skip(ftype)
16738 
      iprot.readFieldEnd()
16739 
    iprot.readStructEnd()
16740 
 
16741 
  def write(self, oprot):
16742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16744 
      return
16745 
    oprot.writeStructBegin('validateCartNew_result')
16746 
    if self.success is not None:
16747 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16748 
      oprot.writeString(self.success)
16749 
      oprot.writeFieldEnd()
16750 
    oprot.writeFieldStop()
16751 
    oprot.writeStructEnd()
16752 
 
16753 
  def validate(self):
16754 
    return
16755 
 
16756 
 
16757 
  def __repr__(self):
16758 
    L = ['%s=%r' % (key, value)
16759 
      for key, value in self.__dict__.iteritems()]
16760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16761 
 
16762 
  def __eq__(self, other):
16763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16764 
 
16765 
  def __ne__(self, other):
16766 
    return not (self == other)
18530 manish.sha 16767 
 
18644 manish.sha 16768 
class isAddressEditableForCounter_args:
18530 manish.sha 16769 
  """
16770 
  Attributes:
16771 
   - userId
16772 
  """
16773 
 
16774 
  thrift_spec = (
16775 
    None, # 0
16776 
    (1, TType.I64, 'userId', None, None, ), # 1
16777 
  )
16778 
 
16779 
  def __init__(self, userId=None,):
16780 
    self.userId = userId
16781 
 
16782 
  def read(self, iprot):
16783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16785 
      return
16786 
    iprot.readStructBegin()
16787 
    while True:
16788 
      (fname, ftype, fid) = iprot.readFieldBegin()
16789 
      if ftype == TType.STOP:
16790 
        break
16791 
      if fid == 1:
16792 
        if ftype == TType.I64:
16793 
          self.userId = iprot.readI64();
16794 
        else:
16795 
          iprot.skip(ftype)
16796 
      else:
16797 
        iprot.skip(ftype)
16798 
      iprot.readFieldEnd()
16799 
    iprot.readStructEnd()
16800 
 
16801 
  def write(self, oprot):
16802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16804 
      return
18644 manish.sha 16805 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 16806 
    if self.userId is not None:
16807 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16808 
      oprot.writeI64(self.userId)
16809 
      oprot.writeFieldEnd()
16810 
    oprot.writeFieldStop()
16811 
    oprot.writeStructEnd()
16812 
 
16813 
  def validate(self):
16814 
    return
16815 
 
16816 
 
16817 
  def __repr__(self):
16818 
    L = ['%s=%r' % (key, value)
16819 
      for key, value in self.__dict__.iteritems()]
16820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16821 
 
16822 
  def __eq__(self, other):
16823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16824 
 
16825 
  def __ne__(self, other):
16826 
    return not (self == other)
16827 
 
18644 manish.sha 16828 
class isAddressEditableForCounter_result:
18530 manish.sha 16829 
  """
16830 
  Attributes:
16831 
   - success
16832 
  """
16833 
 
16834 
  thrift_spec = (
16835 
    (0, TType.BOOL, 'success', None, None, ), # 0
16836 
  )
16837 
 
16838 
  def __init__(self, success=None,):
16839 
    self.success = success
16840 
 
16841 
  def read(self, iprot):
16842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16844 
      return
16845 
    iprot.readStructBegin()
16846 
    while True:
16847 
      (fname, ftype, fid) = iprot.readFieldBegin()
16848 
      if ftype == TType.STOP:
16849 
        break
16850 
      if fid == 0:
16851 
        if ftype == TType.BOOL:
16852 
          self.success = iprot.readBool();
16853 
        else:
16854 
          iprot.skip(ftype)
16855 
      else:
16856 
        iprot.skip(ftype)
16857 
      iprot.readFieldEnd()
16858 
    iprot.readStructEnd()
16859 
 
16860 
  def write(self, oprot):
16861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16863 
      return
18644 manish.sha 16864 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 16865 
    if self.success is not None:
16866 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16867 
      oprot.writeBool(self.success)
16868 
      oprot.writeFieldEnd()
16869 
    oprot.writeFieldStop()
16870 
    oprot.writeStructEnd()
16871 
 
16872 
  def validate(self):
16873 
    return
16874 
 
16875 
 
16876 
  def __repr__(self):
16877 
    L = ['%s=%r' % (key, value)
16878 
      for key, value in self.__dict__.iteritems()]
16879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16880 
 
16881 
  def __eq__(self, other):
16882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16883 
 
16884 
  def __ne__(self, other):
16885 
    return not (self == other)
16886 
 
16887 
class getBillingAddressForUser_args:
16888 
  """
16889 
  Attributes:
16890 
   - userId
16891 
  """
16892 
 
16893 
  thrift_spec = (
16894 
    None, # 0
16895 
    (1, TType.I64, 'userId', None, None, ), # 1
16896 
  )
16897 
 
16898 
  def __init__(self, userId=None,):
16899 
    self.userId = userId
16900 
 
16901 
  def read(self, iprot):
16902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16904 
      return
16905 
    iprot.readStructBegin()
16906 
    while True:
16907 
      (fname, ftype, fid) = iprot.readFieldBegin()
16908 
      if ftype == TType.STOP:
16909 
        break
16910 
      if fid == 1:
16911 
        if ftype == TType.I64:
16912 
          self.userId = iprot.readI64();
16913 
        else:
16914 
          iprot.skip(ftype)
16915 
      else:
16916 
        iprot.skip(ftype)
16917 
      iprot.readFieldEnd()
16918 
    iprot.readStructEnd()
16919 
 
16920 
  def write(self, oprot):
16921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16923 
      return
16924 
    oprot.writeStructBegin('getBillingAddressForUser_args')
16925 
    if self.userId is not None:
16926 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16927 
      oprot.writeI64(self.userId)
16928 
      oprot.writeFieldEnd()
16929 
    oprot.writeFieldStop()
16930 
    oprot.writeStructEnd()
16931 
 
16932 
  def validate(self):
16933 
    return
16934 
 
16935 
 
16936 
  def __repr__(self):
16937 
    L = ['%s=%r' % (key, value)
16938 
      for key, value in self.__dict__.iteritems()]
16939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16940 
 
16941 
  def __eq__(self, other):
16942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16943 
 
16944 
  def __ne__(self, other):
16945 
    return not (self == other)
16946 
 
16947 
class getBillingAddressForUser_result:
16948 
  """
16949 
  Attributes:
16950 
   - success
16951 
  """
16952 
 
16953 
  thrift_spec = (
16954 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
16955 
  )
16956 
 
16957 
  def __init__(self, success=None,):
16958 
    self.success = success
16959 
 
16960 
  def read(self, iprot):
16961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16963 
      return
16964 
    iprot.readStructBegin()
16965 
    while True:
16966 
      (fname, ftype, fid) = iprot.readFieldBegin()
16967 
      if ftype == TType.STOP:
16968 
        break
16969 
      if fid == 0:
16970 
        if ftype == TType.STRUCT:
16971 
          self.success = Address()
16972 
          self.success.read(iprot)
16973 
        else:
16974 
          iprot.skip(ftype)
16975 
      else:
16976 
        iprot.skip(ftype)
16977 
      iprot.readFieldEnd()
16978 
    iprot.readStructEnd()
16979 
 
16980 
  def write(self, oprot):
16981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16983 
      return
16984 
    oprot.writeStructBegin('getBillingAddressForUser_result')
16985 
    if self.success is not None:
16986 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16987 
      self.success.write(oprot)
16988 
      oprot.writeFieldEnd()
16989 
    oprot.writeFieldStop()
16990 
    oprot.writeStructEnd()
16991 
 
16992 
  def validate(self):
16993 
    return
16994 
 
16995 
 
16996 
  def __repr__(self):
16997 
    L = ['%s=%r' % (key, value)
16998 
      for key, value in self.__dict__.iteritems()]
16999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17000 
 
17001 
  def __eq__(self, other):
17002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17003 
 
17004 
  def __ne__(self, other):
17005 
    return not (self == other)
18590 manish.sha 17006 
 
17007 
class isCreditorAssigned_args:
17008 
  """
17009 
  Attributes:
17010 
   - userId
17011 
  """
17012 
 
17013 
  thrift_spec = (
17014 
    None, # 0
17015 
    (1, TType.I64, 'userId', None, None, ), # 1
17016 
  )
17017 
 
17018 
  def __init__(self, userId=None,):
17019 
    self.userId = userId
17020 
 
17021 
  def read(self, iprot):
17022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17024 
      return
17025 
    iprot.readStructBegin()
17026 
    while True:
17027 
      (fname, ftype, fid) = iprot.readFieldBegin()
17028 
      if ftype == TType.STOP:
17029 
        break
17030 
      if fid == 1:
17031 
        if ftype == TType.I64:
17032 
          self.userId = iprot.readI64();
17033 
        else:
17034 
          iprot.skip(ftype)
17035 
      else:
17036 
        iprot.skip(ftype)
17037 
      iprot.readFieldEnd()
17038 
    iprot.readStructEnd()
17039 
 
17040 
  def write(self, oprot):
17041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17043 
      return
17044 
    oprot.writeStructBegin('isCreditorAssigned_args')
17045 
    if self.userId is not None:
17046 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17047 
      oprot.writeI64(self.userId)
17048 
      oprot.writeFieldEnd()
17049 
    oprot.writeFieldStop()
17050 
    oprot.writeStructEnd()
17051 
 
17052 
  def validate(self):
17053 
    return
17054 
 
17055 
 
17056 
  def __repr__(self):
17057 
    L = ['%s=%r' % (key, value)
17058 
      for key, value in self.__dict__.iteritems()]
17059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17060 
 
17061 
  def __eq__(self, other):
17062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17063 
 
17064 
  def __ne__(self, other):
17065 
    return not (self == other)
17066 
 
17067 
class isCreditorAssigned_result:
17068 
  """
17069 
  Attributes:
17070 
   - success
17071 
  """
17072 
 
17073 
  thrift_spec = (
17074 
    (0, TType.BOOL, 'success', None, None, ), # 0
17075 
  )
17076 
 
17077 
  def __init__(self, success=None,):
17078 
    self.success = success
17079 
 
17080 
  def read(self, iprot):
17081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17083 
      return
17084 
    iprot.readStructBegin()
17085 
    while True:
17086 
      (fname, ftype, fid) = iprot.readFieldBegin()
17087 
      if ftype == TType.STOP:
17088 
        break
17089 
      if fid == 0:
17090 
        if ftype == TType.BOOL:
17091 
          self.success = iprot.readBool();
17092 
        else:
17093 
          iprot.skip(ftype)
17094 
      else:
17095 
        iprot.skip(ftype)
17096 
      iprot.readFieldEnd()
17097 
    iprot.readStructEnd()
17098 
 
17099 
  def write(self, oprot):
17100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17102 
      return
17103 
    oprot.writeStructBegin('isCreditorAssigned_result')
17104 
    if self.success is not None:
17105 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17106 
      oprot.writeBool(self.success)
17107 
      oprot.writeFieldEnd()
17108 
    oprot.writeFieldStop()
17109 
    oprot.writeStructEnd()
17110 
 
17111 
  def validate(self):
17112 
    return
17113 
 
17114 
 
17115 
  def __repr__(self):
17116 
    L = ['%s=%r' % (key, value)
17117 
      for key, value in self.__dict__.iteritems()]
17118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17119 
 
17120 
  def __eq__(self, other):
17121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17122 
 
17123 
  def __ne__(self, other):
17124 
    return not (self == other)