Subversion Repositories SmartDukaan

Rev

Rev 17782 | Rev 18590 | 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 
 
18530 manish.sha 753 
  def isTaxInvoiceCounter(self, userId):
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 
 
767 
 
3376 rajveer 768 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 769 
  """
770 
  service
771 
  """
772 
  def __init__(self, iprot, oprot=None):
3376 rajveer 773 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 774 
 
559 chandransh 775 
  def createAnonymousUser(self, jsessionId):
94 ashish 776 
    """
777 
    Parameters:
559 chandransh 778 
     - jsessionId
94 ashish 779 
    """
559 chandransh 780 
    self.send_createAnonymousUser(jsessionId)
781 
    return self.recv_createAnonymousUser()
94 ashish 782 
 
559 chandransh 783 
  def send_createAnonymousUser(self, jsessionId):
784 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
785 
    args = createAnonymousUser_args()
786 
    args.jsessionId = jsessionId
94 ashish 787 
    args.write(self._oprot)
788 
    self._oprot.writeMessageEnd()
789 
    self._oprot.trans.flush()
790 
 
559 chandransh 791 
  def recv_createAnonymousUser(self, ):
94 ashish 792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
793 
    if mtype == TMessageType.EXCEPTION:
794 
      x = TApplicationException()
795 
      x.read(self._iprot)
796 
      self._iprot.readMessageEnd()
797 
      raise x
559 chandransh 798 
    result = createAnonymousUser_result()
94 ashish 799 
    result.read(self._iprot)
800 
    self._iprot.readMessageEnd()
3431 rajveer 801 
    if result.success is not None:
94 ashish 802 
      return result.success
3431 rajveer 803 
    if result.ucex is not None:
559 chandransh 804 
      raise result.ucex
805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 806 
 
559 chandransh 807 
  def getUserById(self, userId):
94 ashish 808 
    """
809 
    Parameters:
810 
     - userId
811 
    """
559 chandransh 812 
    self.send_getUserById(userId)
813 
    return self.recv_getUserById()
94 ashish 814 
 
559 chandransh 815 
  def send_getUserById(self, userId):
816 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
817 
    args = getUserById_args()
94 ashish 818 
    args.userId = userId
819 
    args.write(self._oprot)
820 
    self._oprot.writeMessageEnd()
821 
    self._oprot.trans.flush()
822 
 
559 chandransh 823 
  def recv_getUserById(self, ):
94 ashish 824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
825 
    if mtype == TMessageType.EXCEPTION:
826 
      x = TApplicationException()
827 
      x.read(self._iprot)
828 
      self._iprot.readMessageEnd()
829 
      raise x
559 chandransh 830 
    result = getUserById_result()
94 ashish 831 
    result.read(self._iprot)
832 
    self._iprot.readMessageEnd()
3431 rajveer 833 
    if result.success is not None:
94 ashish 834 
      return result.success
3431 rajveer 835 
    if result.ucex is not None:
559 chandransh 836 
      raise result.ucex
837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 838 
 
5326 rajveer 839 
  def getUserByCartId(self, cartId):
840 
    """
841 
    Parameters:
842 
     - cartId
843 
    """
844 
    self.send_getUserByCartId(cartId)
845 
    return self.recv_getUserByCartId()
846 
 
847 
  def send_getUserByCartId(self, cartId):
848 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
849 
    args = getUserByCartId_args()
850 
    args.cartId = cartId
851 
    args.write(self._oprot)
852 
    self._oprot.writeMessageEnd()
853 
    self._oprot.trans.flush()
854 
 
855 
  def recv_getUserByCartId(self, ):
856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
857 
    if mtype == TMessageType.EXCEPTION:
858 
      x = TApplicationException()
859 
      x.read(self._iprot)
860 
      self._iprot.readMessageEnd()
861 
      raise x
862 
    result = getUserByCartId_result()
863 
    result.read(self._iprot)
864 
    self._iprot.readMessageEnd()
865 
    if result.success is not None:
866 
      return result.success
867 
    if result.ucex is not None:
868 
      raise result.ucex
869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
870 
 
1491 vikas 871 
  def getUserByEmail(self, email):
872 
    """
873 
    Parameters:
874 
     - email
875 
    """
876 
    self.send_getUserByEmail(email)
877 
    return self.recv_getUserByEmail()
878 
 
879 
  def send_getUserByEmail(self, email):
880 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
881 
    args = getUserByEmail_args()
882 
    args.email = email
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_getUserByEmail(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = getUserByEmail_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
3431 rajveer 897 
    if result.success is not None:
1491 vikas 898 
      return result.success
3431 rajveer 899 
    if result.ucex is not None:
1491 vikas 900 
      raise result.ucex
901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
902 
 
3032 mandeep.dh 903 
  def getUserByMobileNumber(self, mobileNumber):
904 
    """
905 
    Parameters:
906 
     - mobileNumber
907 
    """
908 
    self.send_getUserByMobileNumber(mobileNumber)
909 
    return self.recv_getUserByMobileNumber()
910 
 
911 
  def send_getUserByMobileNumber(self, mobileNumber):
912 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
913 
    args = getUserByMobileNumber_args()
914 
    args.mobileNumber = mobileNumber
915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
919 
  def recv_getUserByMobileNumber(self, ):
920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
926 
    result = getUserByMobileNumber_result()
927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
3431 rajveer 929 
    if result.success is not None:
3032 mandeep.dh 930 
      return result.success
3431 rajveer 931 
    if result.ucex is not None:
3032 mandeep.dh 932 
      raise result.ucex
933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
934 
 
559 chandransh 935 
  def createUser(self, user):
94 ashish 936 
    """
937 
    Parameters:
559 chandransh 938 
     - user
94 ashish 939 
    """
559 chandransh 940 
    self.send_createUser(user)
941 
    return self.recv_createUser()
94 ashish 942 
 
559 chandransh 943 
  def send_createUser(self, user):
944 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
945 
    args = createUser_args()
946 
    args.user = user
94 ashish 947 
    args.write(self._oprot)
948 
    self._oprot.writeMessageEnd()
949 
    self._oprot.trans.flush()
950 
 
559 chandransh 951 
  def recv_createUser(self, ):
94 ashish 952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
953 
    if mtype == TMessageType.EXCEPTION:
954 
      x = TApplicationException()
955 
      x.read(self._iprot)
956 
      self._iprot.readMessageEnd()
957 
      raise x
559 chandransh 958 
    result = createUser_result()
94 ashish 959 
    result.read(self._iprot)
960 
    self._iprot.readMessageEnd()
3431 rajveer 961 
    if result.success is not None:
94 ashish 962 
      return result.success
3431 rajveer 963 
    if result.ucex is not None:
559 chandransh 964 
      raise result.ucex
965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 966 
 
559 chandransh 967 
  def updateUser(self, user):
94 ashish 968 
    """
969 
    Parameters:
559 chandransh 970 
     - user
94 ashish 971 
    """
559 chandransh 972 
    self.send_updateUser(user)
973 
    return self.recv_updateUser()
94 ashish 974 
 
559 chandransh 975 
  def send_updateUser(self, user):
976 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
977 
    args = updateUser_args()
978 
    args.user = user
94 ashish 979 
    args.write(self._oprot)
980 
    self._oprot.writeMessageEnd()
981 
    self._oprot.trans.flush()
982 
 
559 chandransh 983 
  def recv_updateUser(self, ):
94 ashish 984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
985 
    if mtype == TMessageType.EXCEPTION:
986 
      x = TApplicationException()
987 
      x.read(self._iprot)
988 
      self._iprot.readMessageEnd()
989 
      raise x
559 chandransh 990 
    result = updateUser_result()
94 ashish 991 
    result.read(self._iprot)
992 
    self._iprot.readMessageEnd()
3431 rajveer 993 
    if result.success is not None:
94 ashish 994 
      return result.success
3431 rajveer 995 
    if result.ucex is not None:
559 chandransh 996 
      raise result.ucex
997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 998 
 
559 chandransh 999 
  def authenticateUser(self, email, password):
94 ashish 1000 
    """
1001 
    Parameters:
1002 
     - email
1003 
     - password
1004 
    """
559 chandransh 1005 
    self.send_authenticateUser(email, password)
122 ashish 1006 
    return self.recv_authenticateUser()
1007 
 
559 chandransh 1008 
  def send_authenticateUser(self, email, password):
122 ashish 1009 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1010 
    args = authenticateUser_args()
559 chandransh 1011 
    args.email = email
122 ashish 1012 
    args.password = password
1013 
    args.write(self._oprot)
1014 
    self._oprot.writeMessageEnd()
1015 
    self._oprot.trans.flush()
1016 
 
1017 
  def recv_authenticateUser(self, ):
1018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1019 
    if mtype == TMessageType.EXCEPTION:
1020 
      x = TApplicationException()
1021 
      x.read(self._iprot)
1022 
      self._iprot.readMessageEnd()
1023 
      raise x
1024 
    result = authenticateUser_result()
1025 
    result.read(self._iprot)
1026 
    self._iprot.readMessageEnd()
3431 rajveer 1027 
    if result.success is not None:
122 ashish 1028 
      return result.success
3431 rajveer 1029 
    if result.auex is not None:
559 chandransh 1030 
      raise result.auex
122 ashish 1031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1032 
 
94 ashish 1033 
  def userExists(self, email):
1034 
    """
1035 
    Parameters:
1036 
     - email
1037 
    """
1038 
    self.send_userExists(email)
1039 
    return self.recv_userExists()
1040 
 
1041 
  def send_userExists(self, email):
1042 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1043 
    args = userExists_args()
1044 
    args.email = email
1045 
    args.write(self._oprot)
1046 
    self._oprot.writeMessageEnd()
1047 
    self._oprot.trans.flush()
1048 
 
1049 
  def recv_userExists(self, ):
1050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1051 
    if mtype == TMessageType.EXCEPTION:
1052 
      x = TApplicationException()
1053 
      x.read(self._iprot)
1054 
      self._iprot.readMessageEnd()
1055 
      raise x
1056 
    result = userExists_result()
1057 
    result.read(self._iprot)
1058 
    self._iprot.readMessageEnd()
3431 rajveer 1059 
    if result.success is not None:
94 ashish 1060 
      return result.success
3431 rajveer 1061 
    if result.ucx is not None:
94 ashish 1062 
      raise result.ucx
1063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1064 
 
567 rajveer 1065 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1066 
    """
1067 
    Parameters:
1068 
     - userId
1069 
     - address
513 rajveer 1070 
     - setDefault
94 ashish 1071 
    """
567 rajveer 1072 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1073 
    return self.recv_addAddressForUser()
1074 
 
567 rajveer 1075 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1076 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1077 
    args = addAddressForUser_args()
559 chandransh 1078 
    args.userId = userId
94 ashish 1079 
    args.address = address
513 rajveer 1080 
    args.setDefault = setDefault
94 ashish 1081 
    args.write(self._oprot)
1082 
    self._oprot.writeMessageEnd()
1083 
    self._oprot.trans.flush()
1084 
 
1085 
  def recv_addAddressForUser(self, ):
1086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1087 
    if mtype == TMessageType.EXCEPTION:
1088 
      x = TApplicationException()
1089 
      x.read(self._iprot)
1090 
      self._iprot.readMessageEnd()
1091 
      raise x
1092 
    result = addAddressForUser_result()
1093 
    result.read(self._iprot)
1094 
    self._iprot.readMessageEnd()
3431 rajveer 1095 
    if result.success is not None:
94 ashish 1096 
      return result.success
3431 rajveer 1097 
    if result.ucx is not None:
94 ashish 1098 
      raise result.ucx
1099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1100 
 
1101 
  def removeAddressForUser(self, userid, addressId):
1102 
    """
1103 
    Parameters:
1104 
     - userid
1105 
     - addressId
1106 
    """
1107 
    self.send_removeAddressForUser(userid, addressId)
1108 
    return self.recv_removeAddressForUser()
1109 
 
1110 
  def send_removeAddressForUser(self, userid, addressId):
1111 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1112 
    args = removeAddressForUser_args()
1113 
    args.userid = userid
1114 
    args.addressId = addressId
1115 
    args.write(self._oprot)
1116 
    self._oprot.writeMessageEnd()
1117 
    self._oprot.trans.flush()
1118 
 
1119 
  def recv_removeAddressForUser(self, ):
1120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1121 
    if mtype == TMessageType.EXCEPTION:
1122 
      x = TApplicationException()
1123 
      x.read(self._iprot)
1124 
      self._iprot.readMessageEnd()
1125 
      raise x
1126 
    result = removeAddressForUser_result()
1127 
    result.read(self._iprot)
1128 
    self._iprot.readMessageEnd()
3431 rajveer 1129 
    if result.success is not None:
94 ashish 1130 
      return result.success
3431 rajveer 1131 
    if result.ucx is not None:
94 ashish 1132 
      raise result.ucx
1133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1134 
 
1135 
  def setUserAsLoggedIn(self, userId, timestamp):
1136 
    """
1137 
    Parameters:
1138 
     - userId
1139 
     - timestamp
1140 
    """
1141 
    self.send_setUserAsLoggedIn(userId, timestamp)
1142 
    return self.recv_setUserAsLoggedIn()
1143 
 
1144 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1145 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1146 
    args = setUserAsLoggedIn_args()
1147 
    args.userId = userId
1148 
    args.timestamp = timestamp
1149 
    args.write(self._oprot)
1150 
    self._oprot.writeMessageEnd()
1151 
    self._oprot.trans.flush()
1152 
 
1153 
  def recv_setUserAsLoggedIn(self, ):
1154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1155 
    if mtype == TMessageType.EXCEPTION:
1156 
      x = TApplicationException()
1157 
      x.read(self._iprot)
1158 
      self._iprot.readMessageEnd()
1159 
      raise x
1160 
    result = setUserAsLoggedIn_result()
1161 
    result.read(self._iprot)
1162 
    self._iprot.readMessageEnd()
3431 rajveer 1163 
    if result.success is not None:
94 ashish 1164 
      return result.success
3431 rajveer 1165 
    if result.ucx is not None:
94 ashish 1166 
      raise result.ucx
1167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1168 
 
1169 
  def setUserAsLoggedOut(self, userid, timestamp):
1170 
    """
1171 
    Parameters:
1172 
     - userid
1173 
     - timestamp
1174 
    """
1175 
    self.send_setUserAsLoggedOut(userid, timestamp)
1176 
    return self.recv_setUserAsLoggedOut()
1177 
 
1178 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1179 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1180 
    args = setUserAsLoggedOut_args()
1181 
    args.userid = userid
1182 
    args.timestamp = timestamp
1183 
    args.write(self._oprot)
1184 
    self._oprot.writeMessageEnd()
1185 
    self._oprot.trans.flush()
1186 
 
1187 
  def recv_setUserAsLoggedOut(self, ):
1188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1189 
    if mtype == TMessageType.EXCEPTION:
1190 
      x = TApplicationException()
1191 
      x.read(self._iprot)
1192 
      self._iprot.readMessageEnd()
1193 
      raise x
1194 
    result = setUserAsLoggedOut_result()
1195 
    result.read(self._iprot)
1196 
    self._iprot.readMessageEnd()
3431 rajveer 1197 
    if result.success is not None:
94 ashish 1198 
      return result.success
3431 rajveer 1199 
    if result.ucx is not None:
94 ashish 1200 
      raise result.ucx
1201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1202 
 
504 rajveer 1203 
  def setDefaultAddress(self, userid, addressId):
1204 
    """
1205 
    Parameters:
1206 
     - userid
1207 
     - addressId
1208 
    """
1209 
    self.send_setDefaultAddress(userid, addressId)
1210 
    return self.recv_setDefaultAddress()
1211 
 
1212 
  def send_setDefaultAddress(self, userid, addressId):
1213 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1214 
    args = setDefaultAddress_args()
1215 
    args.userid = userid
1216 
    args.addressId = addressId
1217 
    args.write(self._oprot)
1218 
    self._oprot.writeMessageEnd()
1219 
    self._oprot.trans.flush()
1220 
 
1221 
  def recv_setDefaultAddress(self, ):
1222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1223 
    if mtype == TMessageType.EXCEPTION:
1224 
      x = TApplicationException()
1225 
      x.read(self._iprot)
1226 
      self._iprot.readMessageEnd()
1227 
      raise x
1228 
    result = setDefaultAddress_result()
1229 
    result.read(self._iprot)
1230 
    self._iprot.readMessageEnd()
3431 rajveer 1231 
    if result.success is not None:
504 rajveer 1232 
      return result.success
3431 rajveer 1233 
    if result.ucx is not None:
504 rajveer 1234 
      raise result.ucx
1235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1236 
 
594 rajveer 1237 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1238 
    """
1239 
    Parameters:
1240 
     - userid
594 rajveer 1241 
     - oldPassword
1242 
     - newPassword
94 ashish 1243 
    """
594 rajveer 1244 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1245 
    return self.recv_updatePassword()
1246 
 
594 rajveer 1247 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1248 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1249 
    args = updatePassword_args()
1250 
    args.userid = userid
594 rajveer 1251 
    args.oldPassword = oldPassword
1252 
    args.newPassword = newPassword
94 ashish 1253 
    args.write(self._oprot)
1254 
    self._oprot.writeMessageEnd()
1255 
    self._oprot.trans.flush()
1256 
 
1257 
  def recv_updatePassword(self, ):
1258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1259 
    if mtype == TMessageType.EXCEPTION:
1260 
      x = TApplicationException()
1261 
      x.read(self._iprot)
1262 
      self._iprot.readMessageEnd()
1263 
      raise x
1264 
    result = updatePassword_result()
1265 
    result.read(self._iprot)
1266 
    self._iprot.readMessageEnd()
3431 rajveer 1267 
    if result.success is not None:
94 ashish 1268 
      return result.success
3431 rajveer 1269 
    if result.ucx is not None:
94 ashish 1270 
      raise result.ucx
1271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1272 
 
884 rajveer 1273 
  def forgotPassword(self, email, newPassword):
581 rajveer 1274 
    """
1275 
    Parameters:
1276 
     - email
884 rajveer 1277 
     - newPassword
581 rajveer 1278 
    """
884 rajveer 1279 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1280 
    return self.recv_forgotPassword()
1281 
 
884 rajveer 1282 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1283 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1284 
    args = forgotPassword_args()
1285 
    args.email = email
884 rajveer 1286 
    args.newPassword = newPassword
581 rajveer 1287 
    args.write(self._oprot)
1288 
    self._oprot.writeMessageEnd()
1289 
    self._oprot.trans.flush()
1290 
 
1291 
  def recv_forgotPassword(self, ):
1292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1293 
    if mtype == TMessageType.EXCEPTION:
1294 
      x = TApplicationException()
1295 
      x.read(self._iprot)
1296 
      self._iprot.readMessageEnd()
1297 
      raise x
1298 
    result = forgotPassword_result()
1299 
    result.read(self._iprot)
1300 
    self._iprot.readMessageEnd()
3431 rajveer 1301 
    if result.success is not None:
581 rajveer 1302 
      return result.success
3431 rajveer 1303 
    if result.ucx is not None:
581 rajveer 1304 
      raise result.ucx
1305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1306 
 
594 rajveer 1307 
  def getAllAddressesForUser(self, userId):
1308 
    """
1309 
    Parameters:
1310 
     - userId
1311 
    """
1312 
    self.send_getAllAddressesForUser(userId)
1313 
    return self.recv_getAllAddressesForUser()
1314 
 
1315 
  def send_getAllAddressesForUser(self, userId):
1316 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1317 
    args = getAllAddressesForUser_args()
1318 
    args.userId = userId
1319 
    args.write(self._oprot)
1320 
    self._oprot.writeMessageEnd()
1321 
    self._oprot.trans.flush()
1322 
 
1323 
  def recv_getAllAddressesForUser(self, ):
1324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1325 
    if mtype == TMessageType.EXCEPTION:
1326 
      x = TApplicationException()
1327 
      x.read(self._iprot)
1328 
      self._iprot.readMessageEnd()
1329 
      raise x
1330 
    result = getAllAddressesForUser_result()
1331 
    result.read(self._iprot)
1332 
    self._iprot.readMessageEnd()
3431 rajveer 1333 
    if result.success is not None:
594 rajveer 1334 
      return result.success
3431 rajveer 1335 
    if result.ucx is not None:
594 rajveer 1336 
      raise result.ucx
1337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1338 
 
1894 vikas 1339 
  def getAddressById(self, addressId):
1340 
    """
1341 
    Parameters:
1342 
     - addressId
1343 
    """
1344 
    self.send_getAddressById(addressId)
1345 
    return self.recv_getAddressById()
1346 
 
1347 
  def send_getAddressById(self, addressId):
1348 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1349 
    args = getAddressById_args()
1350 
    args.addressId = addressId
1351 
    args.write(self._oprot)
1352 
    self._oprot.writeMessageEnd()
1353 
    self._oprot.trans.flush()
1354 
 
1355 
  def recv_getAddressById(self, ):
1356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1357 
    if mtype == TMessageType.EXCEPTION:
1358 
      x = TApplicationException()
1359 
      x.read(self._iprot)
1360 
      self._iprot.readMessageEnd()
1361 
      raise x
1362 
    result = getAddressById_result()
1363 
    result.read(self._iprot)
1364 
    self._iprot.readMessageEnd()
3431 rajveer 1365 
    if result.success is not None:
1894 vikas 1366 
      return result.success
3431 rajveer 1367 
    if result.ucx is not None:
1894 vikas 1368 
      raise result.ucx
1369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1370 
 
594 rajveer 1371 
  def getDefaultAddressId(self, userId):
1372 
    """
1373 
    Parameters:
1374 
     - userId
1375 
    """
1376 
    self.send_getDefaultAddressId(userId)
1377 
    return self.recv_getDefaultAddressId()
1378 
 
1379 
  def send_getDefaultAddressId(self, userId):
1380 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1381 
    args = getDefaultAddressId_args()
1382 
    args.userId = userId
1383 
    args.write(self._oprot)
1384 
    self._oprot.writeMessageEnd()
1385 
    self._oprot.trans.flush()
1386 
 
1387 
  def recv_getDefaultAddressId(self, ):
1388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1389 
    if mtype == TMessageType.EXCEPTION:
1390 
      x = TApplicationException()
1391 
      x.read(self._iprot)
1392 
      self._iprot.readMessageEnd()
1393 
      raise x
1394 
    result = getDefaultAddressId_result()
1395 
    result.read(self._iprot)
1396 
    self._iprot.readMessageEnd()
3431 rajveer 1397 
    if result.success is not None:
594 rajveer 1398 
      return result.success
3431 rajveer 1399 
    if result.ucx is not None:
594 rajveer 1400 
      raise result.ucx
1401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1402 
 
785 rajveer 1403 
  def getDefaultPincode(self, userId):
1404 
    """
1405 
    Parameters:
1406 
     - userId
1407 
    """
1408 
    self.send_getDefaultPincode(userId)
1409 
    return self.recv_getDefaultPincode()
1410 
 
1411 
  def send_getDefaultPincode(self, userId):
1412 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1413 
    args = getDefaultPincode_args()
1414 
    args.userId = userId
1415 
    args.write(self._oprot)
1416 
    self._oprot.writeMessageEnd()
1417 
    self._oprot.trans.flush()
1418 
 
1419 
  def recv_getDefaultPincode(self, ):
1420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1421 
    if mtype == TMessageType.EXCEPTION:
1422 
      x = TApplicationException()
1423 
      x.read(self._iprot)
1424 
      self._iprot.readMessageEnd()
1425 
      raise x
1426 
    result = getDefaultPincode_result()
1427 
    result.read(self._iprot)
1428 
    self._iprot.readMessageEnd()
3431 rajveer 1429 
    if result.success is not None:
785 rajveer 1430 
      return result.success
3431 rajveer 1431 
    if result.ucx is not None:
785 rajveer 1432 
      raise result.ucx
1433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1434 
 
1274 varun.gupt 1435 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1436 
    """
1437 
    Parameters:
1438 
     - userId
1439 
     - replyTo
1440 
     - communicationType
1441 
     - orderId
1442 
     - airwaybillNo
1443 
     - productName
1444 
     - subject
1445 
     - message
1446 
    """
1447 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1448 
    return self.recv_saveUserCommunication()
1449 
 
1450 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1451 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1452 
    args = saveUserCommunication_args()
1453 
    args.userId = userId
1454 
    args.replyTo = replyTo
1455 
    args.communicationType = communicationType
1456 
    args.orderId = orderId
1457 
    args.airwaybillNo = airwaybillNo
1458 
    args.productName = productName
1459 
    args.subject = subject
1460 
    args.message = message
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_saveUserCommunication(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = saveUserCommunication_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
3431 rajveer 1475 
    if result.success is not None:
1274 varun.gupt 1476 
      return result.success
3431 rajveer 1477 
    if result.ucx is not None:
1274 varun.gupt 1478 
      raise result.ucx
1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1480 
 
1590 varun.gupt 1481 
  def getUserCommunicationById(self, id):
1482 
    """
1483 
    Parameters:
1484 
     - id
1485 
    """
1486 
    self.send_getUserCommunicationById(id)
1487 
    return self.recv_getUserCommunicationById()
1488 
 
1489 
  def send_getUserCommunicationById(self, id):
1490 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1491 
    args = getUserCommunicationById_args()
1492 
    args.id = id
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getUserCommunicationById(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getUserCommunicationById_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
3431 rajveer 1507 
    if result.success is not None:
1590 varun.gupt 1508 
      return result.success
3431 rajveer 1509 
    if result.ucx is not None:
1590 varun.gupt 1510 
      raise result.ucx
1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1512 
 
1513 
  def getUserCommunicationByUser(self, userId):
1514 
    """
1515 
    Parameters:
1516 
     - userId
1517 
    """
1518 
    self.send_getUserCommunicationByUser(userId)
1519 
    return self.recv_getUserCommunicationByUser()
1520 
 
1521 
  def send_getUserCommunicationByUser(self, userId):
1522 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1523 
    args = getUserCommunicationByUser_args()
1524 
    args.userId = userId
1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getUserCommunicationByUser(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getUserCommunicationByUser_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
3431 rajveer 1539 
    if result.success is not None:
1590 varun.gupt 1540 
      return result.success
3431 rajveer 1541 
    if result.ucx is not None:
1590 varun.gupt 1542 
      raise result.ucx
1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1544 
 
1545 
  def getAllUserCommunications(self, ):
1546 
    self.send_getAllUserCommunications()
1547 
    return self.recv_getAllUserCommunications()
1548 
 
1549 
  def send_getAllUserCommunications(self, ):
1550 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1551 
    args = getAllUserCommunications_args()
1552 
    args.write(self._oprot)
1553 
    self._oprot.writeMessageEnd()
1554 
    self._oprot.trans.flush()
1555 
 
1556 
  def recv_getAllUserCommunications(self, ):
1557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1558 
    if mtype == TMessageType.EXCEPTION:
1559 
      x = TApplicationException()
1560 
      x.read(self._iprot)
1561 
      self._iprot.readMessageEnd()
1562 
      raise x
1563 
    result = getAllUserCommunications_result()
1564 
    result.read(self._iprot)
1565 
    self._iprot.readMessageEnd()
3431 rajveer 1566 
    if result.success is not None:
1590 varun.gupt 1567 
      return result.success
3431 rajveer 1568 
    if result.ucx is not None:
1590 varun.gupt 1569 
      raise result.ucx
1570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1571 
 
5407 amar.kumar 1572 
  def removeUserCommunication(self, id):
1573 
    """
1574 
    Parameters:
1575 
     - id
1576 
    """
1577 
    self.send_removeUserCommunication(id)
1578 
    self.recv_removeUserCommunication()
1579 
 
1580 
  def send_removeUserCommunication(self, id):
1581 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1582 
    args = removeUserCommunication_args()
1583 
    args.id = id
1584 
    args.write(self._oprot)
1585 
    self._oprot.writeMessageEnd()
1586 
    self._oprot.trans.flush()
1587 
 
1588 
  def recv_removeUserCommunication(self, ):
1589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1590 
    if mtype == TMessageType.EXCEPTION:
1591 
      x = TApplicationException()
1592 
      x.read(self._iprot)
1593 
      self._iprot.readMessageEnd()
1594 
      raise x
1595 
    result = removeUserCommunication_result()
1596 
    result.read(self._iprot)
1597 
    self._iprot.readMessageEnd()
1598 
    if result.ucx is not None:
1599 
      raise result.ucx
1600 
    return
1601 
 
1859 vikas 1602 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1603 
    """
1604 
    Parameters:
1605 
     - name
1859 vikas 1606 
     - addedOn
1845 vikas 1607 
    """
1859 vikas 1608 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1609 
    return self.recv_createMasterAffiliate()
1610 
 
1859 vikas 1611 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1612 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1613 
    args = createMasterAffiliate_args()
1614 
    args.name = name
1859 vikas 1615 
    args.addedOn = addedOn
1845 vikas 1616 
    args.write(self._oprot)
1617 
    self._oprot.writeMessageEnd()
1618 
    self._oprot.trans.flush()
1619 
 
1620 
  def recv_createMasterAffiliate(self, ):
1621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1622 
    if mtype == TMessageType.EXCEPTION:
1623 
      x = TApplicationException()
1624 
      x.read(self._iprot)
1625 
      self._iprot.readMessageEnd()
1626 
      raise x
1627 
    result = createMasterAffiliate_result()
1628 
    result.read(self._iprot)
1629 
    self._iprot.readMessageEnd()
3431 rajveer 1630 
    if result.success is not None:
1845 vikas 1631 
      return result.success
3431 rajveer 1632 
    if result.utx is not None:
1845 vikas 1633 
      raise result.utx
1634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1635 
 
1899 vikas 1636 
  def getAllMasterAffiliates(self, ):
1637 
    self.send_getAllMasterAffiliates()
1638 
    return self.recv_getAllMasterAffiliates()
1639 
 
1640 
  def send_getAllMasterAffiliates(self, ):
1641 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1642 
    args = getAllMasterAffiliates_args()
1643 
    args.write(self._oprot)
1644 
    self._oprot.writeMessageEnd()
1645 
    self._oprot.trans.flush()
1646 
 
1647 
  def recv_getAllMasterAffiliates(self, ):
1648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1649 
    if mtype == TMessageType.EXCEPTION:
1650 
      x = TApplicationException()
1651 
      x.read(self._iprot)
1652 
      self._iprot.readMessageEnd()
1653 
      raise x
1654 
    result = getAllMasterAffiliates_result()
1655 
    result.read(self._iprot)
1656 
    self._iprot.readMessageEnd()
3431 rajveer 1657 
    if result.success is not None:
1899 vikas 1658 
      return result.success
3431 rajveer 1659 
    if result.utx is not None:
1899 vikas 1660 
      raise result.utx
1661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1662 
 
1845 vikas 1663 
  def getMasterAffiliateById(self, id):
1664 
    """
1665 
    Parameters:
1666 
     - id
1667 
    """
1668 
    self.send_getMasterAffiliateById(id)
1669 
    return self.recv_getMasterAffiliateById()
1670 
 
1671 
  def send_getMasterAffiliateById(self, id):
1672 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1673 
    args = getMasterAffiliateById_args()
1674 
    args.id = id
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getMasterAffiliateById(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = getMasterAffiliateById_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
3431 rajveer 1689 
    if result.success is not None:
1845 vikas 1690 
      return result.success
3431 rajveer 1691 
    if result.utx is not None:
1845 vikas 1692 
      raise result.utx
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1694 
 
1695 
  def getMasterAffiliateByName(self, name):
1696 
    """
1697 
    Parameters:
1698 
     - name
1699 
    """
1700 
    self.send_getMasterAffiliateByName(name)
1701 
    return self.recv_getMasterAffiliateByName()
1702 
 
1703 
  def send_getMasterAffiliateByName(self, name):
1704 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1705 
    args = getMasterAffiliateByName_args()
1706 
    args.name = name
1707 
    args.write(self._oprot)
1708 
    self._oprot.writeMessageEnd()
1709 
    self._oprot.trans.flush()
1710 
 
1711 
  def recv_getMasterAffiliateByName(self, ):
1712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1713 
    if mtype == TMessageType.EXCEPTION:
1714 
      x = TApplicationException()
1715 
      x.read(self._iprot)
1716 
      self._iprot.readMessageEnd()
1717 
      raise x
1718 
    result = getMasterAffiliateByName_result()
1719 
    result.read(self._iprot)
1720 
    self._iprot.readMessageEnd()
3431 rajveer 1721 
    if result.success is not None:
1845 vikas 1722 
      return result.success
3431 rajveer 1723 
    if result.utx is not None:
1845 vikas 1724 
      raise result.utx
1725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1726 
 
1859 vikas 1727 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1728 
    """
1729 
    Parameters:
1730 
     - name
1731 
     - url
1732 
     - masterAffiliateId
1859 vikas 1733 
     - addedOn
1845 vikas 1734 
    """
1859 vikas 1735 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1736 
    return self.recv_createAffiliate()
1737 
 
1859 vikas 1738 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1739 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1740 
    args = createAffiliate_args()
1741 
    args.name = name
1742 
    args.url = url
1743 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1744 
    args.addedOn = addedOn
1845 vikas 1745 
    args.write(self._oprot)
1746 
    self._oprot.writeMessageEnd()
1747 
    self._oprot.trans.flush()
1748 
 
1749 
  def recv_createAffiliate(self, ):
1750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1751 
    if mtype == TMessageType.EXCEPTION:
1752 
      x = TApplicationException()
1753 
      x.read(self._iprot)
1754 
      self._iprot.readMessageEnd()
1755 
      raise x
1756 
    result = createAffiliate_result()
1757 
    result.read(self._iprot)
1758 
    self._iprot.readMessageEnd()
3431 rajveer 1759 
    if result.success is not None:
1845 vikas 1760 
      return result.success
3431 rajveer 1761 
    if result.utx is not None:
1845 vikas 1762 
      raise result.utx
1763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1764 
 
1765 
  def getAffiliateById(self, id):
1766 
    """
1767 
    Parameters:
1768 
     - id
1769 
    """
1770 
    self.send_getAffiliateById(id)
1771 
    return self.recv_getAffiliateById()
1772 
 
1773 
  def send_getAffiliateById(self, id):
1774 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1775 
    args = getAffiliateById_args()
1776 
    args.id = id
1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getAffiliateById(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getAffiliateById_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
1845 vikas 1792 
      return result.success
3431 rajveer 1793 
    if result.utx is not None:
1845 vikas 1794 
      raise result.utx
1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1796 
 
1797 
  def getAffiliateByName(self, name):
1798 
    """
1799 
    Parameters:
1800 
     - name
1801 
    """
1802 
    self.send_getAffiliateByName(name)
1803 
    return self.recv_getAffiliateByName()
1804 
 
1805 
  def send_getAffiliateByName(self, name):
1806 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1807 
    args = getAffiliateByName_args()
1808 
    args.name = name
1809 
    args.write(self._oprot)
1810 
    self._oprot.writeMessageEnd()
1811 
    self._oprot.trans.flush()
1812 
 
1813 
  def recv_getAffiliateByName(self, ):
1814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1815 
    if mtype == TMessageType.EXCEPTION:
1816 
      x = TApplicationException()
1817 
      x.read(self._iprot)
1818 
      self._iprot.readMessageEnd()
1819 
      raise x
1820 
    result = getAffiliateByName_result()
1821 
    result.read(self._iprot)
1822 
    self._iprot.readMessageEnd()
3431 rajveer 1823 
    if result.success is not None:
1845 vikas 1824 
      return result.success
3431 rajveer 1825 
    if result.utx is not None:
1845 vikas 1826 
      raise result.utx
1827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1828 
 
1996 vikas 1829 
  def getTrackerById(self, id):
1845 vikas 1830 
    """
1831 
    Parameters:
1832 
     - id
1833 
    """
1996 vikas 1834 
    self.send_getTrackerById(id)
1845 vikas 1835 
    return self.recv_getTrackerById()
1836 
 
1996 vikas 1837 
  def send_getTrackerById(self, id):
1845 vikas 1838 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1839 
    args = getTrackerById_args()
1996 vikas 1840 
    args.id = id
1845 vikas 1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
1845 
  def recv_getTrackerById(self, ):
1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
1852 
    result = getTrackerById_result()
1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
1845 vikas 1856 
      return result.success
3431 rajveer 1857 
    if result.utx is not None:
1845 vikas 1858 
      raise result.utx
1859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1860 
 
1996 vikas 1861 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1862 
    """
1863 
    Parameters:
1996 vikas 1864 
     - id
1845 vikas 1865 
    """
1996 vikas 1866 
    self.send_getAffiliatesByMasterAffiliate(id)
1867 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1868 
 
1996 vikas 1869 
  def send_getAffiliatesByMasterAffiliate(self, id):
1870 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1871 
    args = getAffiliatesByMasterAffiliate_args()
1872 
    args.id = id
1845 vikas 1873 
    args.write(self._oprot)
1874 
    self._oprot.writeMessageEnd()
1875 
    self._oprot.trans.flush()
1876 
 
1996 vikas 1877 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1879 
    if mtype == TMessageType.EXCEPTION:
1880 
      x = TApplicationException()
1881 
      x.read(self._iprot)
1882 
      self._iprot.readMessageEnd()
1883 
      raise x
1996 vikas 1884 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1885 
    result.read(self._iprot)
1886 
    self._iprot.readMessageEnd()
3431 rajveer 1887 
    if result.success is not None:
1845 vikas 1888 
      return result.success
3431 rajveer 1889 
    if result.utx is not None:
1845 vikas 1890 
      raise result.utx
1996 vikas 1891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1892 
 
1996 vikas 1893 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1894 
    """
1895 
    Parameters:
1996 vikas 1896 
     - affiliateId
1845 vikas 1897 
     - userId
1898 
     - event
1899 
     - url
1900 
     - data
1859 vikas 1901 
     - addedOn
1845 vikas 1902 
    """
1996 vikas 1903 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1904 
    return self.recv_addTrackLog()
1905 
 
1996 vikas 1906 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1907 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1908 
    args = addTrackLog_args()
1996 vikas 1909 
    args.affiliateId = affiliateId
1845 vikas 1910 
    args.userId = userId
1911 
    args.event = event
1912 
    args.url = url
1913 
    args.data = data
1859 vikas 1914 
    args.addedOn = addedOn
1845 vikas 1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
1919 
  def recv_addTrackLog(self, ):
1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
1926 
    result = addTrackLog_result()
1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
3431 rajveer 1929 
    if result.success is not None:
1845 vikas 1930 
      return result.success
3431 rajveer 1931 
    if result.utx is not None:
1845 vikas 1932 
      raise result.utx
1933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1934 
 
1935 
  def getTrackLogById(self, id):
1936 
    """
1937 
    Parameters:
1938 
     - id
1939 
    """
1940 
    self.send_getTrackLogById(id)
1941 
    return self.recv_getTrackLogById()
1942 
 
1943 
  def send_getTrackLogById(self, id):
1944 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1945 
    args = getTrackLogById_args()
1946 
    args.id = id
1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
1951 
  def recv_getTrackLogById(self, ):
1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
1958 
    result = getTrackLogById_result()
1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
3431 rajveer 1961 
    if result.success is not None:
1845 vikas 1962 
      return result.success
3431 rajveer 1963 
    if result.utx is not None:
1845 vikas 1964 
      raise result.utx
1965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1966 
 
3293 vikas 1967 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1968 
    """
1969 
    Parameters:
1996 vikas 1970 
     - affiliateId
3293 vikas 1971 
     - startDate
1972 
     - endDate
1845 vikas 1973 
    """
3293 vikas 1974 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1975 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1976 
 
3293 vikas 1977 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1978 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1979 
    args = getTrackLogsByAffiliate_args()
1980 
    args.affiliateId = affiliateId
3293 vikas 1981 
    args.startDate = startDate
1982 
    args.endDate = endDate
1845 vikas 1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
1996 vikas 1987 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
1996 vikas 1994 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
3431 rajveer 1997 
    if result.success is not None:
1845 vikas 1998 
      return result.success
3431 rajveer 1999 
    if result.utx is not None:
1845 vikas 2000 
      raise result.utx
1996 vikas 2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2002 
 
2003 
  def getTrackLogsByUser(self, userId):
2004 
    """
2005 
    Parameters:
2006 
     - userId
2007 
    """
2008 
    self.send_getTrackLogsByUser(userId)
2009 
    return self.recv_getTrackLogsByUser()
2010 
 
2011 
  def send_getTrackLogsByUser(self, userId):
2012 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2013 
    args = getTrackLogsByUser_args()
2014 
    args.userId = userId
2015 
    args.write(self._oprot)
2016 
    self._oprot.writeMessageEnd()
2017 
    self._oprot.trans.flush()
2018 
 
2019 
  def recv_getTrackLogsByUser(self, ):
2020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2021 
    if mtype == TMessageType.EXCEPTION:
2022 
      x = TApplicationException()
2023 
      x.read(self._iprot)
2024 
      self._iprot.readMessageEnd()
2025 
      raise x
2026 
    result = getTrackLogsByUser_result()
2027 
    result.read(self._iprot)
2028 
    self._iprot.readMessageEnd()
3431 rajveer 2029 
    if result.success is not None:
1845 vikas 2030 
      return result.success
3431 rajveer 2031 
    if result.utx is not None:
1845 vikas 2032 
      raise result.utx
2033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2034 
 
1996 vikas 2035 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2036 
    """
2037 
    Parameters:
2038 
     - userId
2039 
     - event
2040 
     - url
2041 
    """
1996 vikas 2042 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2043 
    return self.recv_getTrackLogs()
2044 
 
1996 vikas 2045 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2046 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2047 
    args = getTrackLogs_args()
2048 
    args.userId = userId
2049 
    args.event = event
2050 
    args.url = url
2051 
    args.write(self._oprot)
2052 
    self._oprot.writeMessageEnd()
2053 
    self._oprot.trans.flush()
2054 
 
2055 
  def recv_getTrackLogs(self, ):
2056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2057 
    if mtype == TMessageType.EXCEPTION:
2058 
      x = TApplicationException()
2059 
      x.read(self._iprot)
2060 
      self._iprot.readMessageEnd()
2061 
      raise x
2062 
    result = getTrackLogs_result()
2063 
    result.read(self._iprot)
2064 
    self._iprot.readMessageEnd()
3431 rajveer 2065 
    if result.success is not None:
1845 vikas 2066 
      return result.success
3431 rajveer 2067 
    if result.utx is not None:
1845 vikas 2068 
      raise result.utx
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2070 
 
559 chandransh 2071 
  def getCurrentCart(self, userId):
94 ashish 2072 
    """
2073 
    Parameters:
559 chandransh 2074 
     - userId
94 ashish 2075 
    """
559 chandransh 2076 
    self.send_getCurrentCart(userId)
2077 
    return self.recv_getCurrentCart()
94 ashish 2078 
 
559 chandransh 2079 
  def send_getCurrentCart(self, userId):
2080 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2081 
    args = getCurrentCart_args()
2082 
    args.userId = userId
94 ashish 2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
559 chandransh 2087 
  def recv_getCurrentCart(self, ):
94 ashish 2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
559 chandransh 2094 
    result = getCurrentCart_result()
94 ashish 2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
3431 rajveer 2097 
    if result.success is not None:
94 ashish 2098 
      return result.success
3431 rajveer 2099 
    if result.scx is not None:
559 chandransh 2100 
      raise result.scx
2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2102 
 
559 chandransh 2103 
  def getCart(self, cartId):
94 ashish 2104 
    """
2105 
    Parameters:
559 chandransh 2106 
     - cartId
94 ashish 2107 
    """
559 chandransh 2108 
    self.send_getCart(cartId)
2109 
    return self.recv_getCart()
94 ashish 2110 
 
559 chandransh 2111 
  def send_getCart(self, cartId):
2112 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2113 
    args = getCart_args()
2114 
    args.cartId = cartId
94 ashish 2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
559 chandransh 2119 
  def recv_getCart(self, ):
94 ashish 2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
559 chandransh 2126 
    result = getCart_result()
94 ashish 2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
94 ashish 2130 
      return result.success
3431 rajveer 2131 
    if result.scx is not None:
559 chandransh 2132 
      raise result.scx
2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2134 
 
559 chandransh 2135 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2136 
    """
2137 
    Parameters:
559 chandransh 2138 
     - from_time
2139 
     - to_time
2140 
     - status
94 ashish 2141 
    """
559 chandransh 2142 
    self.send_getCartsByTime(from_time, to_time, status)
2143 
    return self.recv_getCartsByTime()
94 ashish 2144 
 
559 chandransh 2145 
  def send_getCartsByTime(self, from_time, to_time, status):
2146 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2147 
    args = getCartsByTime_args()
2148 
    args.from_time = from_time
2149 
    args.to_time = to_time
2150 
    args.status = status
94 ashish 2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
559 chandransh 2155 
  def recv_getCartsByTime(self, ):
94 ashish 2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
559 chandransh 2162 
    result = getCartsByTime_result()
94 ashish 2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
3431 rajveer 2165 
    if result.success is not None:
94 ashish 2166 
      return result.success
3431 rajveer 2167 
    if result.scx is not None:
559 chandransh 2168 
      raise result.scx
2169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2170 
 
3557 rajveer 2171 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2172 
    """
2173 
    Parameters:
2174 
     - cartId
2175 
     - itemId
2176 
     - quantity
3557 rajveer 2177 
     - sourceId
559 chandransh 2178 
    """
3557 rajveer 2179 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2180 
    return self.recv_addItemToCart()
559 chandransh 2181 
 
3557 rajveer 2182 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2183 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2184 
    args = addItemToCart_args()
2185 
    args.cartId = cartId
2186 
    args.itemId = itemId
2187 
    args.quantity = quantity
3557 rajveer 2188 
    args.sourceId = sourceId
559 chandransh 2189 
    args.write(self._oprot)
2190 
    self._oprot.writeMessageEnd()
2191 
    self._oprot.trans.flush()
2192 
 
2193 
  def recv_addItemToCart(self, ):
2194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2195 
    if mtype == TMessageType.EXCEPTION:
2196 
      x = TApplicationException()
2197 
      x.read(self._iprot)
2198 
      self._iprot.readMessageEnd()
2199 
      raise x
2200 
    result = addItemToCart_result()
2201 
    result.read(self._iprot)
2202 
    self._iprot.readMessageEnd()
3431 rajveer 2203 
    if result.success is not None:
2035 rajveer 2204 
      return result.success
3431 rajveer 2205 
    if result.scx is not None:
559 chandransh 2206 
      raise result.scx
2035 rajveer 2207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2208 
 
2209 
  def deleteItemFromCart(self, cartId, itemId):
2210 
    """
2211 
    Parameters:
2212 
     - cartId
2213 
     - itemId
2214 
    """
2215 
    self.send_deleteItemFromCart(cartId, itemId)
2216 
    self.recv_deleteItemFromCart()
2217 
 
2218 
  def send_deleteItemFromCart(self, cartId, itemId):
2219 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2220 
    args = deleteItemFromCart_args()
2221 
    args.cartId = cartId
2222 
    args.itemId = itemId
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_deleteItemFromCart(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = deleteItemFromCart_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.scx is not None:
559 chandransh 2238 
      raise result.scx
2239 
    return
2240 
 
2241 
  def addAddressToCart(self, cartId, addressId):
2242 
    """
2243 
    Parameters:
2244 
     - cartId
2245 
     - addressId
2246 
    """
2247 
    self.send_addAddressToCart(cartId, addressId)
2248 
    self.recv_addAddressToCart()
2249 
 
2250 
  def send_addAddressToCart(self, cartId, addressId):
2251 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2252 
    args = addAddressToCart_args()
2253 
    args.cartId = cartId
2254 
    args.addressId = addressId
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_addAddressToCart(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = addAddressToCart_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
3431 rajveer 2269 
    if result.scx is not None:
575 chandransh 2270 
      raise result.scx
559 chandransh 2271 
    return
2272 
 
5553 rajveer 2273 
  def addStoreToCart(self, cartId, storeId):
2274 
    """
2275 
    Parameters:
2276 
     - cartId
2277 
     - storeId
2278 
    """
2279 
    self.send_addStoreToCart(cartId, storeId)
2280 
    self.recv_addStoreToCart()
2281 
 
2282 
  def send_addStoreToCart(self, cartId, storeId):
2283 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2284 
    args = addStoreToCart_args()
2285 
    args.cartId = cartId
2286 
    args.storeId = storeId
2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_addStoreToCart(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = addStoreToCart_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
2301 
    if result.scx is not None:
2302 
      raise result.scx
2303 
    return
2304 
 
6922 anupam.sin 2305 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2306 
    """
2307 
    Parameters:
6922 anupam.sin 2308 
     - cart
1976 varun.gupt 2309 
     - couponCode
2310 
    """
6922 anupam.sin 2311 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2312 
    self.recv_applyCouponToCart()
2313 
 
6922 anupam.sin 2314 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2315 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2316 
    args = applyCouponToCart_args()
6922 anupam.sin 2317 
    args.cart = cart
1976 varun.gupt 2318 
    args.couponCode = couponCode
2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
2323 
  def recv_applyCouponToCart(self, ):
2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
2330 
    result = applyCouponToCart_result()
2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
3431 rajveer 2333 
    if result.scx is not None:
1976 varun.gupt 2334 
      raise result.scx
2335 
    return
2336 
 
2337 
  def removeCoupon(self, cartId):
2338 
    """
2339 
    Parameters:
2340 
     - cartId
2341 
    """
2342 
    self.send_removeCoupon(cartId)
2343 
    self.recv_removeCoupon()
2344 
 
2345 
  def send_removeCoupon(self, cartId):
2346 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2347 
    args = removeCoupon_args()
2348 
    args.cartId = cartId
2349 
    args.write(self._oprot)
2350 
    self._oprot.writeMessageEnd()
2351 
    self._oprot.trans.flush()
2352 
 
2353 
  def recv_removeCoupon(self, ):
2354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2355 
    if mtype == TMessageType.EXCEPTION:
2356 
      x = TApplicationException()
2357 
      x.read(self._iprot)
2358 
      self._iprot.readMessageEnd()
2359 
      raise x
2360 
    result = removeCoupon_result()
2361 
    result.read(self._iprot)
2362 
    self._iprot.readMessageEnd()
3431 rajveer 2363 
    if result.scx is not None:
1976 varun.gupt 2364 
      raise result.scx
2365 
    return
2366 
 
3554 varun.gupt 2367 
  def deleteDiscountsFromCart(self, cartId):
2368 
    """
2369 
    Deletes all the discounts associated with the cart
2370 
 
2371 
    Parameters:
2372 
     - cartId
2373 
    """
2374 
    self.send_deleteDiscountsFromCart(cartId)
2375 
    self.recv_deleteDiscountsFromCart()
2376 
 
2377 
  def send_deleteDiscountsFromCart(self, cartId):
2378 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2379 
    args = deleteDiscountsFromCart_args()
2380 
    args.cartId = cartId
2381 
    args.write(self._oprot)
2382 
    self._oprot.writeMessageEnd()
2383 
    self._oprot.trans.flush()
2384 
 
2385 
  def recv_deleteDiscountsFromCart(self, ):
2386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2387 
    if mtype == TMessageType.EXCEPTION:
2388 
      x = TApplicationException()
2389 
      x.read(self._iprot)
2390 
      self._iprot.readMessageEnd()
2391 
      raise x
2392 
    result = deleteDiscountsFromCart_result()
2393 
    result.read(self._iprot)
2394 
    self._iprot.readMessageEnd()
2395 
    if result.scx is not None:
2396 
      raise result.scx
2397 
    return
2398 
 
2399 
  def saveDiscounts(self, discounts):
2400 
    """
2401 
    Accepts a list of thrift objects of Discount type and saves them
2402 
 
2403 
    Parameters:
2404 
     - discounts
2405 
    """
2406 
    self.send_saveDiscounts(discounts)
2407 
    self.recv_saveDiscounts()
2408 
 
2409 
  def send_saveDiscounts(self, discounts):
2410 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2411 
    args = saveDiscounts_args()
2412 
    args.discounts = discounts
2413 
    args.write(self._oprot)
2414 
    self._oprot.writeMessageEnd()
2415 
    self._oprot.trans.flush()
2416 
 
2417 
  def recv_saveDiscounts(self, ):
2418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2419 
    if mtype == TMessageType.EXCEPTION:
2420 
      x = TApplicationException()
2421 
      x.read(self._iprot)
2422 
      self._iprot.readMessageEnd()
2423 
      raise x
2424 
    result = saveDiscounts_result()
2425 
    result.read(self._iprot)
2426 
    self._iprot.readMessageEnd()
2427 
    if result.scx is not None:
2428 
      raise result.scx
2429 
    return
2430 
 
11526 amit.gupta 2431 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2432 
    """
690 chandransh 2433 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2434 
 
559 chandransh 2435 
    Parameters:
2436 
     - cartId
2815 vikas 2437 
     - sessionSource
2438 
     - sessionStartTime
3858 vikas 2439 
     - firstSource
2440 
     - firstSourceTime
5326 rajveer 2441 
     - userId
6389 rajveer 2442 
     - schemeId
11526 amit.gupta 2443 
     - orderSource
559 chandransh 2444 
    """
11526 amit.gupta 2445 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2446 
    return self.recv_createOrders()
559 chandransh 2447 
 
11526 amit.gupta 2448 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2449 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2450 
    args = createOrders_args()
559 chandransh 2451 
    args.cartId = cartId
2815 vikas 2452 
    args.sessionSource = sessionSource
2453 
    args.sessionStartTime = sessionStartTime
3858 vikas 2454 
    args.firstSource = firstSource
2455 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2456 
    args.userId = userId
6389 rajveer 2457 
    args.schemeId = schemeId
11526 amit.gupta 2458 
    args.orderSource = orderSource
559 chandransh 2459 
    args.write(self._oprot)
2460 
    self._oprot.writeMessageEnd()
2461 
    self._oprot.trans.flush()
2462 
 
690 chandransh 2463 
  def recv_createOrders(self, ):
559 chandransh 2464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2465 
    if mtype == TMessageType.EXCEPTION:
2466 
      x = TApplicationException()
2467 
      x.read(self._iprot)
2468 
      self._iprot.readMessageEnd()
2469 
      raise x
690 chandransh 2470 
    result = createOrders_result()
559 chandransh 2471 
    result.read(self._iprot)
2472 
    self._iprot.readMessageEnd()
3431 rajveer 2473 
    if result.success is not None:
130 ashish 2474 
      return result.success
3431 rajveer 2475 
    if result.scx is not None:
559 chandransh 2476 
      raise result.scx
690 chandransh 2477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2478 
 
3557 rajveer 2479 
  def validateCart(self, cartId, sourceId):
130 ashish 2480 
    """
690 chandransh 2481 
    Validates that:
2482 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2483 
    2. All of the lines in the cart are active items.
690 chandransh 2484 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2485 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2486 
 
130 ashish 2487 
    Parameters:
559 chandransh 2488 
     - cartId
3557 rajveer 2489 
     - sourceId
130 ashish 2490 
    """
3557 rajveer 2491 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2492 
    return self.recv_validateCart()
130 ashish 2493 
 
3557 rajveer 2494 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2495 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2496 
    args = validateCart_args()
2497 
    args.cartId = cartId
3557 rajveer 2498 
    args.sourceId = sourceId
130 ashish 2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
559 chandransh 2503 
  def recv_validateCart(self, ):
130 ashish 2504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2505 
    if mtype == TMessageType.EXCEPTION:
2506 
      x = TApplicationException()
2507 
      x.read(self._iprot)
2508 
      self._iprot.readMessageEnd()
2509 
      raise x
559 chandransh 2510 
    result = validateCart_result()
130 ashish 2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
3431 rajveer 2513 
    if result.success is not None:
130 ashish 2514 
      return result.success
3431 rajveer 2515 
    if result.scex is not None:
575 chandransh 2516 
      raise result.scex
559 chandransh 2517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2518 
 
11980 amit.gupta 2519 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2520 
    """
2521 
    Validates that:
2522 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2523 
    2. All of the lines in the cart are active items.
2524 
    3. The estimate for any of the lines in cart doesn't change.
2525 
    If all three are true, returns empty string; else returns appropriate message.
2526 
 
2527 
    Parameters:
2528 
     - cartId
2529 
     - sourceId
2530 
     - dealCoupon
2531 
    """
2532 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2533 
    return self.recv_validateCartWithDealerCoupon()
2534 
 
2535 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2536 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2537 
    args = validateCartWithDealerCoupon_args()
2538 
    args.cartId = cartId
2539 
    args.sourceId = sourceId
2540 
    args.dealCoupon = dealCoupon
2541 
    args.write(self._oprot)
2542 
    self._oprot.writeMessageEnd()
2543 
    self._oprot.trans.flush()
2544 
 
2545 
  def recv_validateCartWithDealerCoupon(self, ):
2546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2547 
    if mtype == TMessageType.EXCEPTION:
2548 
      x = TApplicationException()
2549 
      x.read(self._iprot)
2550 
      self._iprot.readMessageEnd()
2551 
      raise x
2552 
    result = validateCartWithDealerCoupon_result()
2553 
    result.read(self._iprot)
2554 
    self._iprot.readMessageEnd()
2555 
    if result.success is not None:
2556 
      return result.success
2557 
    if result.scex is not None:
2558 
      raise result.scex
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2560 
 
690 chandransh 2561 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2562 
    """
690 chandransh 2563 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2564 
 
575 chandransh 2565 
    Parameters:
690 chandransh 2566 
     - fromCartId
2567 
     - toCartId
2568 
    """
2569 
    self.send_mergeCart(fromCartId, toCartId)
2570 
    self.recv_mergeCart()
2571 
 
2572 
  def send_mergeCart(self, fromCartId, toCartId):
2573 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2574 
    args = mergeCart_args()
2575 
    args.fromCartId = fromCartId
2576 
    args.toCartId = toCartId
2577 
    args.write(self._oprot)
2578 
    self._oprot.writeMessageEnd()
2579 
    self._oprot.trans.flush()
2580 
 
2581 
  def recv_mergeCart(self, ):
2582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2583 
    if mtype == TMessageType.EXCEPTION:
2584 
      x = TApplicationException()
2585 
      x.read(self._iprot)
2586 
      self._iprot.readMessageEnd()
2587 
      raise x
2588 
    result = mergeCart_result()
2589 
    result.read(self._iprot)
2590 
    self._iprot.readMessageEnd()
2591 
    return
2592 
 
2593 
  def checkOut(self, cartId):
2594 
    """
2595 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2596 
 
690 chandransh 2597 
    Parameters:
575 chandransh 2598 
     - cartId
2599 
    """
690 chandransh 2600 
    self.send_checkOut(cartId)
2601 
    return self.recv_checkOut()
575 chandransh 2602 
 
690 chandransh 2603 
  def send_checkOut(self, cartId):
2604 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2605 
    args = checkOut_args()
575 chandransh 2606 
    args.cartId = cartId
2607 
    args.write(self._oprot)
2608 
    self._oprot.writeMessageEnd()
2609 
    self._oprot.trans.flush()
2610 
 
690 chandransh 2611 
  def recv_checkOut(self, ):
575 chandransh 2612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2613 
    if mtype == TMessageType.EXCEPTION:
2614 
      x = TApplicationException()
2615 
      x.read(self._iprot)
2616 
      self._iprot.readMessageEnd()
2617 
      raise x
690 chandransh 2618 
    result = checkOut_result()
575 chandransh 2619 
    result.read(self._iprot)
2620 
    self._iprot.readMessageEnd()
3431 rajveer 2621 
    if result.success is not None:
575 chandransh 2622 
      return result.success
3431 rajveer 2623 
    if result.scex is not None:
575 chandransh 2624 
      raise result.scex
690 chandransh 2625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2626 
 
690 chandransh 2627 
  def resetCart(self, cartId, items):
559 chandransh 2628 
    """
690 chandransh 2629 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2630 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2631 
 
559 chandransh 2632 
    Parameters:
690 chandransh 2633 
     - cartId
2634 
     - items
559 chandransh 2635 
    """
690 chandransh 2636 
    self.send_resetCart(cartId, items)
2637 
    return self.recv_resetCart()
130 ashish 2638 
 
690 chandransh 2639 
  def send_resetCart(self, cartId, items):
2640 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2641 
    args = resetCart_args()
2642 
    args.cartId = cartId
2643 
    args.items = items
559 chandransh 2644 
    args.write(self._oprot)
2645 
    self._oprot.writeMessageEnd()
2646 
    self._oprot.trans.flush()
2647 
 
690 chandransh 2648 
  def recv_resetCart(self, ):
559 chandransh 2649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2650 
    if mtype == TMessageType.EXCEPTION:
2651 
      x = TApplicationException()
2652 
      x.read(self._iprot)
2653 
      self._iprot.readMessageEnd()
2654 
      raise x
690 chandransh 2655 
    result = resetCart_result()
559 chandransh 2656 
    result.read(self._iprot)
2657 
    self._iprot.readMessageEnd()
3431 rajveer 2658 
    if result.success is not None:
690 chandransh 2659 
      return result.success
3431 rajveer 2660 
    if result.scex is not None:
690 chandransh 2661 
      raise result.scex
2662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2663 
 
2981 rajveer 2664 
  def getUserCount(self, userType):
559 chandransh 2665 
    """
2981 rajveer 2666 
    Returns number of registered users.
2667 
    If userType = null, then it returns count of all users, including anonymous
2668 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2669 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2670 
 
559 chandransh 2671 
    Parameters:
2981 rajveer 2672 
     - userType
559 chandransh 2673 
    """
2981 rajveer 2674 
    self.send_getUserCount(userType)
2675 
    return self.recv_getUserCount()
559 chandransh 2676 
 
2981 rajveer 2677 
  def send_getUserCount(self, userType):
2678 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2679 
    args = getUserCount_args()
2680 
    args.userType = userType
559 chandransh 2681 
    args.write(self._oprot)
2682 
    self._oprot.writeMessageEnd()
2683 
    self._oprot.trans.flush()
2684 
 
2981 rajveer 2685 
  def recv_getUserCount(self, ):
559 chandransh 2686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2687 
    if mtype == TMessageType.EXCEPTION:
2688 
      x = TApplicationException()
2689 
      x.read(self._iprot)
2690 
      self._iprot.readMessageEnd()
2691 
      raise x
2981 rajveer 2692 
    result = getUserCount_result()
559 chandransh 2693 
    result.read(self._iprot)
2694 
    self._iprot.readMessageEnd()
3431 rajveer 2695 
    if result.success is not None:
559 chandransh 2696 
      return result.success
2981 rajveer 2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2698 
 
2981 rajveer 2699 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2700 
    """
2981 rajveer 2701 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2702 
    If any of startDate or endDate is -1, then that filter is ignored.
2703 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2704 
 
2705 
 
559 chandransh 2706 
    Parameters:
2981 rajveer 2707 
     - userType
2708 
     - startDate
2709 
     - endDate
559 chandransh 2710 
    """
2981 rajveer 2711 
    self.send_getAllUsers(userType, startDate, endDate)
2712 
    return self.recv_getAllUsers()
559 chandransh 2713 
 
2981 rajveer 2714 
  def send_getAllUsers(self, userType, startDate, endDate):
2715 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2716 
    args = getAllUsers_args()
2717 
    args.userType = userType
2718 
    args.startDate = startDate
2719 
    args.endDate = endDate
559 chandransh 2720 
    args.write(self._oprot)
2721 
    self._oprot.writeMessageEnd()
2722 
    self._oprot.trans.flush()
2723 
 
2981 rajveer 2724 
  def recv_getAllUsers(self, ):
559 chandransh 2725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2726 
    if mtype == TMessageType.EXCEPTION:
2727 
      x = TApplicationException()
2728 
      x.read(self._iprot)
2729 
      self._iprot.readMessageEnd()
2730 
      raise x
2981 rajveer 2731 
    result = getAllUsers_result()
559 chandransh 2732 
    result.read(self._iprot)
2733 
    self._iprot.readMessageEnd()
3431 rajveer 2734 
    if result.success is not None:
559 chandransh 2735 
      return result.success
2981 rajveer 2736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2737 
 
2981 rajveer 2738 
  def getMyResearchItems(self, userId):
559 chandransh 2739 
    """
2981 rajveer 2740 
    Returns list of item ids in myresearch for the user
3431 rajveer 2741 
 
559 chandransh 2742 
    Parameters:
772 rajveer 2743 
     - userId
559 chandransh 2744 
    """
2981 rajveer 2745 
    self.send_getMyResearchItems(userId)
2746 
    return self.recv_getMyResearchItems()
559 chandransh 2747 
 
2981 rajveer 2748 
  def send_getMyResearchItems(self, userId):
2749 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2750 
    args = getMyResearchItems_args()
772 rajveer 2751 
    args.userId = userId
559 chandransh 2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2981 rajveer 2756 
  def recv_getMyResearchItems(self, ):
559 chandransh 2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2981 rajveer 2763 
    result = getMyResearchItems_result()
559 chandransh 2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
3431 rajveer 2766 
    if result.success is not None:
559 chandransh 2767 
      return result.success
3431 rajveer 2768 
    if result.scx is not None:
559 chandransh 2769 
      raise result.scx
2981 rajveer 2770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2771 
 
2981 rajveer 2772 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2773 
    """
2981 rajveer 2774 
    add item to my research for a user
3431 rajveer 2775 
 
559 chandransh 2776 
    Parameters:
2981 rajveer 2777 
     - userId
2778 
     - itemId
559 chandransh 2779 
    """
2981 rajveer 2780 
    self.send_updateMyResearch(userId, itemId)
2781 
    return self.recv_updateMyResearch()
559 chandransh 2782 
 
2981 rajveer 2783 
  def send_updateMyResearch(self, userId, itemId):
2784 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2785 
    args = updateMyResearch_args()
2786 
    args.userId = userId
2787 
    args.itemId = itemId
559 chandransh 2788 
    args.write(self._oprot)
2789 
    self._oprot.writeMessageEnd()
2790 
    self._oprot.trans.flush()
2791 
 
2981 rajveer 2792 
  def recv_updateMyResearch(self, ):
559 chandransh 2793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2794 
    if mtype == TMessageType.EXCEPTION:
2795 
      x = TApplicationException()
2796 
      x.read(self._iprot)
2797 
      self._iprot.readMessageEnd()
2798 
      raise x
2981 rajveer 2799 
    result = updateMyResearch_result()
559 chandransh 2800 
    result.read(self._iprot)
2801 
    self._iprot.readMessageEnd()
3431 rajveer 2802 
    if result.success is not None:
2981 rajveer 2803 
      return result.success
3431 rajveer 2804 
    if result.scx is not None:
2981 rajveer 2805 
      raise result.scx
2806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2807 
 
2981 rajveer 2808 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2809 
    """
2981 rajveer 2810 
    delete item from my research for a user
3431 rajveer 2811 
 
1596 ankur.sing 2812 
    Parameters:
2981 rajveer 2813 
     - userId
2814 
     - itemId
1596 ankur.sing 2815 
    """
2981 rajveer 2816 
    self.send_deleteItemFromMyResearch(userId, itemId)
2817 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2818 
 
2981 rajveer 2819 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2820 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2821 
    args = deleteItemFromMyResearch_args()
2822 
    args.userId = userId
2823 
    args.itemId = itemId
1596 ankur.sing 2824 
    args.write(self._oprot)
2825 
    self._oprot.writeMessageEnd()
2826 
    self._oprot.trans.flush()
2827 
 
2981 rajveer 2828 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2830 
    if mtype == TMessageType.EXCEPTION:
2831 
      x = TApplicationException()
2832 
      x.read(self._iprot)
2833 
      self._iprot.readMessageEnd()
2834 
      raise x
2981 rajveer 2835 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2836 
    result.read(self._iprot)
2837 
    self._iprot.readMessageEnd()
3431 rajveer 2838 
    if result.scx is not None:
2981 rajveer 2839 
      raise result.scx
2840 
    return
1596 ankur.sing 2841 
 
2981 rajveer 2842 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2843 
    """
2981 rajveer 2844 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2845 
 
1673 ankur.sing 2846 
    Parameters:
2981 rajveer 2847 
     - userId
1673 ankur.sing 2848 
    """
2981 rajveer 2849 
    self.send_getBrowseHistoryItems(userId)
2850 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2851 
 
2981 rajveer 2852 
  def send_getBrowseHistoryItems(self, userId):
2853 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2854 
    args = getBrowseHistoryItems_args()
2855 
    args.userId = userId
1673 ankur.sing 2856 
    args.write(self._oprot)
2857 
    self._oprot.writeMessageEnd()
2858 
    self._oprot.trans.flush()
2859 
 
2981 rajveer 2860 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2862 
    if mtype == TMessageType.EXCEPTION:
2863 
      x = TApplicationException()
2864 
      x.read(self._iprot)
2865 
      self._iprot.readMessageEnd()
2866 
      raise x
2981 rajveer 2867 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2868 
    result.read(self._iprot)
2869 
    self._iprot.readMessageEnd()
3431 rajveer 2870 
    if result.success is not None:
1673 ankur.sing 2871 
      return result.success
3431 rajveer 2872 
    if result.scx is not None:
2981 rajveer 2873 
      raise result.scx
2874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2875 
 
2981 rajveer 2876 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2877 
    """
2981 rajveer 2878 
    add item to browse history for a user
3431 rajveer 2879 
 
2642 varun.gupt 2880 
    Parameters:
2981 rajveer 2881 
     - userId
2882 
     - itemId
2642 varun.gupt 2883 
    """
2981 rajveer 2884 
    self.send_updateBrowseHistory(userId, itemId)
2885 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2886 
 
2981 rajveer 2887 
  def send_updateBrowseHistory(self, userId, itemId):
2888 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2889 
    args = updateBrowseHistory_args()
2890 
    args.userId = userId
2891 
    args.itemId = itemId
2642 varun.gupt 2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
2981 rajveer 2896 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
2981 rajveer 2903 
    result = updateBrowseHistory_result()
2642 varun.gupt 2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
2906 
    return
2907 
 
3385 varun.gupt 2908 
  def getCartsWithCouponCount(self, couponCode):
2909 
    """
2910 
    Returns count of Carts with given coupon applied
3431 rajveer 2911 
 
3385 varun.gupt 2912 
    Parameters:
2913 
     - couponCode
2914 
    """
2915 
    self.send_getCartsWithCouponCount(couponCode)
2916 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2917 
 
3385 varun.gupt 2918 
  def send_getCartsWithCouponCount(self, couponCode):
2919 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2920 
    args = getCartsWithCouponCount_args()
2921 
    args.couponCode = couponCode
2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
2926 
  def recv_getCartsWithCouponCount(self, ):
2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
2933 
    result = getCartsWithCouponCount_result()
2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
3431 rajveer 2936 
    if result.success is not None:
3385 varun.gupt 2937 
      return result.success
2938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2939 
 
3499 mandeep.dh 2940 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2941 
    """
2942 
    Updates COD trust level of a user
3385 varun.gupt 2943 
 
3499 mandeep.dh 2944 
    Parameters:
2945 
     - userId
2946 
     - trustLevelDelta
2947 
    """
2948 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2949 
 
2950 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2951 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2952 
    args = increaseTrustLevel_args()
2953 
    args.userId = userId
2954 
    args.trustLevelDelta = trustLevelDelta
2955 
    args.write(self._oprot)
2956 
    self._oprot.writeMessageEnd()
2957 
    self._oprot.trans.flush()
5407 amar.kumar 2958 
  def getTrustLevel(self, userId):
2959 
    """
2960 
    Get trust level of a user
2961 
 
2962 
    Parameters:
2963 
     - userId
2964 
    """
2965 
    self.send_getTrustLevel(userId)
2966 
    return self.recv_getTrustLevel()
2967 
 
2968 
  def send_getTrustLevel(self, userId):
2969 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2970 
    args = getTrustLevel_args()
2971 
    args.userId = userId
2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
2976 
  def recv_getTrustLevel(self, ):
2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
2983 
    result = getTrustLevel_result()
2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
2986 
    if result.success is not None:
2987 
      return result.success
2988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2989 
 
4668 varun.gupt 2990 
  def showCODOption(self, cartId, sourceId, pincode):
2991 
    """
2992 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2993 
 
4668 varun.gupt 2994 
    Parameters:
2995 
     - cartId
2996 
     - sourceId
2997 
     - pincode
2998 
    """
2999 
    self.send_showCODOption(cartId, sourceId, pincode)
3000 
    return self.recv_showCODOption()
3001 
 
3002 
  def send_showCODOption(self, cartId, sourceId, pincode):
3003 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3004 
    args = showCODOption_args()
3005 
    args.cartId = cartId
3006 
    args.sourceId = sourceId
3007 
    args.pincode = pincode
3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
3011 
 
3012 
  def recv_showCODOption(self, ):
3013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3014 
    if mtype == TMessageType.EXCEPTION:
3015 
      x = TApplicationException()
3016 
      x.read(self._iprot)
3017 
      self._iprot.readMessageEnd()
3018 
      raise x
3019 
    result = showCODOption_result()
3020 
    result.read(self._iprot)
3021 
    self._iprot.readMessageEnd()
3022 
    if result.success is not None:
3023 
      return result.success
3024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3025 
 
5623 anupam.sin 3026 
  def getUserEmails(self, startDate, endDate):
3027 
    """
3028 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3029 
 
5623 anupam.sin 3030 
    Parameters:
3031 
     - startDate
3032 
     - endDate
3033 
    """
3034 
    self.send_getUserEmails(startDate, endDate)
3035 
    return self.recv_getUserEmails()
3036 
 
3037 
  def send_getUserEmails(self, startDate, endDate):
3038 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3039 
    args = getUserEmails_args()
3040 
    args.startDate = startDate
3041 
    args.endDate = endDate
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_getUserEmails(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = getUserEmails_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3056 
    if result.success is not None:
3057 
      return result.success
3058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3059 
 
9299 kshitij.so 3060 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3061 
    """
3062 
    Mark a cart lineitem as insured. Returns true/false.
3063 
 
3064 
    Parameters:
3065 
     - itemId
3066 
     - cartId
3067 
     - toInsure
9299 kshitij.so 3068 
     - insurerType
6903 anupam.sin 3069 
    """
9299 kshitij.so 3070 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3071 
    return self.recv_insureItem()
3072 
 
9299 kshitij.so 3073 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3074 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3075 
    args = insureItem_args()
3076 
    args.itemId = itemId
3077 
    args.cartId = cartId
3078 
    args.toInsure = toInsure
9299 kshitij.so 3079 
    args.insurerType = insurerType
6903 anupam.sin 3080 
    args.write(self._oprot)
3081 
    self._oprot.writeMessageEnd()
3082 
    self._oprot.trans.flush()
3083 
 
3084 
  def recv_insureItem(self, ):
3085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3086 
    if mtype == TMessageType.EXCEPTION:
3087 
      x = TApplicationException()
3088 
      x.read(self._iprot)
3089 
      self._iprot.readMessageEnd()
3090 
      raise x
3091 
    result = insureItem_result()
3092 
    result.read(self._iprot)
3093 
    self._iprot.readMessageEnd()
3094 
    if result.success is not None:
3095 
      return result.success
3096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3097 
 
3098 
  def cancelInsurance(self, cartId):
3099 
    """
3100 
    Cancel insurance for all items in the cart
3101 
 
3102 
    Parameters:
3103 
     - cartId
3104 
    """
3105 
    self.send_cancelInsurance(cartId)
3106 
    return self.recv_cancelInsurance()
3107 
 
3108 
  def send_cancelInsurance(self, cartId):
3109 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3110 
    args = cancelInsurance_args()
3111 
    args.cartId = cartId
3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3116 
  def recv_cancelInsurance(self, ):
3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3123 
    result = cancelInsurance_result()
3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3126 
    if result.success is not None:
3127 
      return result.success
3128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3129 
 
3130 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3131 
    """
3132 
    Stores insurance specific details like date of birth and guardianName
3133 
 
3134 
    Parameters:
3135 
     - addressId
3136 
     - dob
3137 
     - guardianName
3138 
    """
3139 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3140 
    return self.recv_storeInsuranceSpecificDetails()
3141 
 
3142 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3143 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3144 
    args = storeInsuranceSpecificDetails_args()
3145 
    args.addressId = addressId
3146 
    args.dob = dob
3147 
    args.guardianName = guardianName
3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
3152 
  def recv_storeInsuranceSpecificDetails(self, ):
3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
3159 
    result = storeInsuranceSpecificDetails_result()
3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
3162 
    if result.success is not None:
3163 
      return result.success
3164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3165 
 
3166 
  def isInsuranceDetailPresent(self, addressId):
3167 
    """
3168 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3169 
 
3170 
    Parameters:
3171 
     - addressId
3172 
    """
3173 
    self.send_isInsuranceDetailPresent(addressId)
3174 
    return self.recv_isInsuranceDetailPresent()
3175 
 
3176 
  def send_isInsuranceDetailPresent(self, addressId):
3177 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3178 
    args = isInsuranceDetailPresent_args()
3179 
    args.addressId = addressId
3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_isInsuranceDetailPresent(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = isInsuranceDetailPresent_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    if result.success is not None:
3195 
      return result.success
3196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3197 
 
9791 rajveer 3198 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3199 
    """
9791 rajveer 3200 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3201 
 
6821 amar.kumar 3202 
    Parameters:
3203 
     - startDate
3204 
     - endDate
3205 
    """
9791 rajveer 3206 
    self.send_getProductsAddedToCart(startDate, endDate)
3207 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3208 
 
9791 rajveer 3209 
  def send_getProductsAddedToCart(self, startDate, endDate):
3210 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3211 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3212 
    args.startDate = startDate
3213 
    args.endDate = endDate
3214 
    args.write(self._oprot)
3215 
    self._oprot.writeMessageEnd()
3216 
    self._oprot.trans.flush()
3217 
 
9791 rajveer 3218 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3220 
    if mtype == TMessageType.EXCEPTION:
3221 
      x = TApplicationException()
3222 
      x.read(self._iprot)
3223 
      self._iprot.readMessageEnd()
3224 
      raise x
9791 rajveer 3225 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3226 
    result.read(self._iprot)
3227 
    self._iprot.readMessageEnd()
3228 
    if result.success is not None:
3229 
      return result.success
9791 rajveer 3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3231 
 
11980 amit.gupta 3232 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3233 
    """
3234 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3235 
 
11592 amit.gupta 3236 
    Parameters:
3237 
     - cartId
3238 
     - sourceId
11980 amit.gupta 3239 
     - dealerCoupon
11592 amit.gupta 3240 
    """
11980 amit.gupta 3241 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3242 
    return self.recv_validateCartPlus()
3243 
 
11980 amit.gupta 3244 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3245 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3246 
    args = validateCartPlus_args()
3247 
    args.cartId = cartId
3248 
    args.sourceId = sourceId
11980 amit.gupta 3249 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_validateCartPlus(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = validateCartPlus_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
3264 
    if result.success is not None:
3265 
      return result.success
3266 
    if result.scex is not None:
3267 
      raise result.scex
3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3269 
 
11679 vikram.rag 3270 
  def isPrivateDealUser(self, userId):
3271 
    """
3272 
    Parameters:
3273 
     - userId
3274 
    """
3275 
    self.send_isPrivateDealUser(userId)
3276 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3277 
 
11679 vikram.rag 3278 
  def send_isPrivateDealUser(self, userId):
3279 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3280 
    args = isPrivateDealUser_args()
3281 
    args.userId = userId
3282 
    args.write(self._oprot)
3283 
    self._oprot.writeMessageEnd()
3284 
    self._oprot.trans.flush()
3285 
 
3286 
  def recv_isPrivateDealUser(self, ):
3287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3288 
    if mtype == TMessageType.EXCEPTION:
3289 
      x = TApplicationException()
3290 
      x.read(self._iprot)
3291 
      self._iprot.readMessageEnd()
3292 
      raise x
3293 
    result = isPrivateDealUser_result()
3294 
    result.read(self._iprot)
3295 
    self._iprot.readMessageEnd()
3296 
    if result.success is not None:
3297 
      return result.success
3298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3299 
 
11890 kshitij.so 3300 
  def addPrivateDealUser(self, userId):
3301 
    """
3302 
    Parameters:
3303 
     - userId
3304 
    """
3305 
    self.send_addPrivateDealUser(userId)
3306 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3307 
 
11890 kshitij.so 3308 
  def send_addPrivateDealUser(self, userId):
3309 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3310 
    args = addPrivateDealUser_args()
3311 
    args.userId = userId
3312 
    args.write(self._oprot)
3313 
    self._oprot.writeMessageEnd()
3314 
    self._oprot.trans.flush()
3315 
 
3316 
  def recv_addPrivateDealUser(self, ):
3317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3318 
    if mtype == TMessageType.EXCEPTION:
3319 
      x = TApplicationException()
3320 
      x.read(self._iprot)
3321 
      self._iprot.readMessageEnd()
3322 
      raise x
3323 
    result = addPrivateDealUser_result()
3324 
    result.read(self._iprot)
3325 
    self._iprot.readMessageEnd()
3326 
    if result.success is not None:
3327 
      return result.success
3328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3329 
 
3330 
  def changePrivateDealUserStatus(self, userId, isActive):
3331 
    """
3332 
    Parameters:
3333 
     - userId
3334 
     - isActive
3335 
    """
3336 
    self.send_changePrivateDealUserStatus(userId, isActive)
3337 
    return self.recv_changePrivateDealUserStatus()
3338 
 
3339 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3340 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3341 
    args = changePrivateDealUserStatus_args()
3342 
    args.userId = userId
3343 
    args.isActive = isActive
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_changePrivateDealUserStatus(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = changePrivateDealUserStatus_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3361 
 
3362 
  def getPrivateDealUser(self, userId):
3363 
    """
3364 
    Parameters:
3365 
     - userId
3366 
    """
3367 
    self.send_getPrivateDealUser(userId)
3368 
    return self.recv_getPrivateDealUser()
3369 
 
3370 
  def send_getPrivateDealUser(self, userId):
3371 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3372 
    args = getPrivateDealUser_args()
3373 
    args.userId = userId
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_getPrivateDealUser(self, ):
3379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3380 
    if mtype == TMessageType.EXCEPTION:
3381 
      x = TApplicationException()
3382 
      x.read(self._iprot)
3383 
      self._iprot.readMessageEnd()
3384 
      raise x
3385 
    result = getPrivateDealUser_result()
3386 
    result.read(self._iprot)
3387 
    self._iprot.readMessageEnd()
3388 
    if result.success is not None:
3389 
      return result.success
3390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3391 
 
12696 amit.gupta 3392 
  def registerCounter(self, counter, userId):
3393 
    """
3394 
    Parameters:
3395 
     - counter
3396 
     - userId
3397 
    """
3398 
    self.send_registerCounter(counter, userId)
3399 
    return self.recv_registerCounter()
11890 kshitij.so 3400 
 
12696 amit.gupta 3401 
  def send_registerCounter(self, counter, userId):
3402 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3403 
    args = registerCounter_args()
3404 
    args.counter = counter
3405 
    args.userId = userId
3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_registerCounter(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = registerCounter_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
3420 
    if result.success is not None:
3421 
      return result.success
3422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3423 
 
12722 amit.gupta 3424 
  def searchCounter(self, type1, searchString):
3425 
    """
3426 
    Parameters:
3427 
     - type1
3428 
     - searchString
3429 
    """
3430 
    self.send_searchCounter(type1, searchString)
3431 
    return self.recv_searchCounter()
12696 amit.gupta 3432 
 
12722 amit.gupta 3433 
  def send_searchCounter(self, type1, searchString):
3434 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3435 
    args = searchCounter_args()
3436 
    args.type1 = type1
3437 
    args.searchString = searchString
3438 
    args.write(self._oprot)
3439 
    self._oprot.writeMessageEnd()
3440 
    self._oprot.trans.flush()
3441 
 
3442 
  def recv_searchCounter(self, ):
3443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3444 
    if mtype == TMessageType.EXCEPTION:
3445 
      x = TApplicationException()
3446 
      x.read(self._iprot)
3447 
      self._iprot.readMessageEnd()
3448 
      raise x
3449 
    result = searchCounter_result()
3450 
    result.read(self._iprot)
3451 
    self._iprot.readMessageEnd()
3452 
    if result.success is not None:
3453 
      return result.success
3454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3455 
 
3456 
  def getAllUsersByCounter(self, counterId):
3457 
    """
3458 
    Parameters:
3459 
     - counterId
3460 
    """
3461 
    self.send_getAllUsersByCounter(counterId)
3462 
    return self.recv_getAllUsersByCounter()
3463 
 
3464 
  def send_getAllUsersByCounter(self, counterId):
3465 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3466 
    args = getAllUsersByCounter_args()
3467 
    args.counterId = counterId
3468 
    args.write(self._oprot)
3469 
    self._oprot.writeMessageEnd()
3470 
    self._oprot.trans.flush()
3471 
 
3472 
  def recv_getAllUsersByCounter(self, ):
3473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3474 
    if mtype == TMessageType.EXCEPTION:
3475 
      x = TApplicationException()
3476 
      x.read(self._iprot)
3477 
      self._iprot.readMessageEnd()
3478 
      raise x
3479 
    result = getAllUsersByCounter_result()
3480 
    result.read(self._iprot)
3481 
    self._iprot.readMessageEnd()
3482 
    if result.success is not None:
3483 
      return result.success
3484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3485 
 
15251 manish.sha 3486 
  def getActiveAccessTokenForUser(self, userId, source):
3487 
    """
3488 
    Parameters:
3489 
     - userId
3490 
     - source
3491 
    """
3492 
    self.send_getActiveAccessTokenForUser(userId, source)
3493 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3494 
 
15251 manish.sha 3495 
  def send_getActiveAccessTokenForUser(self, userId, source):
3496 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3497 
    args = getActiveAccessTokenForUser_args()
3498 
    args.userId = userId
3499 
    args.source = source
3500 
    args.write(self._oprot)
3501 
    self._oprot.writeMessageEnd()
3502 
    self._oprot.trans.flush()
3503 
 
3504 
  def recv_getActiveAccessTokenForUser(self, ):
3505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3506 
    if mtype == TMessageType.EXCEPTION:
3507 
      x = TApplicationException()
3508 
      x.read(self._iprot)
3509 
      self._iprot.readMessageEnd()
3510 
      raise x
3511 
    result = getActiveAccessTokenForUser_result()
3512 
    result.read(self._iprot)
3513 
    self._iprot.readMessageEnd()
3514 
    if result.success is not None:
3515 
      return result.success
3516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3517 
 
3518 
  def validateAccessToken(self, accessToken):
3519 
    """
3520 
    Parameters:
3521 
     - accessToken
3522 
    """
3523 
    self.send_validateAccessToken(accessToken)
3524 
    return self.recv_validateAccessToken()
3525 
 
3526 
  def send_validateAccessToken(self, accessToken):
3527 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3528 
    args = validateAccessToken_args()
3529 
    args.accessToken = accessToken
3530 
    args.write(self._oprot)
3531 
    self._oprot.writeMessageEnd()
3532 
    self._oprot.trans.flush()
3533 
 
3534 
  def recv_validateAccessToken(self, ):
3535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3536 
    if mtype == TMessageType.EXCEPTION:
3537 
      x = TApplicationException()
3538 
      x.read(self._iprot)
3539 
      self._iprot.readMessageEnd()
3540 
      raise x
3541 
    result = validateAccessToken_result()
3542 
    result.read(self._iprot)
3543 
    self._iprot.readMessageEnd()
3544 
    if result.success is not None:
3545 
      return result.success
3546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3547 
 
17782 amit.gupta 3548 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3549 
    """
3550 
    Parameters:
3551 
     - cartId
3552 
     - itemQty
3553 
     - couponCode
3554 
    """
3555 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3556 
    return self.recv_addItemsToCart()
15251 manish.sha 3557 
 
17782 amit.gupta 3558 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3559 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3560 
    args = addItemsToCart_args()
3561 
    args.cartId = cartId
3562 
    args.itemQty = itemQty
3563 
    args.couponCode = couponCode
3564 
    args.write(self._oprot)
3565 
    self._oprot.writeMessageEnd()
3566 
    self._oprot.trans.flush()
3567 
 
3568 
  def recv_addItemsToCart(self, ):
3569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3570 
    if mtype == TMessageType.EXCEPTION:
3571 
      x = TApplicationException()
3572 
      x.read(self._iprot)
3573 
      self._iprot.readMessageEnd()
3574 
      raise x
3575 
    result = addItemsToCart_result()
3576 
    result.read(self._iprot)
3577 
    self._iprot.readMessageEnd()
3578 
    if result.success is not None:
3579 
      return result.success
3580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3581 
 
3582 
  def validateCartNew(self, cartId, pinCode, sourceId):
3583 
    """
3584 
    Parameters:
3585 
     - cartId
3586 
     - pinCode
3587 
     - sourceId
3588 
    """
3589 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3590 
    return self.recv_validateCartNew()
3591 
 
3592 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3593 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3594 
    args = validateCartNew_args()
3595 
    args.cartId = cartId
3596 
    args.pinCode = pinCode
3597 
    args.sourceId = sourceId
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_validateCartNew(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = validateCartNew_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3612 
    if result.success is not None:
3613 
      return result.success
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3615 
 
18530 manish.sha 3616 
  def isTaxInvoiceCounter(self, userId):
3617 
    """
3618 
    Parameters:
3619 
     - userId
3620 
    """
3621 
    self.send_isTaxInvoiceCounter(userId)
3622 
    return self.recv_isTaxInvoiceCounter()
17782 amit.gupta 3623 
 
18530 manish.sha 3624 
  def send_isTaxInvoiceCounter(self, userId):
3625 
    self._oprot.writeMessageBegin('isTaxInvoiceCounter', TMessageType.CALL, self._seqid)
3626 
    args = isTaxInvoiceCounter_args()
3627 
    args.userId = userId
3628 
    args.write(self._oprot)
3629 
    self._oprot.writeMessageEnd()
3630 
    self._oprot.trans.flush()
3631 
 
3632 
  def recv_isTaxInvoiceCounter(self, ):
3633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3634 
    if mtype == TMessageType.EXCEPTION:
3635 
      x = TApplicationException()
3636 
      x.read(self._iprot)
3637 
      self._iprot.readMessageEnd()
3638 
      raise x
3639 
    result = isTaxInvoiceCounter_result()
3640 
    result.read(self._iprot)
3641 
    self._iprot.readMessageEnd()
3642 
    if result.success is not None:
3643 
      return result.success
3644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceCounter failed: unknown result");
3645 
 
3646 
  def getBillingAddressForUser(self, userId):
3647 
    """
3648 
    Parameters:
3649 
     - userId
3650 
    """
3651 
    self.send_getBillingAddressForUser(userId)
3652 
    return self.recv_getBillingAddressForUser()
3653 
 
3654 
  def send_getBillingAddressForUser(self, userId):
3655 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3656 
    args = getBillingAddressForUser_args()
3657 
    args.userId = userId
3658 
    args.write(self._oprot)
3659 
    self._oprot.writeMessageEnd()
3660 
    self._oprot.trans.flush()
3661 
 
3662 
  def recv_getBillingAddressForUser(self, ):
3663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3664 
    if mtype == TMessageType.EXCEPTION:
3665 
      x = TApplicationException()
3666 
      x.read(self._iprot)
3667 
      self._iprot.readMessageEnd()
3668 
      raise x
3669 
    result = getBillingAddressForUser_result()
3670 
    result.read(self._iprot)
3671 
    self._iprot.readMessageEnd()
3672 
    if result.success is not None:
3673 
      return result.success
3674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3675 
 
3676 
 
3376 rajveer 3677 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3678 
  def __init__(self, handler):
3376 rajveer 3679 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3680 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3681 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3682 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3683 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3684 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3685 
    self._processMap["createUser"] = Processor.process_createUser
3686 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3687 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3688 
    self._processMap["userExists"] = Processor.process_userExists
3689 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3690 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3691 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3692 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3693 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3694 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3695 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3696 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3697 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3698 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3699 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3700 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3701 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3702 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3703 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3704 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3705 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3706 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3707 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3708 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3709 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3710 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3711 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3712 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3713 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3714 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3715 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3716 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3717 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3718 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3719 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3720 
    self._processMap["getCart"] = Processor.process_getCart
3721 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3722 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3723 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3724 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3725 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3726 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3727 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3728 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3729 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3730 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3731 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3732 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3733 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3734 
    self._processMap["checkOut"] = Processor.process_checkOut
3735 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3736 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3737 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3738 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3739 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3740 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3741 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3742 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3743 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3744 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3745 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3746 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3747 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3748 
    self._processMap["insureItem"] = Processor.process_insureItem
3749 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3750 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3751 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3752 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3753 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3754 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3755 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3756 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3757 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3758 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3759 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3760 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3761 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3762 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3763 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3764 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18530 manish.sha 3765 
    self._processMap["isTaxInvoiceCounter"] = Processor.process_isTaxInvoiceCounter
3766 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
94 ashish 3767 
 
3768 
  def process(self, iprot, oprot):
3769 
    (name, type, seqid) = iprot.readMessageBegin()
3770 
    if name not in self._processMap:
3771 
      iprot.skip(TType.STRUCT)
3772 
      iprot.readMessageEnd()
3773 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3774 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3775 
      x.write(oprot)
3776 
      oprot.writeMessageEnd()
3777 
      oprot.trans.flush()
3778 
      return
3779 
    else:
3780 
      self._processMap[name](self, seqid, iprot, oprot)
3781 
    return True
3782 
 
559 chandransh 3783 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3784 
    args = createAnonymousUser_args()
94 ashish 3785 
    args.read(iprot)
3786 
    iprot.readMessageEnd()
559 chandransh 3787 
    result = createAnonymousUser_result()
94 ashish 3788 
    try:
559 chandransh 3789 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3790 
    except UserContextException, ucex:
3791 
      result.ucex = ucex
3792 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3793 
    result.write(oprot)
3794 
    oprot.writeMessageEnd()
3795 
    oprot.trans.flush()
3796 
 
559 chandransh 3797 
  def process_getUserById(self, seqid, iprot, oprot):
3798 
    args = getUserById_args()
94 ashish 3799 
    args.read(iprot)
3800 
    iprot.readMessageEnd()
559 chandransh 3801 
    result = getUserById_result()
94 ashish 3802 
    try:
559 chandransh 3803 
      result.success = self._handler.getUserById(args.userId)
3804 
    except UserContextException, ucex:
3805 
      result.ucex = ucex
3806 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3807 
    result.write(oprot)
3808 
    oprot.writeMessageEnd()
3809 
    oprot.trans.flush()
3810 
 
5326 rajveer 3811 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3812 
    args = getUserByCartId_args()
3813 
    args.read(iprot)
3814 
    iprot.readMessageEnd()
3815 
    result = getUserByCartId_result()
3816 
    try:
3817 
      result.success = self._handler.getUserByCartId(args.cartId)
3818 
    except UserContextException, ucex:
3819 
      result.ucex = ucex
3820 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3821 
    result.write(oprot)
3822 
    oprot.writeMessageEnd()
3823 
    oprot.trans.flush()
3824 
 
1491 vikas 3825 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3826 
    args = getUserByEmail_args()
3827 
    args.read(iprot)
3828 
    iprot.readMessageEnd()
3829 
    result = getUserByEmail_result()
3830 
    try:
3831 
      result.success = self._handler.getUserByEmail(args.email)
3832 
    except UserContextException, ucex:
3833 
      result.ucex = ucex
3834 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3835 
    result.write(oprot)
3836 
    oprot.writeMessageEnd()
3837 
    oprot.trans.flush()
3838 
 
3032 mandeep.dh 3839 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3840 
    args = getUserByMobileNumber_args()
3841 
    args.read(iprot)
3842 
    iprot.readMessageEnd()
3843 
    result = getUserByMobileNumber_result()
3844 
    try:
3845 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3846 
    except UserContextException, ucex:
3847 
      result.ucex = ucex
3848 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3849 
    result.write(oprot)
3850 
    oprot.writeMessageEnd()
3851 
    oprot.trans.flush()
3852 
 
559 chandransh 3853 
  def process_createUser(self, seqid, iprot, oprot):
3854 
    args = createUser_args()
94 ashish 3855 
    args.read(iprot)
3856 
    iprot.readMessageEnd()
559 chandransh 3857 
    result = createUser_result()
94 ashish 3858 
    try:
559 chandransh 3859 
      result.success = self._handler.createUser(args.user)
3860 
    except UserContextException, ucex:
3861 
      result.ucex = ucex
3862 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3863 
    result.write(oprot)
3864 
    oprot.writeMessageEnd()
3865 
    oprot.trans.flush()
3866 
 
559 chandransh 3867 
  def process_updateUser(self, seqid, iprot, oprot):
3868 
    args = updateUser_args()
94 ashish 3869 
    args.read(iprot)
3870 
    iprot.readMessageEnd()
559 chandransh 3871 
    result = updateUser_result()
94 ashish 3872 
    try:
559 chandransh 3873 
      result.success = self._handler.updateUser(args.user)
3874 
    except UserContextException, ucex:
3875 
      result.ucex = ucex
3876 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3877 
    result.write(oprot)
3878 
    oprot.writeMessageEnd()
3879 
    oprot.trans.flush()
3880 
 
122 ashish 3881 
  def process_authenticateUser(self, seqid, iprot, oprot):
3882 
    args = authenticateUser_args()
3883 
    args.read(iprot)
3884 
    iprot.readMessageEnd()
3885 
    result = authenticateUser_result()
3886 
    try:
559 chandransh 3887 
      result.success = self._handler.authenticateUser(args.email, args.password)
3888 
    except AuthenticationException, auex:
3889 
      result.auex = auex
122 ashish 3890 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3891 
    result.write(oprot)
3892 
    oprot.writeMessageEnd()
3893 
    oprot.trans.flush()
3894 
 
94 ashish 3895 
  def process_userExists(self, seqid, iprot, oprot):
3896 
    args = userExists_args()
3897 
    args.read(iprot)
3898 
    iprot.readMessageEnd()
3899 
    result = userExists_result()
3900 
    try:
3901 
      result.success = self._handler.userExists(args.email)
3902 
    except UserContextException, ucx:
3903 
      result.ucx = ucx
3904 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3905 
    result.write(oprot)
3906 
    oprot.writeMessageEnd()
3907 
    oprot.trans.flush()
3908 
 
3909 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3910 
    args = addAddressForUser_args()
3911 
    args.read(iprot)
3912 
    iprot.readMessageEnd()
3913 
    result = addAddressForUser_result()
3914 
    try:
567 rajveer 3915 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3916 
    except UserContextException, ucx:
3917 
      result.ucx = ucx
3918 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3919 
    result.write(oprot)
3920 
    oprot.writeMessageEnd()
3921 
    oprot.trans.flush()
3922 
 
3923 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3924 
    args = removeAddressForUser_args()
3925 
    args.read(iprot)
3926 
    iprot.readMessageEnd()
3927 
    result = removeAddressForUser_result()
3928 
    try:
3929 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3930 
    except UserContextException, ucx:
3931 
      result.ucx = ucx
3932 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3933 
    result.write(oprot)
3934 
    oprot.writeMessageEnd()
3935 
    oprot.trans.flush()
3936 
 
3937 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3938 
    args = setUserAsLoggedIn_args()
3939 
    args.read(iprot)
3940 
    iprot.readMessageEnd()
3941 
    result = setUserAsLoggedIn_result()
3942 
    try:
3943 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3944 
    except UserContextException, ucx:
3945 
      result.ucx = ucx
3946 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3947 
    result.write(oprot)
3948 
    oprot.writeMessageEnd()
3949 
    oprot.trans.flush()
3950 
 
3951 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3952 
    args = setUserAsLoggedOut_args()
3953 
    args.read(iprot)
3954 
    iprot.readMessageEnd()
3955 
    result = setUserAsLoggedOut_result()
3956 
    try:
3957 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3958 
    except UserContextException, ucx:
3959 
      result.ucx = ucx
3960 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3961 
    result.write(oprot)
3962 
    oprot.writeMessageEnd()
3963 
    oprot.trans.flush()
3964 
 
504 rajveer 3965 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3966 
    args = setDefaultAddress_args()
3967 
    args.read(iprot)
3968 
    iprot.readMessageEnd()
3969 
    result = setDefaultAddress_result()
3970 
    try:
3971 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3972 
    except UserContextException, ucx:
3973 
      result.ucx = ucx
3974 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3975 
    result.write(oprot)
3976 
    oprot.writeMessageEnd()
3977 
    oprot.trans.flush()
3978 
 
94 ashish 3979 
  def process_updatePassword(self, seqid, iprot, oprot):
3980 
    args = updatePassword_args()
3981 
    args.read(iprot)
3982 
    iprot.readMessageEnd()
3983 
    result = updatePassword_result()
3984 
    try:
594 rajveer 3985 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3986 
    except UserContextException, ucx:
3987 
      result.ucx = ucx
3988 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3989 
    result.write(oprot)
3990 
    oprot.writeMessageEnd()
3991 
    oprot.trans.flush()
3992 
 
581 rajveer 3993 
  def process_forgotPassword(self, seqid, iprot, oprot):
3994 
    args = forgotPassword_args()
3995 
    args.read(iprot)
3996 
    iprot.readMessageEnd()
3997 
    result = forgotPassword_result()
3998 
    try:
884 rajveer 3999 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4000 
    except UserContextException, ucx:
4001 
      result.ucx = ucx
4002 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4003 
    result.write(oprot)
4004 
    oprot.writeMessageEnd()
4005 
    oprot.trans.flush()
4006 
 
594 rajveer 4007 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4008 
    args = getAllAddressesForUser_args()
4009 
    args.read(iprot)
4010 
    iprot.readMessageEnd()
4011 
    result = getAllAddressesForUser_result()
4012 
    try:
4013 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4014 
    except UserContextException, ucx:
4015 
      result.ucx = ucx
4016 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4017 
    result.write(oprot)
4018 
    oprot.writeMessageEnd()
4019 
    oprot.trans.flush()
4020 
 
1894 vikas 4021 
  def process_getAddressById(self, seqid, iprot, oprot):
4022 
    args = getAddressById_args()
4023 
    args.read(iprot)
4024 
    iprot.readMessageEnd()
4025 
    result = getAddressById_result()
4026 
    try:
4027 
      result.success = self._handler.getAddressById(args.addressId)
4028 
    except UserContextException, ucx:
4029 
      result.ucx = ucx
4030 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4031 
    result.write(oprot)
4032 
    oprot.writeMessageEnd()
4033 
    oprot.trans.flush()
4034 
 
594 rajveer 4035 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4036 
    args = getDefaultAddressId_args()
4037 
    args.read(iprot)
4038 
    iprot.readMessageEnd()
4039 
    result = getDefaultAddressId_result()
4040 
    try:
4041 
      result.success = self._handler.getDefaultAddressId(args.userId)
4042 
    except UserContextException, ucx:
4043 
      result.ucx = ucx
4044 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4045 
    result.write(oprot)
4046 
    oprot.writeMessageEnd()
4047 
    oprot.trans.flush()
4048 
 
785 rajveer 4049 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4050 
    args = getDefaultPincode_args()
4051 
    args.read(iprot)
4052 
    iprot.readMessageEnd()
4053 
    result = getDefaultPincode_result()
4054 
    try:
4055 
      result.success = self._handler.getDefaultPincode(args.userId)
4056 
    except UserContextException, ucx:
4057 
      result.ucx = ucx
4058 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4059 
    result.write(oprot)
4060 
    oprot.writeMessageEnd()
4061 
    oprot.trans.flush()
4062 
 
1274 varun.gupt 4063 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4064 
    args = saveUserCommunication_args()
4065 
    args.read(iprot)
4066 
    iprot.readMessageEnd()
4067 
    result = saveUserCommunication_result()
4068 
    try:
4069 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4070 
    except UserCommunicationException, ucx:
4071 
      result.ucx = ucx
4072 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4073 
    result.write(oprot)
4074 
    oprot.writeMessageEnd()
4075 
    oprot.trans.flush()
4076 
 
1590 varun.gupt 4077 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4078 
    args = getUserCommunicationById_args()
4079 
    args.read(iprot)
4080 
    iprot.readMessageEnd()
4081 
    result = getUserCommunicationById_result()
4082 
    try:
4083 
      result.success = self._handler.getUserCommunicationById(args.id)
4084 
    except UserCommunicationException, ucx:
4085 
      result.ucx = ucx
4086 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4087 
    result.write(oprot)
4088 
    oprot.writeMessageEnd()
4089 
    oprot.trans.flush()
4090 
 
4091 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4092 
    args = getUserCommunicationByUser_args()
4093 
    args.read(iprot)
4094 
    iprot.readMessageEnd()
4095 
    result = getUserCommunicationByUser_result()
4096 
    try:
4097 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4098 
    except UserCommunicationException, ucx:
4099 
      result.ucx = ucx
4100 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4101 
    result.write(oprot)
4102 
    oprot.writeMessageEnd()
4103 
    oprot.trans.flush()
4104 
 
4105 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4106 
    args = getAllUserCommunications_args()
4107 
    args.read(iprot)
4108 
    iprot.readMessageEnd()
4109 
    result = getAllUserCommunications_result()
4110 
    try:
4111 
      result.success = self._handler.getAllUserCommunications()
4112 
    except UserCommunicationException, ucx:
4113 
      result.ucx = ucx
4114 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4115 
    result.write(oprot)
4116 
    oprot.writeMessageEnd()
4117 
    oprot.trans.flush()
4118 
 
5407 amar.kumar 4119 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4120 
    args = removeUserCommunication_args()
4121 
    args.read(iprot)
4122 
    iprot.readMessageEnd()
4123 
    result = removeUserCommunication_result()
4124 
    try:
4125 
      self._handler.removeUserCommunication(args.id)
4126 
    except UserCommunicationException, ucx:
4127 
      result.ucx = ucx
4128 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
1845 vikas 4133 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4134 
    args = createMasterAffiliate_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = createMasterAffiliate_result()
4138 
    try:
1859 vikas 4139 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4140 
    except UserAffiliateException, utx:
1845 vikas 4141 
      result.utx = utx
4142 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4143 
    result.write(oprot)
4144 
    oprot.writeMessageEnd()
4145 
    oprot.trans.flush()
4146 
 
1899 vikas 4147 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4148 
    args = getAllMasterAffiliates_args()
4149 
    args.read(iprot)
4150 
    iprot.readMessageEnd()
4151 
    result = getAllMasterAffiliates_result()
4152 
    try:
4153 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4154 
    except UserAffiliateException, utx:
1899 vikas 4155 
      result.utx = utx
4156 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4157 
    result.write(oprot)
4158 
    oprot.writeMessageEnd()
4159 
    oprot.trans.flush()
4160 
 
1845 vikas 4161 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4162 
    args = getMasterAffiliateById_args()
4163 
    args.read(iprot)
4164 
    iprot.readMessageEnd()
4165 
    result = getMasterAffiliateById_result()
4166 
    try:
4167 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4168 
    except UserAffiliateException, utx:
1845 vikas 4169 
      result.utx = utx
4170 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4171 
    result.write(oprot)
4172 
    oprot.writeMessageEnd()
4173 
    oprot.trans.flush()
4174 
 
4175 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4176 
    args = getMasterAffiliateByName_args()
4177 
    args.read(iprot)
4178 
    iprot.readMessageEnd()
4179 
    result = getMasterAffiliateByName_result()
4180 
    try:
4181 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4182 
    except UserAffiliateException, utx:
1845 vikas 4183 
      result.utx = utx
4184 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4185 
    result.write(oprot)
4186 
    oprot.writeMessageEnd()
4187 
    oprot.trans.flush()
4188 
 
4189 
  def process_createAffiliate(self, seqid, iprot, oprot):
4190 
    args = createAffiliate_args()
4191 
    args.read(iprot)
4192 
    iprot.readMessageEnd()
4193 
    result = createAffiliate_result()
4194 
    try:
1859 vikas 4195 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4196 
    except UserAffiliateException, utx:
1845 vikas 4197 
      result.utx = utx
4198 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4199 
    result.write(oprot)
4200 
    oprot.writeMessageEnd()
4201 
    oprot.trans.flush()
4202 
 
4203 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4204 
    args = getAffiliateById_args()
4205 
    args.read(iprot)
4206 
    iprot.readMessageEnd()
4207 
    result = getAffiliateById_result()
4208 
    try:
4209 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4210 
    except UserAffiliateException, utx:
1845 vikas 4211 
      result.utx = utx
4212 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4213 
    result.write(oprot)
4214 
    oprot.writeMessageEnd()
4215 
    oprot.trans.flush()
4216 
 
4217 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4218 
    args = getAffiliateByName_args()
4219 
    args.read(iprot)
4220 
    iprot.readMessageEnd()
4221 
    result = getAffiliateByName_result()
4222 
    try:
4223 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4224 
    except UserAffiliateException, utx:
1845 vikas 4225 
      result.utx = utx
4226 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4227 
    result.write(oprot)
4228 
    oprot.writeMessageEnd()
4229 
    oprot.trans.flush()
4230 
 
4231 
  def process_getTrackerById(self, seqid, iprot, oprot):
4232 
    args = getTrackerById_args()
4233 
    args.read(iprot)
4234 
    iprot.readMessageEnd()
4235 
    result = getTrackerById_result()
4236 
    try:
1996 vikas 4237 
      result.success = self._handler.getTrackerById(args.id)
4238 
    except UserAffiliateException, utx:
1845 vikas 4239 
      result.utx = utx
4240 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4241 
    result.write(oprot)
4242 
    oprot.writeMessageEnd()
4243 
    oprot.trans.flush()
4244 
 
1996 vikas 4245 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4246 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4247 
    args.read(iprot)
4248 
    iprot.readMessageEnd()
1996 vikas 4249 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4250 
    try:
1996 vikas 4251 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4252 
    except UserAffiliateException, utx:
1845 vikas 4253 
      result.utx = utx
1996 vikas 4254 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4255 
    result.write(oprot)
4256 
    oprot.writeMessageEnd()
4257 
    oprot.trans.flush()
4258 
 
4259 
  def process_addTrackLog(self, seqid, iprot, oprot):
4260 
    args = addTrackLog_args()
4261 
    args.read(iprot)
4262 
    iprot.readMessageEnd()
4263 
    result = addTrackLog_result()
4264 
    try:
1996 vikas 4265 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4266 
    except UserAffiliateException, utx:
1845 vikas 4267 
      result.utx = utx
4268 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4269 
    result.write(oprot)
4270 
    oprot.writeMessageEnd()
4271 
    oprot.trans.flush()
4272 
 
4273 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4274 
    args = getTrackLogById_args()
4275 
    args.read(iprot)
4276 
    iprot.readMessageEnd()
4277 
    result = getTrackLogById_result()
4278 
    try:
4279 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4280 
    except UserAffiliateException, utx:
1845 vikas 4281 
      result.utx = utx
4282 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4283 
    result.write(oprot)
4284 
    oprot.writeMessageEnd()
4285 
    oprot.trans.flush()
4286 
 
1996 vikas 4287 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4288 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
1996 vikas 4291 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4292 
    try:
3293 vikas 4293 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4294 
    except UserAffiliateException, utx:
1845 vikas 4295 
      result.utx = utx
1996 vikas 4296 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
4300 
 
4301 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4302 
    args = getTrackLogsByUser_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    result = getTrackLogsByUser_result()
4306 
    try:
4307 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4308 
    except UserAffiliateException, utx:
1845 vikas 4309 
      result.utx = utx
4310 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4311 
    result.write(oprot)
4312 
    oprot.writeMessageEnd()
4313 
    oprot.trans.flush()
4314 
 
4315 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4316 
    args = getTrackLogs_args()
4317 
    args.read(iprot)
4318 
    iprot.readMessageEnd()
4319 
    result = getTrackLogs_result()
4320 
    try:
1996 vikas 4321 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4322 
    except UserAffiliateException, utx:
1845 vikas 4323 
      result.utx = utx
4324 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4325 
    result.write(oprot)
4326 
    oprot.writeMessageEnd()
4327 
    oprot.trans.flush()
4328 
 
559 chandransh 4329 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4330 
    args = getCurrentCart_args()
94 ashish 4331 
    args.read(iprot)
4332 
    iprot.readMessageEnd()
559 chandransh 4333 
    result = getCurrentCart_result()
94 ashish 4334 
    try:
559 chandransh 4335 
      result.success = self._handler.getCurrentCart(args.userId)
4336 
    except ShoppingCartException, scx:
4337 
      result.scx = scx
4338 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4342 
 
559 chandransh 4343 
  def process_getCart(self, seqid, iprot, oprot):
4344 
    args = getCart_args()
94 ashish 4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
559 chandransh 4347 
    result = getCart_result()
94 ashish 4348 
    try:
559 chandransh 4349 
      result.success = self._handler.getCart(args.cartId)
4350 
    except ShoppingCartException, scx:
4351 
      result.scx = scx
4352 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
4356 
 
559 chandransh 4357 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4358 
    args = getCartsByTime_args()
94 ashish 4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
559 chandransh 4361 
    result = getCartsByTime_result()
94 ashish 4362 
    try:
559 chandransh 4363 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4364 
    except ShoppingCartException, scx:
4365 
      result.scx = scx
4366 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
4370 
 
559 chandransh 4371 
  def process_addItemToCart(self, seqid, iprot, oprot):
4372 
    args = addItemToCart_args()
130 ashish 4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
559 chandransh 4375 
    result = addItemToCart_result()
130 ashish 4376 
    try:
3557 rajveer 4377 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4378 
    except ShoppingCartException, scx:
4379 
      result.scx = scx
4380 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
559 chandransh 4385 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4386 
    args = deleteItemFromCart_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = deleteItemFromCart_result()
4390 
    try:
4391 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4392 
    except ShoppingCartException, scx:
4393 
      result.scx = scx
4394 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
130 ashish 4398 
 
559 chandransh 4399 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4400 
    args = addAddressToCart_args()
4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
4403 
    result = addAddressToCart_result()
575 chandransh 4404 
    try:
4405 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4406 
    except ShoppingCartException, scx:
4407 
      result.scx = scx
559 chandransh 4408 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
4412 
 
5553 rajveer 4413 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4414 
    args = addStoreToCart_args()
4415 
    args.read(iprot)
4416 
    iprot.readMessageEnd()
4417 
    result = addStoreToCart_result()
4418 
    try:
4419 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4420 
    except ShoppingCartException, scx:
4421 
      result.scx = scx
4422 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4423 
    result.write(oprot)
4424 
    oprot.writeMessageEnd()
4425 
    oprot.trans.flush()
4426 
 
1976 varun.gupt 4427 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4428 
    args = applyCouponToCart_args()
4429 
    args.read(iprot)
4430 
    iprot.readMessageEnd()
4431 
    result = applyCouponToCart_result()
4432 
    try:
6922 anupam.sin 4433 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4434 
    except ShoppingCartException, scx:
4435 
      result.scx = scx
4436 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4437 
    result.write(oprot)
4438 
    oprot.writeMessageEnd()
4439 
    oprot.trans.flush()
4440 
 
4441 
  def process_removeCoupon(self, seqid, iprot, oprot):
4442 
    args = removeCoupon_args()
4443 
    args.read(iprot)
4444 
    iprot.readMessageEnd()
4445 
    result = removeCoupon_result()
4446 
    try:
4447 
      self._handler.removeCoupon(args.cartId)
4448 
    except ShoppingCartException, scx:
4449 
      result.scx = scx
4450 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
4454 
 
3554 varun.gupt 4455 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4456 
    args = deleteDiscountsFromCart_args()
4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
4459 
    result = deleteDiscountsFromCart_result()
4460 
    try:
4461 
      self._handler.deleteDiscountsFromCart(args.cartId)
4462 
    except ShoppingCartException, scx:
4463 
      result.scx = scx
4464 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4465 
    result.write(oprot)
4466 
    oprot.writeMessageEnd()
4467 
    oprot.trans.flush()
4468 
 
4469 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4470 
    args = saveDiscounts_args()
4471 
    args.read(iprot)
4472 
    iprot.readMessageEnd()
4473 
    result = saveDiscounts_result()
4474 
    try:
4475 
      self._handler.saveDiscounts(args.discounts)
4476 
    except ShoppingCartException, scx:
4477 
      result.scx = scx
4478 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4479 
    result.write(oprot)
4480 
    oprot.writeMessageEnd()
4481 
    oprot.trans.flush()
4482 
 
690 chandransh 4483 
  def process_createOrders(self, seqid, iprot, oprot):
4484 
    args = createOrders_args()
559 chandransh 4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
690 chandransh 4487 
    result = createOrders_result()
559 chandransh 4488 
    try:
11526 amit.gupta 4489 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4490 
    except ShoppingCartException, scx:
4491 
      result.scx = scx
690 chandransh 4492 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4493 
    result.write(oprot)
4494 
    oprot.writeMessageEnd()
4495 
    oprot.trans.flush()
4496 
 
4497 
  def process_validateCart(self, seqid, iprot, oprot):
4498 
    args = validateCart_args()
4499 
    args.read(iprot)
4500 
    iprot.readMessageEnd()
4501 
    result = validateCart_result()
575 chandransh 4502 
    try:
3557 rajveer 4503 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4504 
    except ShoppingCartException, scex:
4505 
      result.scex = scex
559 chandransh 4506 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4507 
    result.write(oprot)
4508 
    oprot.writeMessageEnd()
4509 
    oprot.trans.flush()
4510 
 
11980 amit.gupta 4511 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4512 
    args = validateCartWithDealerCoupon_args()
4513 
    args.read(iprot)
4514 
    iprot.readMessageEnd()
4515 
    result = validateCartWithDealerCoupon_result()
4516 
    try:
4517 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4518 
    except ShoppingCartException, scex:
4519 
      result.scex = scex
4520 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4521 
    result.write(oprot)
4522 
    oprot.writeMessageEnd()
4523 
    oprot.trans.flush()
4524 
 
690 chandransh 4525 
  def process_mergeCart(self, seqid, iprot, oprot):
4526 
    args = mergeCart_args()
575 chandransh 4527 
    args.read(iprot)
4528 
    iprot.readMessageEnd()
690 chandransh 4529 
    result = mergeCart_result()
4530 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4531 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4532 
    result.write(oprot)
4533 
    oprot.writeMessageEnd()
4534 
    oprot.trans.flush()
4535 
 
4536 
  def process_checkOut(self, seqid, iprot, oprot):
4537 
    args = checkOut_args()
4538 
    args.read(iprot)
4539 
    iprot.readMessageEnd()
4540 
    result = checkOut_result()
575 chandransh 4541 
    try:
690 chandransh 4542 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4543 
    except ShoppingCartException, scex:
4544 
      result.scex = scex
690 chandransh 4545 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4546 
    result.write(oprot)
4547 
    oprot.writeMessageEnd()
4548 
    oprot.trans.flush()
4549 
 
690 chandransh 4550 
  def process_resetCart(self, seqid, iprot, oprot):
4551 
    args = resetCart_args()
559 chandransh 4552 
    args.read(iprot)
4553 
    iprot.readMessageEnd()
690 chandransh 4554 
    result = resetCart_result()
4555 
    try:
4556 
      result.success = self._handler.resetCart(args.cartId, args.items)
4557 
    except ShoppingCartException, scex:
4558 
      result.scex = scex
4559 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4560 
    result.write(oprot)
4561 
    oprot.writeMessageEnd()
4562 
    oprot.trans.flush()
4563 
 
2981 rajveer 4564 
  def process_getUserCount(self, seqid, iprot, oprot):
4565 
    args = getUserCount_args()
559 chandransh 4566 
    args.read(iprot)
4567 
    iprot.readMessageEnd()
2981 rajveer 4568 
    result = getUserCount_result()
4569 
    result.success = self._handler.getUserCount(args.userType)
4570 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4571 
    result.write(oprot)
4572 
    oprot.writeMessageEnd()
4573 
    oprot.trans.flush()
4574 
 
2981 rajveer 4575 
  def process_getAllUsers(self, seqid, iprot, oprot):
4576 
    args = getAllUsers_args()
559 chandransh 4577 
    args.read(iprot)
4578 
    iprot.readMessageEnd()
2981 rajveer 4579 
    result = getAllUsers_result()
4580 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4581 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
2981 rajveer 4586 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4587 
    args = getMyResearchItems_args()
559 chandransh 4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
2981 rajveer 4590 
    result = getMyResearchItems_result()
559 chandransh 4591 
    try:
2981 rajveer 4592 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4593 
    except WidgetException, scx:
4594 
      result.scx = scx
2981 rajveer 4595 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
4599 
 
2981 rajveer 4600 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4601 
    args = updateMyResearch_args()
772 rajveer 4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
2981 rajveer 4604 
    result = updateMyResearch_result()
4605 
    try:
4606 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4607 
    except WidgetException, scx:
4608 
      result.scx = scx
4609 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4610 
    result.write(oprot)
4611 
    oprot.writeMessageEnd()
4612 
    oprot.trans.flush()
559 chandransh 4613 
 
2981 rajveer 4614 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4615 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4616 
    args.read(iprot)
4617 
    iprot.readMessageEnd()
2981 rajveer 4618 
    result = deleteItemFromMyResearch_result()
4619 
    try:
4620 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4621 
    except WidgetException, scx:
4622 
      result.scx = scx
4623 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4624 
    result.write(oprot)
4625 
    oprot.writeMessageEnd()
4626 
    oprot.trans.flush()
772 rajveer 4627 
 
2981 rajveer 4628 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4629 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4630 
    args.read(iprot)
4631 
    iprot.readMessageEnd()
2981 rajveer 4632 
    result = getBrowseHistoryItems_result()
4633 
    try:
4634 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4635 
    except WidgetException, scx:
4636 
      result.scx = scx
4637 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4638 
    result.write(oprot)
4639 
    oprot.writeMessageEnd()
4640 
    oprot.trans.flush()
1596 ankur.sing 4641 
 
2981 rajveer 4642 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4643 
    args = updateBrowseHistory_args()
2642 varun.gupt 4644 
    args.read(iprot)
4645 
    iprot.readMessageEnd()
2981 rajveer 4646 
    result = updateBrowseHistory_result()
4647 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4648 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4649 
    result.write(oprot)
4650 
    oprot.writeMessageEnd()
4651 
    oprot.trans.flush()
1673 ankur.sing 4652 
 
3385 varun.gupt 4653 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4654 
    args = getCartsWithCouponCount_args()
4655 
    args.read(iprot)
4656 
    iprot.readMessageEnd()
4657 
    result = getCartsWithCouponCount_result()
4658 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4659 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
2642 varun.gupt 4663 
 
3499 mandeep.dh 4664 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4665 
    args = increaseTrustLevel_args()
4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
4668 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4669 
    return
3385 varun.gupt 4670 
 
5407 amar.kumar 4671 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4672 
    args = getTrustLevel_args()
4673 
    args.read(iprot)
4674 
    iprot.readMessageEnd()
4675 
    result = getTrustLevel_result()
4676 
    result.success = self._handler.getTrustLevel(args.userId)
4677 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4678 
    result.write(oprot)
4679 
    oprot.writeMessageEnd()
4680 
    oprot.trans.flush()
4681 
 
4668 varun.gupt 4682 
  def process_showCODOption(self, seqid, iprot, oprot):
4683 
    args = showCODOption_args()
4684 
    args.read(iprot)
4685 
    iprot.readMessageEnd()
4686 
    result = showCODOption_result()
4687 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4688 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4689 
    result.write(oprot)
4690 
    oprot.writeMessageEnd()
4691 
    oprot.trans.flush()
3499 mandeep.dh 4692 
 
5623 anupam.sin 4693 
  def process_getUserEmails(self, seqid, iprot, oprot):
4694 
    args = getUserEmails_args()
4695 
    args.read(iprot)
4696 
    iprot.readMessageEnd()
4697 
    result = getUserEmails_result()
4698 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4699 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4700 
    result.write(oprot)
4701 
    oprot.writeMessageEnd()
4702 
    oprot.trans.flush()
4668 varun.gupt 4703 
 
6903 anupam.sin 4704 
  def process_insureItem(self, seqid, iprot, oprot):
4705 
    args = insureItem_args()
4706 
    args.read(iprot)
4707 
    iprot.readMessageEnd()
4708 
    result = insureItem_result()
9299 kshitij.so 4709 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4710 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4711 
    result.write(oprot)
4712 
    oprot.writeMessageEnd()
4713 
    oprot.trans.flush()
4714 
 
4715 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4716 
    args = cancelInsurance_args()
4717 
    args.read(iprot)
4718 
    iprot.readMessageEnd()
4719 
    result = cancelInsurance_result()
4720 
    result.success = self._handler.cancelInsurance(args.cartId)
4721 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4722 
    result.write(oprot)
4723 
    oprot.writeMessageEnd()
4724 
    oprot.trans.flush()
4725 
 
4726 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4727 
    args = storeInsuranceSpecificDetails_args()
4728 
    args.read(iprot)
4729 
    iprot.readMessageEnd()
4730 
    result = storeInsuranceSpecificDetails_result()
4731 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4732 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4733 
    result.write(oprot)
4734 
    oprot.writeMessageEnd()
4735 
    oprot.trans.flush()
4736 
 
4737 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4738 
    args = isInsuranceDetailPresent_args()
4739 
    args.read(iprot)
4740 
    iprot.readMessageEnd()
4741 
    result = isInsuranceDetailPresent_result()
4742 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4743 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
9791 rajveer 4748 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4749 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
9791 rajveer 4752 
    result = getProductsAddedToCart_result()
4753 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4754 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
5623 anupam.sin 4758 
 
11592 amit.gupta 4759 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4760 
    args = validateCartPlus_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = validateCartPlus_result()
4764 
    try:
11980 amit.gupta 4765 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4766 
    except ShoppingCartException, scex:
4767 
      result.scex = scex
4768 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4769 
    result.write(oprot)
4770 
    oprot.writeMessageEnd()
4771 
    oprot.trans.flush()
6821 amar.kumar 4772 
 
11679 vikram.rag 4773 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4774 
    args = isPrivateDealUser_args()
4775 
    args.read(iprot)
4776 
    iprot.readMessageEnd()
4777 
    result = isPrivateDealUser_result()
4778 
    result.success = self._handler.isPrivateDealUser(args.userId)
4779 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4780 
    result.write(oprot)
4781 
    oprot.writeMessageEnd()
4782 
    oprot.trans.flush()
11592 amit.gupta 4783 
 
11890 kshitij.so 4784 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4785 
    args = addPrivateDealUser_args()
4786 
    args.read(iprot)
4787 
    iprot.readMessageEnd()
4788 
    result = addPrivateDealUser_result()
4789 
    result.success = self._handler.addPrivateDealUser(args.userId)
4790 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4791 
    result.write(oprot)
4792 
    oprot.writeMessageEnd()
4793 
    oprot.trans.flush()
11679 vikram.rag 4794 
 
11890 kshitij.so 4795 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4796 
    args = changePrivateDealUserStatus_args()
4797 
    args.read(iprot)
4798 
    iprot.readMessageEnd()
4799 
    result = changePrivateDealUserStatus_result()
4800 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4801 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
4805 
 
4806 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4807 
    args = getPrivateDealUser_args()
4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
4810 
    result = getPrivateDealUser_result()
4811 
    result.success = self._handler.getPrivateDealUser(args.userId)
4812 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
12696 amit.gupta 4817 
  def process_registerCounter(self, seqid, iprot, oprot):
4818 
    args = registerCounter_args()
4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
4821 
    result = registerCounter_result()
4822 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4823 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4824 
    result.write(oprot)
4825 
    oprot.writeMessageEnd()
4826 
    oprot.trans.flush()
11890 kshitij.so 4827 
 
12722 amit.gupta 4828 
  def process_searchCounter(self, seqid, iprot, oprot):
4829 
    args = searchCounter_args()
4830 
    args.read(iprot)
4831 
    iprot.readMessageEnd()
4832 
    result = searchCounter_result()
4833 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4834 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4835 
    result.write(oprot)
4836 
    oprot.writeMessageEnd()
4837 
    oprot.trans.flush()
12696 amit.gupta 4838 
 
12722 amit.gupta 4839 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4840 
    args = getAllUsersByCounter_args()
4841 
    args.read(iprot)
4842 
    iprot.readMessageEnd()
4843 
    result = getAllUsersByCounter_result()
4844 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4845 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4846 
    result.write(oprot)
4847 
    oprot.writeMessageEnd()
4848 
    oprot.trans.flush()
4849 
 
15251 manish.sha 4850 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
4851 
    args = getActiveAccessTokenForUser_args()
4852 
    args.read(iprot)
4853 
    iprot.readMessageEnd()
4854 
    result = getActiveAccessTokenForUser_result()
4855 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
4856 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
4857 
    result.write(oprot)
4858 
    oprot.writeMessageEnd()
4859 
    oprot.trans.flush()
12722 amit.gupta 4860 
 
15251 manish.sha 4861 
  def process_validateAccessToken(self, seqid, iprot, oprot):
4862 
    args = validateAccessToken_args()
4863 
    args.read(iprot)
4864 
    iprot.readMessageEnd()
4865 
    result = validateAccessToken_result()
4866 
    result.success = self._handler.validateAccessToken(args.accessToken)
4867 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
4871 
 
17782 amit.gupta 4872 
  def process_addItemsToCart(self, seqid, iprot, oprot):
4873 
    args = addItemsToCart_args()
4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
4876 
    result = addItemsToCart_result()
4877 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
4878 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
4879 
    result.write(oprot)
4880 
    oprot.writeMessageEnd()
4881 
    oprot.trans.flush()
15251 manish.sha 4882 
 
17782 amit.gupta 4883 
  def process_validateCartNew(self, seqid, iprot, oprot):
4884 
    args = validateCartNew_args()
4885 
    args.read(iprot)
4886 
    iprot.readMessageEnd()
4887 
    result = validateCartNew_result()
4888 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
4889 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
4893 
 
18530 manish.sha 4894 
  def process_isTaxInvoiceCounter(self, seqid, iprot, oprot):
4895 
    args = isTaxInvoiceCounter_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = isTaxInvoiceCounter_result()
4899 
    result.success = self._handler.isTaxInvoiceCounter(args.userId)
4900 
    oprot.writeMessageBegin("isTaxInvoiceCounter", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
17782 amit.gupta 4904 
 
18530 manish.sha 4905 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
4906 
    args = getBillingAddressForUser_args()
4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
4909 
    result = getBillingAddressForUser_result()
4910 
    result.success = self._handler.getBillingAddressForUser(args.userId)
4911 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
4916 
 
94 ashish 4917 
# HELPER FUNCTIONS AND STRUCTURES
4918 
 
559 chandransh 4919 
class createAnonymousUser_args:
94 ashish 4920 
  """
4921 
  Attributes:
559 chandransh 4922 
   - jsessionId
94 ashish 4923 
  """
4924 
 
4925 
  thrift_spec = (
4926 
    None, # 0
559 chandransh 4927 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4928 
  )
4929 
 
559 chandransh 4930 
  def __init__(self, jsessionId=None,):
4931 
    self.jsessionId = jsessionId
94 ashish 4932 
 
4933 
  def read(self, iprot):
4934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4936 
      return
4937 
    iprot.readStructBegin()
4938 
    while True:
4939 
      (fname, ftype, fid) = iprot.readFieldBegin()
4940 
      if ftype == TType.STOP:
4941 
        break
4942 
      if fid == 1:
559 chandransh 4943 
        if ftype == TType.STRING:
4944 
          self.jsessionId = iprot.readString();
94 ashish 4945 
        else:
4946 
          iprot.skip(ftype)
4947 
      else:
4948 
        iprot.skip(ftype)
4949 
      iprot.readFieldEnd()
4950 
    iprot.readStructEnd()
4951 
 
4952 
  def write(self, oprot):
4953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4955 
      return
559 chandransh 4956 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4957 
    if self.jsessionId is not None:
559 chandransh 4958 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4959 
      oprot.writeString(self.jsessionId)
94 ashish 4960 
      oprot.writeFieldEnd()
4961 
    oprot.writeFieldStop()
4962 
    oprot.writeStructEnd()
4963 
 
3431 rajveer 4964 
  def validate(self):
4965 
    return
4966 
 
4967 
 
94 ashish 4968 
  def __repr__(self):
4969 
    L = ['%s=%r' % (key, value)
4970 
      for key, value in self.__dict__.iteritems()]
4971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4972 
 
4973 
  def __eq__(self, other):
4974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4975 
 
4976 
  def __ne__(self, other):
4977 
    return not (self == other)
4978 
 
559 chandransh 4979 
class createAnonymousUser_result:
94 ashish 4980 
  """
4981 
  Attributes:
4982 
   - success
559 chandransh 4983 
   - ucex
94 ashish 4984 
  """
4985 
 
4986 
  thrift_spec = (
559 chandransh 4987 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4988 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4989 
  )
4990 
 
559 chandransh 4991 
  def __init__(self, success=None, ucex=None,):
94 ashish 4992 
    self.success = success
559 chandransh 4993 
    self.ucex = ucex
94 ashish 4994 
 
4995 
  def read(self, iprot):
4996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4998 
      return
4999 
    iprot.readStructBegin()
5000 
    while True:
5001 
      (fname, ftype, fid) = iprot.readFieldBegin()
5002 
      if ftype == TType.STOP:
5003 
        break
5004 
      if fid == 0:
5005 
        if ftype == TType.STRUCT:
559 chandransh 5006 
          self.success = User()
94 ashish 5007 
          self.success.read(iprot)
5008 
        else:
5009 
          iprot.skip(ftype)
5010 
      elif fid == 1:
5011 
        if ftype == TType.STRUCT:
559 chandransh 5012 
          self.ucex = UserContextException()
5013 
          self.ucex.read(iprot)
94 ashish 5014 
        else:
5015 
          iprot.skip(ftype)
5016 
      else:
5017 
        iprot.skip(ftype)
5018 
      iprot.readFieldEnd()
5019 
    iprot.readStructEnd()
5020 
 
5021 
  def write(self, oprot):
5022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5024 
      return
559 chandransh 5025 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5026 
    if self.success is not None:
94 ashish 5027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5028 
      self.success.write(oprot)
5029 
      oprot.writeFieldEnd()
3431 rajveer 5030 
    if self.ucex is not None:
559 chandransh 5031 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5032 
      self.ucex.write(oprot)
94 ashish 5033 
      oprot.writeFieldEnd()
5034 
    oprot.writeFieldStop()
5035 
    oprot.writeStructEnd()
5036 
 
3431 rajveer 5037 
  def validate(self):
5038 
    return
5039 
 
5040 
 
94 ashish 5041 
  def __repr__(self):
5042 
    L = ['%s=%r' % (key, value)
5043 
      for key, value in self.__dict__.iteritems()]
5044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5045 
 
5046 
  def __eq__(self, other):
5047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5048 
 
5049 
  def __ne__(self, other):
5050 
    return not (self == other)
5051 
 
559 chandransh 5052 
class getUserById_args:
94 ashish 5053 
  """
5054 
  Attributes:
5055 
   - userId
5056 
  """
5057 
 
5058 
  thrift_spec = (
5059 
    None, # 0
5060 
    (1, TType.I64, 'userId', None, None, ), # 1
5061 
  )
5062 
 
559 chandransh 5063 
  def __init__(self, userId=None,):
94 ashish 5064 
    self.userId = userId
5065 
 
5066 
  def read(self, iprot):
5067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5069 
      return
5070 
    iprot.readStructBegin()
5071 
    while True:
5072 
      (fname, ftype, fid) = iprot.readFieldBegin()
5073 
      if ftype == TType.STOP:
5074 
        break
5075 
      if fid == 1:
5076 
        if ftype == TType.I64:
5077 
          self.userId = iprot.readI64();
5078 
        else:
5079 
          iprot.skip(ftype)
5080 
      else:
5081 
        iprot.skip(ftype)
5082 
      iprot.readFieldEnd()
5083 
    iprot.readStructEnd()
5084 
 
5085 
  def write(self, oprot):
5086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5088 
      return
559 chandransh 5089 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5090 
    if self.userId is not None:
94 ashish 5091 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5092 
      oprot.writeI64(self.userId)
5093 
      oprot.writeFieldEnd()
5094 
    oprot.writeFieldStop()
5095 
    oprot.writeStructEnd()
5096 
 
3431 rajveer 5097 
  def validate(self):
5098 
    return
5099 
 
5100 
 
94 ashish 5101 
  def __repr__(self):
5102 
    L = ['%s=%r' % (key, value)
5103 
      for key, value in self.__dict__.iteritems()]
5104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5105 
 
5106 
  def __eq__(self, other):
5107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5108 
 
5109 
  def __ne__(self, other):
5110 
    return not (self == other)
5111 
 
559 chandransh 5112 
class getUserById_result:
94 ashish 5113 
  """
5114 
  Attributes:
5115 
   - success
559 chandransh 5116 
   - ucex
94 ashish 5117 
  """
5118 
 
5119 
  thrift_spec = (
559 chandransh 5120 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5121 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5122 
  )
5123 
 
559 chandransh 5124 
  def __init__(self, success=None, ucex=None,):
94 ashish 5125 
    self.success = success
559 chandransh 5126 
    self.ucex = ucex
94 ashish 5127 
 
5128 
  def read(self, iprot):
5129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5131 
      return
5132 
    iprot.readStructBegin()
5133 
    while True:
5134 
      (fname, ftype, fid) = iprot.readFieldBegin()
5135 
      if ftype == TType.STOP:
5136 
        break
5137 
      if fid == 0:
5138 
        if ftype == TType.STRUCT:
559 chandransh 5139 
          self.success = User()
94 ashish 5140 
          self.success.read(iprot)
5141 
        else:
5142 
          iprot.skip(ftype)
5143 
      elif fid == 1:
5144 
        if ftype == TType.STRUCT:
559 chandransh 5145 
          self.ucex = UserContextException()
5146 
          self.ucex.read(iprot)
94 ashish 5147 
        else:
5148 
          iprot.skip(ftype)
5149 
      else:
5150 
        iprot.skip(ftype)
5151 
      iprot.readFieldEnd()
5152 
    iprot.readStructEnd()
5153 
 
5154 
  def write(self, oprot):
5155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5157 
      return
559 chandransh 5158 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5159 
    if self.success is not None:
94 ashish 5160 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5161 
      self.success.write(oprot)
5162 
      oprot.writeFieldEnd()
3431 rajveer 5163 
    if self.ucex is not None:
559 chandransh 5164 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5165 
      self.ucex.write(oprot)
94 ashish 5166 
      oprot.writeFieldEnd()
5167 
    oprot.writeFieldStop()
5168 
    oprot.writeStructEnd()
5169 
 
3431 rajveer 5170 
  def validate(self):
5171 
    return
5172 
 
5173 
 
94 ashish 5174 
  def __repr__(self):
5175 
    L = ['%s=%r' % (key, value)
5176 
      for key, value in self.__dict__.iteritems()]
5177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5178 
 
5179 
  def __eq__(self, other):
5180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5181 
 
5182 
  def __ne__(self, other):
5183 
    return not (self == other)
5184 
 
5326 rajveer 5185 
class getUserByCartId_args:
1491 vikas 5186 
  """
5187 
  Attributes:
5326 rajveer 5188 
   - cartId
1491 vikas 5189 
  """
5190 
 
5191 
  thrift_spec = (
5192 
    None, # 0
5326 rajveer 5193 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5194 
  )
5195 
 
5326 rajveer 5196 
  def __init__(self, cartId=None,):
5197 
    self.cartId = cartId
1491 vikas 5198 
 
5199 
  def read(self, iprot):
5200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5202 
      return
5203 
    iprot.readStructBegin()
5204 
    while True:
5205 
      (fname, ftype, fid) = iprot.readFieldBegin()
5206 
      if ftype == TType.STOP:
5207 
        break
5208 
      if fid == 1:
5326 rajveer 5209 
        if ftype == TType.I64:
5210 
          self.cartId = iprot.readI64();
1491 vikas 5211 
        else:
5212 
          iprot.skip(ftype)
5213 
      else:
5214 
        iprot.skip(ftype)
5215 
      iprot.readFieldEnd()
5216 
    iprot.readStructEnd()
5217 
 
5218 
  def write(self, oprot):
5219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5221 
      return
5326 rajveer 5222 
    oprot.writeStructBegin('getUserByCartId_args')
5223 
    if self.cartId is not None:
5224 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5225 
      oprot.writeI64(self.cartId)
1491 vikas 5226 
      oprot.writeFieldEnd()
5227 
    oprot.writeFieldStop()
5228 
    oprot.writeStructEnd()
5229 
 
3431 rajveer 5230 
  def validate(self):
5231 
    return
5232 
 
5233 
 
1491 vikas 5234 
  def __repr__(self):
5235 
    L = ['%s=%r' % (key, value)
5236 
      for key, value in self.__dict__.iteritems()]
5237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5238 
 
5239 
  def __eq__(self, other):
5240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5241 
 
5242 
  def __ne__(self, other):
5243 
    return not (self == other)
5244 
 
5326 rajveer 5245 
class getUserByCartId_result:
1491 vikas 5246 
  """
5247 
  Attributes:
5248 
   - success
5249 
   - ucex
5250 
  """
5251 
 
5252 
  thrift_spec = (
5253 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5254 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5255 
  )
5256 
 
5257 
  def __init__(self, success=None, ucex=None,):
5258 
    self.success = success
5259 
    self.ucex = ucex
5260 
 
5261 
  def read(self, iprot):
5262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5264 
      return
5265 
    iprot.readStructBegin()
5266 
    while True:
5267 
      (fname, ftype, fid) = iprot.readFieldBegin()
5268 
      if ftype == TType.STOP:
5269 
        break
5270 
      if fid == 0:
5271 
        if ftype == TType.STRUCT:
5272 
          self.success = User()
5273 
          self.success.read(iprot)
5274 
        else:
5275 
          iprot.skip(ftype)
5276 
      elif fid == 1:
5277 
        if ftype == TType.STRUCT:
5278 
          self.ucex = UserContextException()
5279 
          self.ucex.read(iprot)
5280 
        else:
5281 
          iprot.skip(ftype)
5282 
      else:
5283 
        iprot.skip(ftype)
5284 
      iprot.readFieldEnd()
5285 
    iprot.readStructEnd()
5286 
 
5287 
  def write(self, oprot):
5288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5290 
      return
5326 rajveer 5291 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5292 
    if self.success is not None:
1491 vikas 5293 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5294 
      self.success.write(oprot)
5295 
      oprot.writeFieldEnd()
3431 rajveer 5296 
    if self.ucex is not None:
1491 vikas 5297 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5298 
      self.ucex.write(oprot)
5299 
      oprot.writeFieldEnd()
5300 
    oprot.writeFieldStop()
5301 
    oprot.writeStructEnd()
5302 
 
3431 rajveer 5303 
  def validate(self):
5304 
    return
5305 
 
5306 
 
1491 vikas 5307 
  def __repr__(self):
5308 
    L = ['%s=%r' % (key, value)
5309 
      for key, value in self.__dict__.iteritems()]
5310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5311 
 
5312 
  def __eq__(self, other):
5313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5314 
 
5315 
  def __ne__(self, other):
5316 
    return not (self == other)
5317 
 
5326 rajveer 5318 
class getUserByEmail_args:
3032 mandeep.dh 5319 
  """
5320 
  Attributes:
5326 rajveer 5321 
   - email
3032 mandeep.dh 5322 
  """
5323 
 
5324 
  thrift_spec = (
5325 
    None, # 0
5326 rajveer 5326 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5327 
  )
5328 
 
5326 rajveer 5329 
  def __init__(self, email=None,):
5330 
    self.email = email
3032 mandeep.dh 5331 
 
5332 
  def read(self, iprot):
5333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5335 
      return
5336 
    iprot.readStructBegin()
5337 
    while True:
5338 
      (fname, ftype, fid) = iprot.readFieldBegin()
5339 
      if ftype == TType.STOP:
5340 
        break
5341 
      if fid == 1:
5326 rajveer 5342 
        if ftype == TType.STRING:
5343 
          self.email = iprot.readString();
3032 mandeep.dh 5344 
        else:
5345 
          iprot.skip(ftype)
5346 
      else:
5347 
        iprot.skip(ftype)
5348 
      iprot.readFieldEnd()
5349 
    iprot.readStructEnd()
5350 
 
5351 
  def write(self, oprot):
5352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5354 
      return
5326 rajveer 5355 
    oprot.writeStructBegin('getUserByEmail_args')
5356 
    if self.email is not None:
5357 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5358 
      oprot.writeString(self.email)
3032 mandeep.dh 5359 
      oprot.writeFieldEnd()
5360 
    oprot.writeFieldStop()
5361 
    oprot.writeStructEnd()
5362 
 
3431 rajveer 5363 
  def validate(self):
5364 
    return
5365 
 
5366 
 
3032 mandeep.dh 5367 
  def __repr__(self):
5368 
    L = ['%s=%r' % (key, value)
5369 
      for key, value in self.__dict__.iteritems()]
5370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5371 
 
5372 
  def __eq__(self, other):
5373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5374 
 
5375 
  def __ne__(self, other):
5376 
    return not (self == other)
5377 
 
5326 rajveer 5378 
class getUserByEmail_result:
3032 mandeep.dh 5379 
  """
5380 
  Attributes:
5381 
   - success
5382 
   - ucex
5383 
  """
5384 
 
5385 
  thrift_spec = (
5386 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5387 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5388 
  )
5389 
 
5390 
  def __init__(self, success=None, ucex=None,):
5391 
    self.success = success
5392 
    self.ucex = ucex
5393 
 
5394 
  def read(self, iprot):
5395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5397 
      return
5398 
    iprot.readStructBegin()
5399 
    while True:
5400 
      (fname, ftype, fid) = iprot.readFieldBegin()
5401 
      if ftype == TType.STOP:
5402 
        break
5403 
      if fid == 0:
5404 
        if ftype == TType.STRUCT:
5405 
          self.success = User()
5406 
          self.success.read(iprot)
5407 
        else:
5408 
          iprot.skip(ftype)
5409 
      elif fid == 1:
5410 
        if ftype == TType.STRUCT:
5411 
          self.ucex = UserContextException()
5412 
          self.ucex.read(iprot)
5413 
        else:
5414 
          iprot.skip(ftype)
5415 
      else:
5416 
        iprot.skip(ftype)
5417 
      iprot.readFieldEnd()
5418 
    iprot.readStructEnd()
5419 
 
5420 
  def write(self, oprot):
5421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5423 
      return
5326 rajveer 5424 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5425 
    if self.success is not None:
3032 mandeep.dh 5426 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5427 
      self.success.write(oprot)
5428 
      oprot.writeFieldEnd()
3431 rajveer 5429 
    if self.ucex is not None:
3032 mandeep.dh 5430 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5431 
      self.ucex.write(oprot)
5432 
      oprot.writeFieldEnd()
5433 
    oprot.writeFieldStop()
5434 
    oprot.writeStructEnd()
5435 
 
3431 rajveer 5436 
  def validate(self):
5437 
    return
5438 
 
5439 
 
3032 mandeep.dh 5440 
  def __repr__(self):
5441 
    L = ['%s=%r' % (key, value)
5442 
      for key, value in self.__dict__.iteritems()]
5443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5444 
 
5445 
  def __eq__(self, other):
5446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5447 
 
5448 
  def __ne__(self, other):
5449 
    return not (self == other)
5450 
 
5326 rajveer 5451 
class getUserByMobileNumber_args:
94 ashish 5452 
  """
5453 
  Attributes:
5326 rajveer 5454 
   - mobileNumber
94 ashish 5455 
  """
5456 
 
5457 
  thrift_spec = (
5458 
    None, # 0
5326 rajveer 5459 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5460 
  )
5461 
 
5326 rajveer 5462 
  def __init__(self, mobileNumber=None,):
5463 
    self.mobileNumber = mobileNumber
94 ashish 5464 
 
5465 
  def read(self, iprot):
5466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5468 
      return
5469 
    iprot.readStructBegin()
5470 
    while True:
5471 
      (fname, ftype, fid) = iprot.readFieldBegin()
5472 
      if ftype == TType.STOP:
5473 
        break
5474 
      if fid == 1:
5326 rajveer 5475 
        if ftype == TType.I64:
5476 
          self.mobileNumber = iprot.readI64();
94 ashish 5477 
        else:
5478 
          iprot.skip(ftype)
5479 
      else:
5480 
        iprot.skip(ftype)
5481 
      iprot.readFieldEnd()
5482 
    iprot.readStructEnd()
5483 
 
5484 
  def write(self, oprot):
5485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5487 
      return
5326 rajveer 5488 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5489 
    if self.mobileNumber is not None:
5490 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5491 
      oprot.writeI64(self.mobileNumber)
94 ashish 5492 
      oprot.writeFieldEnd()
5493 
    oprot.writeFieldStop()
5494 
    oprot.writeStructEnd()
5495 
 
3431 rajveer 5496 
  def validate(self):
5497 
    return
5498 
 
5499 
 
94 ashish 5500 
  def __repr__(self):
5501 
    L = ['%s=%r' % (key, value)
5502 
      for key, value in self.__dict__.iteritems()]
5503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5504 
 
5505 
  def __eq__(self, other):
5506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5507 
 
5508 
  def __ne__(self, other):
5509 
    return not (self == other)
5510 
 
5326 rajveer 5511 
class getUserByMobileNumber_result:
94 ashish 5512 
  """
5513 
  Attributes:
5514 
   - success
559 chandransh 5515 
   - ucex
94 ashish 5516 
  """
5517 
 
5518 
  thrift_spec = (
559 chandransh 5519 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5520 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5521 
  )
5522 
 
559 chandransh 5523 
  def __init__(self, success=None, ucex=None,):
94 ashish 5524 
    self.success = success
559 chandransh 5525 
    self.ucex = ucex
94 ashish 5526 
 
5527 
  def read(self, iprot):
5528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5530 
      return
5531 
    iprot.readStructBegin()
5532 
    while True:
5533 
      (fname, ftype, fid) = iprot.readFieldBegin()
5534 
      if ftype == TType.STOP:
5535 
        break
5536 
      if fid == 0:
5537 
        if ftype == TType.STRUCT:
559 chandransh 5538 
          self.success = User()
94 ashish 5539 
          self.success.read(iprot)
5540 
        else:
5541 
          iprot.skip(ftype)
5542 
      elif fid == 1:
5543 
        if ftype == TType.STRUCT:
559 chandransh 5544 
          self.ucex = UserContextException()
5545 
          self.ucex.read(iprot)
94 ashish 5546 
        else:
5547 
          iprot.skip(ftype)
5548 
      else:
5549 
        iprot.skip(ftype)
5550 
      iprot.readFieldEnd()
5551 
    iprot.readStructEnd()
5552 
 
5553 
  def write(self, oprot):
5554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5556 
      return
5326 rajveer 5557 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5558 
    if self.success is not None:
94 ashish 5559 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5560 
      self.success.write(oprot)
5561 
      oprot.writeFieldEnd()
3431 rajveer 5562 
    if self.ucex is not None:
559 chandransh 5563 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5564 
      self.ucex.write(oprot)
94 ashish 5565 
      oprot.writeFieldEnd()
5566 
    oprot.writeFieldStop()
5567 
    oprot.writeStructEnd()
5568 
 
3431 rajveer 5569 
  def validate(self):
5570 
    return
5571 
 
5572 
 
94 ashish 5573 
  def __repr__(self):
5574 
    L = ['%s=%r' % (key, value)
5575 
      for key, value in self.__dict__.iteritems()]
5576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5577 
 
5578 
  def __eq__(self, other):
5579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5580 
 
5581 
  def __ne__(self, other):
5582 
    return not (self == other)
5583 
 
5326 rajveer 5584 
class createUser_args:
94 ashish 5585 
  """
5586 
  Attributes:
559 chandransh 5587 
   - user
94 ashish 5588 
  """
5589 
 
5590 
  thrift_spec = (
5591 
    None, # 0
559 chandransh 5592 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5593 
  )
5594 
 
559 chandransh 5595 
  def __init__(self, user=None,):
5596 
    self.user = user
94 ashish 5597 
 
5598 
  def read(self, iprot):
5599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5601 
      return
5602 
    iprot.readStructBegin()
5603 
    while True:
5604 
      (fname, ftype, fid) = iprot.readFieldBegin()
5605 
      if ftype == TType.STOP:
5606 
        break
5607 
      if fid == 1:
559 chandransh 5608 
        if ftype == TType.STRUCT:
5609 
          self.user = User()
5610 
          self.user.read(iprot)
94 ashish 5611 
        else:
5612 
          iprot.skip(ftype)
5613 
      else:
5614 
        iprot.skip(ftype)
5615 
      iprot.readFieldEnd()
5616 
    iprot.readStructEnd()
5617 
 
5618 
  def write(self, oprot):
5619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5621 
      return
5326 rajveer 5622 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5623 
    if self.user is not None:
559 chandransh 5624 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5625 
      self.user.write(oprot)
94 ashish 5626 
      oprot.writeFieldEnd()
5627 
    oprot.writeFieldStop()
5628 
    oprot.writeStructEnd()
5629 
 
3431 rajveer 5630 
  def validate(self):
5631 
    return
5632 
 
5633 
 
94 ashish 5634 
  def __repr__(self):
5635 
    L = ['%s=%r' % (key, value)
5636 
      for key, value in self.__dict__.iteritems()]
5637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5638 
 
5639 
  def __eq__(self, other):
5640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5641 
 
5642 
  def __ne__(self, other):
5643 
    return not (self == other)
5644 
 
5326 rajveer 5645 
class createUser_result:
94 ashish 5646 
  """
5647 
  Attributes:
5648 
   - success
559 chandransh 5649 
   - ucex
94 ashish 5650 
  """
5651 
 
5652 
  thrift_spec = (
559 chandransh 5653 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5654 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5655 
  )
5656 
 
559 chandransh 5657 
  def __init__(self, success=None, ucex=None,):
94 ashish 5658 
    self.success = success
559 chandransh 5659 
    self.ucex = ucex
94 ashish 5660 
 
5661 
  def read(self, iprot):
5662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5664 
      return
5665 
    iprot.readStructBegin()
5666 
    while True:
5667 
      (fname, ftype, fid) = iprot.readFieldBegin()
5668 
      if ftype == TType.STOP:
5669 
        break
5670 
      if fid == 0:
5671 
        if ftype == TType.STRUCT:
559 chandransh 5672 
          self.success = User()
94 ashish 5673 
          self.success.read(iprot)
5674 
        else:
5675 
          iprot.skip(ftype)
5676 
      elif fid == 1:
5677 
        if ftype == TType.STRUCT:
559 chandransh 5678 
          self.ucex = UserContextException()
5679 
          self.ucex.read(iprot)
94 ashish 5680 
        else:
5681 
          iprot.skip(ftype)
5682 
      else:
5683 
        iprot.skip(ftype)
5684 
      iprot.readFieldEnd()
5685 
    iprot.readStructEnd()
5686 
 
5687 
  def write(self, oprot):
5688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5690 
      return
5326 rajveer 5691 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5692 
    if self.success is not None:
94 ashish 5693 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5694 
      self.success.write(oprot)
5695 
      oprot.writeFieldEnd()
3431 rajveer 5696 
    if self.ucex is not None:
559 chandransh 5697 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5698 
      self.ucex.write(oprot)
94 ashish 5699 
      oprot.writeFieldEnd()
5700 
    oprot.writeFieldStop()
5701 
    oprot.writeStructEnd()
5702 
 
3431 rajveer 5703 
  def validate(self):
5704 
    return
5705 
 
5706 
 
94 ashish 5707 
  def __repr__(self):
5708 
    L = ['%s=%r' % (key, value)
5709 
      for key, value in self.__dict__.iteritems()]
5710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5711 
 
5712 
  def __eq__(self, other):
5713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5714 
 
5715 
  def __ne__(self, other):
5716 
    return not (self == other)
5717 
 
5326 rajveer 5718 
class updateUser_args:
94 ashish 5719 
  """
5720 
  Attributes:
5326 rajveer 5721 
   - user
94 ashish 5722 
  """
5723 
 
5724 
  thrift_spec = (
5725 
    None, # 0
5326 rajveer 5726 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5727 
  )
5728 
 
5326 rajveer 5729 
  def __init__(self, user=None,):
5730 
    self.user = user
94 ashish 5731 
 
5732 
  def read(self, iprot):
5733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5735 
      return
5736 
    iprot.readStructBegin()
5737 
    while True:
5738 
      (fname, ftype, fid) = iprot.readFieldBegin()
5739 
      if ftype == TType.STOP:
5740 
        break
5741 
      if fid == 1:
5326 rajveer 5742 
        if ftype == TType.STRUCT:
5743 
          self.user = User()
5744 
          self.user.read(iprot)
94 ashish 5745 
        else:
5746 
          iprot.skip(ftype)
5747 
      else:
5748 
        iprot.skip(ftype)
5749 
      iprot.readFieldEnd()
5750 
    iprot.readStructEnd()
5751 
 
5752 
  def write(self, oprot):
5753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5755 
      return
5326 rajveer 5756 
    oprot.writeStructBegin('updateUser_args')
5757 
    if self.user is not None:
5758 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5759 
      self.user.write(oprot)
94 ashish 5760 
      oprot.writeFieldEnd()
5761 
    oprot.writeFieldStop()
5762 
    oprot.writeStructEnd()
5763 
 
3431 rajveer 5764 
  def validate(self):
5765 
    return
5766 
 
5767 
 
94 ashish 5768 
  def __repr__(self):
5769 
    L = ['%s=%r' % (key, value)
5770 
      for key, value in self.__dict__.iteritems()]
5771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5772 
 
5773 
  def __eq__(self, other):
5774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5775 
 
5776 
  def __ne__(self, other):
5777 
    return not (self == other)
5778 
 
5326 rajveer 5779 
class updateUser_result:
94 ashish 5780 
  """
5781 
  Attributes:
5782 
   - success
559 chandransh 5783 
   - ucex
94 ashish 5784 
  """
5785 
 
5786 
  thrift_spec = (
5326 rajveer 5787 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5788 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5789 
  )
5790 
 
559 chandransh 5791 
  def __init__(self, success=None, ucex=None,):
94 ashish 5792 
    self.success = success
559 chandransh 5793 
    self.ucex = ucex
94 ashish 5794 
 
5795 
  def read(self, iprot):
5796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5798 
      return
5799 
    iprot.readStructBegin()
5800 
    while True:
5801 
      (fname, ftype, fid) = iprot.readFieldBegin()
5802 
      if ftype == TType.STOP:
5803 
        break
5804 
      if fid == 0:
5326 rajveer 5805 
        if ftype == TType.STRUCT:
5806 
          self.success = User()
5807 
          self.success.read(iprot)
94 ashish 5808 
        else:
5809 
          iprot.skip(ftype)
5810 
      elif fid == 1:
5811 
        if ftype == TType.STRUCT:
559 chandransh 5812 
          self.ucex = UserContextException()
5813 
          self.ucex.read(iprot)
94 ashish 5814 
        else:
5815 
          iprot.skip(ftype)
5816 
      else:
5817 
        iprot.skip(ftype)
5818 
      iprot.readFieldEnd()
5819 
    iprot.readStructEnd()
5820 
 
5821 
  def write(self, oprot):
5822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5824 
      return
5326 rajveer 5825 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5826 
    if self.success is not None:
5326 rajveer 5827 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5828 
      self.success.write(oprot)
94 ashish 5829 
      oprot.writeFieldEnd()
3431 rajveer 5830 
    if self.ucex is not None:
559 chandransh 5831 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5832 
      self.ucex.write(oprot)
94 ashish 5833 
      oprot.writeFieldEnd()
5834 
    oprot.writeFieldStop()
5835 
    oprot.writeStructEnd()
5836 
 
3431 rajveer 5837 
  def validate(self):
5838 
    return
5839 
 
5840 
 
94 ashish 5841 
  def __repr__(self):
5842 
    L = ['%s=%r' % (key, value)
5843 
      for key, value in self.__dict__.iteritems()]
5844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5845 
 
5846 
  def __eq__(self, other):
5847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5848 
 
5849 
  def __ne__(self, other):
5850 
    return not (self == other)
5851 
 
559 chandransh 5852 
class authenticateUser_args:
94 ashish 5853 
  """
5854 
  Attributes:
5855 
   - email
5856 
   - password
5857 
  """
5858 
 
5859 
  thrift_spec = (
5860 
    None, # 0
5861 
    (1, TType.STRING, 'email', None, None, ), # 1
5862 
    (2, TType.STRING, 'password', None, None, ), # 2
5863 
  )
5864 
 
5865 
  def __init__(self, email=None, password=None,):
5866 
    self.email = email
5867 
    self.password = password
5868 
 
5869 
  def read(self, iprot):
5870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5872 
      return
5873 
    iprot.readStructBegin()
5874 
    while True:
5875 
      (fname, ftype, fid) = iprot.readFieldBegin()
5876 
      if ftype == TType.STOP:
5877 
        break
5878 
      if fid == 1:
5879 
        if ftype == TType.STRING:
5880 
          self.email = iprot.readString();
5881 
        else:
5882 
          iprot.skip(ftype)
5883 
      elif fid == 2:
5884 
        if ftype == TType.STRING:
5885 
          self.password = iprot.readString();
5886 
        else:
5887 
          iprot.skip(ftype)
5888 
      else:
5889 
        iprot.skip(ftype)
5890 
      iprot.readFieldEnd()
5891 
    iprot.readStructEnd()
5892 
 
5893 
  def write(self, oprot):
5894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5896 
      return
559 chandransh 5897 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5898 
    if self.email is not None:
94 ashish 5899 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5900 
      oprot.writeString(self.email)
5901 
      oprot.writeFieldEnd()
3431 rajveer 5902 
    if self.password is not None:
94 ashish 5903 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5904 
      oprot.writeString(self.password)
5905 
      oprot.writeFieldEnd()
5906 
    oprot.writeFieldStop()
5907 
    oprot.writeStructEnd()
5908 
 
3431 rajveer 5909 
  def validate(self):
5910 
    return
5911 
 
5912 
 
94 ashish 5913 
  def __repr__(self):
5914 
    L = ['%s=%r' % (key, value)
5915 
      for key, value in self.__dict__.iteritems()]
5916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5917 
 
5918 
  def __eq__(self, other):
5919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5920 
 
5921 
  def __ne__(self, other):
5922 
    return not (self == other)
5923 
 
559 chandransh 5924 
class authenticateUser_result:
94 ashish 5925 
  """
5926 
  Attributes:
5927 
   - success
559 chandransh 5928 
   - auex
94 ashish 5929 
  """
5930 
 
5931 
  thrift_spec = (
559 chandransh 5932 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5933 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5934 
  )
5935 
 
559 chandransh 5936 
  def __init__(self, success=None, auex=None,):
94 ashish 5937 
    self.success = success
559 chandransh 5938 
    self.auex = auex
94 ashish 5939 
 
5940 
  def read(self, iprot):
5941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5943 
      return
5944 
    iprot.readStructBegin()
5945 
    while True:
5946 
      (fname, ftype, fid) = iprot.readFieldBegin()
5947 
      if ftype == TType.STOP:
5948 
        break
5949 
      if fid == 0:
5950 
        if ftype == TType.STRUCT:
559 chandransh 5951 
          self.success = User()
94 ashish 5952 
          self.success.read(iprot)
5953 
        else:
5954 
          iprot.skip(ftype)
5955 
      elif fid == 1:
5956 
        if ftype == TType.STRUCT:
559 chandransh 5957 
          self.auex = AuthenticationException()
5958 
          self.auex.read(iprot)
94 ashish 5959 
        else:
5960 
          iprot.skip(ftype)
5961 
      else:
5962 
        iprot.skip(ftype)
5963 
      iprot.readFieldEnd()
5964 
    iprot.readStructEnd()
5965 
 
5966 
  def write(self, oprot):
5967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5969 
      return
559 chandransh 5970 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5971 
    if self.success is not None:
94 ashish 5972 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5973 
      self.success.write(oprot)
5974 
      oprot.writeFieldEnd()
3431 rajveer 5975 
    if self.auex is not None:
559 chandransh 5976 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5977 
      self.auex.write(oprot)
94 ashish 5978 
      oprot.writeFieldEnd()
5979 
    oprot.writeFieldStop()
5980 
    oprot.writeStructEnd()
5981 
 
3431 rajveer 5982 
  def validate(self):
5983 
    return
5984 
 
5985 
 
94 ashish 5986 
  def __repr__(self):
5987 
    L = ['%s=%r' % (key, value)
5988 
      for key, value in self.__dict__.iteritems()]
5989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5990 
 
5991 
  def __eq__(self, other):
5992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5993 
 
5994 
  def __ne__(self, other):
5995 
    return not (self == other)
5996 
 
559 chandransh 5997 
class userExists_args:
122 ashish 5998 
  """
5999 
  Attributes:
559 chandransh 6000 
   - email
122 ashish 6001 
  """
6002 
 
6003 
  thrift_spec = (
6004 
    None, # 0
559 chandransh 6005 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6006 
  )
6007 
 
559 chandransh 6008 
  def __init__(self, email=None,):
6009 
    self.email = email
122 ashish 6010 
 
6011 
  def read(self, iprot):
6012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6014 
      return
6015 
    iprot.readStructBegin()
6016 
    while True:
6017 
      (fname, ftype, fid) = iprot.readFieldBegin()
6018 
      if ftype == TType.STOP:
6019 
        break
6020 
      if fid == 1:
6021 
        if ftype == TType.STRING:
559 chandransh 6022 
          self.email = iprot.readString();
122 ashish 6023 
        else:
6024 
          iprot.skip(ftype)
559 chandransh 6025 
      else:
6026 
        iprot.skip(ftype)
6027 
      iprot.readFieldEnd()
6028 
    iprot.readStructEnd()
6029 
 
6030 
  def write(self, oprot):
6031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6033 
      return
6034 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6035 
    if self.email is not None:
559 chandransh 6036 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6037 
      oprot.writeString(self.email)
6038 
      oprot.writeFieldEnd()
6039 
    oprot.writeFieldStop()
6040 
    oprot.writeStructEnd()
6041 
 
3431 rajveer 6042 
  def validate(self):
6043 
    return
6044 
 
6045 
 
559 chandransh 6046 
  def __repr__(self):
6047 
    L = ['%s=%r' % (key, value)
6048 
      for key, value in self.__dict__.iteritems()]
6049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6050 
 
6051 
  def __eq__(self, other):
6052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6053 
 
6054 
  def __ne__(self, other):
6055 
    return not (self == other)
6056 
 
6057 
class userExists_result:
6058 
  """
6059 
  Attributes:
6060 
   - success
6061 
   - ucx
6062 
  """
6063 
 
6064 
  thrift_spec = (
6065 
    (0, TType.BOOL, 'success', None, None, ), # 0
6066 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6067 
  )
6068 
 
6069 
  def __init__(self, success=None, ucx=None,):
6070 
    self.success = success
6071 
    self.ucx = ucx
6072 
 
6073 
  def read(self, iprot):
6074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6076 
      return
6077 
    iprot.readStructBegin()
6078 
    while True:
6079 
      (fname, ftype, fid) = iprot.readFieldBegin()
6080 
      if ftype == TType.STOP:
6081 
        break
6082 
      if fid == 0:
6083 
        if ftype == TType.BOOL:
6084 
          self.success = iprot.readBool();
6085 
        else:
6086 
          iprot.skip(ftype)
6087 
      elif fid == 1:
6088 
        if ftype == TType.STRUCT:
6089 
          self.ucx = UserContextException()
6090 
          self.ucx.read(iprot)
6091 
        else:
6092 
          iprot.skip(ftype)
6093 
      else:
6094 
        iprot.skip(ftype)
6095 
      iprot.readFieldEnd()
6096 
    iprot.readStructEnd()
6097 
 
6098 
  def write(self, oprot):
6099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6101 
      return
6102 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6103 
    if self.success is not None:
559 chandransh 6104 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6105 
      oprot.writeBool(self.success)
6106 
      oprot.writeFieldEnd()
3431 rajveer 6107 
    if self.ucx is not None:
559 chandransh 6108 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6109 
      self.ucx.write(oprot)
6110 
      oprot.writeFieldEnd()
6111 
    oprot.writeFieldStop()
6112 
    oprot.writeStructEnd()
6113 
 
3431 rajveer 6114 
  def validate(self):
6115 
    return
6116 
 
6117 
 
559 chandransh 6118 
  def __repr__(self):
6119 
    L = ['%s=%r' % (key, value)
6120 
      for key, value in self.__dict__.iteritems()]
6121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6122 
 
6123 
  def __eq__(self, other):
6124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6125 
 
6126 
  def __ne__(self, other):
6127 
    return not (self == other)
6128 
 
6129 
class addAddressForUser_args:
6130 
  """
6131 
  Attributes:
6132 
   - userId
6133 
   - address
6134 
   - setDefault
6135 
  """
6136 
 
6137 
  thrift_spec = (
6138 
    None, # 0
6139 
    (1, TType.I64, 'userId', None, None, ), # 1
6140 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6141 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6142 
  )
6143 
 
567 rajveer 6144 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6145 
    self.userId = userId
6146 
    self.address = address
6147 
    self.setDefault = setDefault
6148 
 
6149 
  def read(self, iprot):
6150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6152 
      return
6153 
    iprot.readStructBegin()
6154 
    while True:
6155 
      (fname, ftype, fid) = iprot.readFieldBegin()
6156 
      if ftype == TType.STOP:
6157 
        break
6158 
      if fid == 1:
6159 
        if ftype == TType.I64:
6160 
          self.userId = iprot.readI64();
6161 
        else:
6162 
          iprot.skip(ftype)
122 ashish 6163 
      elif fid == 2:
559 chandransh 6164 
        if ftype == TType.STRUCT:
6165 
          self.address = Address()
6166 
          self.address.read(iprot)
122 ashish 6167 
        else:
6168 
          iprot.skip(ftype)
6169 
      elif fid == 3:
6170 
        if ftype == TType.BOOL:
559 chandransh 6171 
          self.setDefault = iprot.readBool();
122 ashish 6172 
        else:
6173 
          iprot.skip(ftype)
6174 
      else:
6175 
        iprot.skip(ftype)
6176 
      iprot.readFieldEnd()
6177 
    iprot.readStructEnd()
6178 
 
6179 
  def write(self, oprot):
6180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6182 
      return
559 chandransh 6183 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6184 
    if self.userId is not None:
559 chandransh 6185 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6186 
      oprot.writeI64(self.userId)
122 ashish 6187 
      oprot.writeFieldEnd()
3431 rajveer 6188 
    if self.address is not None:
559 chandransh 6189 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6190 
      self.address.write(oprot)
122 ashish 6191 
      oprot.writeFieldEnd()
3431 rajveer 6192 
    if self.setDefault is not None:
567 rajveer 6193 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6194 
      oprot.writeBool(self.setDefault)
6195 
      oprot.writeFieldEnd()
122 ashish 6196 
    oprot.writeFieldStop()
6197 
    oprot.writeStructEnd()
6198 
 
3431 rajveer 6199 
  def validate(self):
6200 
    return
6201 
 
6202 
 
122 ashish 6203 
  def __repr__(self):
6204 
    L = ['%s=%r' % (key, value)
6205 
      for key, value in self.__dict__.iteritems()]
6206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6207 
 
6208 
  def __eq__(self, other):
6209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6210 
 
6211 
  def __ne__(self, other):
6212 
    return not (self == other)
6213 
 
559 chandransh 6214 
class addAddressForUser_result:
122 ashish 6215 
  """
6216 
  Attributes:
6217 
   - success
559 chandransh 6218 
   - ucx
122 ashish 6219 
  """
6220 
 
6221 
  thrift_spec = (
567 rajveer 6222 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6223 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6224 
  )
6225 
 
559 chandransh 6226 
  def __init__(self, success=None, ucx=None,):
122 ashish 6227 
    self.success = success
559 chandransh 6228 
    self.ucx = ucx
122 ashish 6229 
 
6230 
  def read(self, iprot):
6231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6233 
      return
6234 
    iprot.readStructBegin()
6235 
    while True:
6236 
      (fname, ftype, fid) = iprot.readFieldBegin()
6237 
      if ftype == TType.STOP:
6238 
        break
6239 
      if fid == 0:
567 rajveer 6240 
        if ftype == TType.I64:
6241 
          self.success = iprot.readI64();
122 ashish 6242 
        else:
6243 
          iprot.skip(ftype)
6244 
      elif fid == 1:
6245 
        if ftype == TType.STRUCT:
559 chandransh 6246 
          self.ucx = UserContextException()
6247 
          self.ucx.read(iprot)
122 ashish 6248 
        else:
6249 
          iprot.skip(ftype)
6250 
      else:
6251 
        iprot.skip(ftype)
6252 
      iprot.readFieldEnd()
6253 
    iprot.readStructEnd()
6254 
 
6255 
  def write(self, oprot):
6256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6258 
      return
559 chandransh 6259 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6260 
    if self.success is not None:
567 rajveer 6261 
      oprot.writeFieldBegin('success', TType.I64, 0)
6262 
      oprot.writeI64(self.success)
122 ashish 6263 
      oprot.writeFieldEnd()
3431 rajveer 6264 
    if self.ucx is not None:
559 chandransh 6265 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6266 
      self.ucx.write(oprot)
122 ashish 6267 
      oprot.writeFieldEnd()
6268 
    oprot.writeFieldStop()
6269 
    oprot.writeStructEnd()
6270 
 
3431 rajveer 6271 
  def validate(self):
6272 
    return
6273 
 
6274 
 
122 ashish 6275 
  def __repr__(self):
6276 
    L = ['%s=%r' % (key, value)
6277 
      for key, value in self.__dict__.iteritems()]
6278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6279 
 
6280 
  def __eq__(self, other):
6281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6282 
 
6283 
  def __ne__(self, other):
6284 
    return not (self == other)
6285 
 
559 chandransh 6286 
class removeAddressForUser_args:
94 ashish 6287 
  """
6288 
  Attributes:
559 chandransh 6289 
   - userid
6290 
   - addressId
94 ashish 6291 
  """
6292 
 
6293 
  thrift_spec = (
6294 
    None, # 0
559 chandransh 6295 
    (1, TType.I64, 'userid', None, None, ), # 1
6296 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6297 
  )
6298 
 
559 chandransh 6299 
  def __init__(self, userid=None, addressId=None,):
6300 
    self.userid = userid
6301 
    self.addressId = addressId
94 ashish 6302 
 
6303 
  def read(self, iprot):
6304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6306 
      return
6307 
    iprot.readStructBegin()
6308 
    while True:
6309 
      (fname, ftype, fid) = iprot.readFieldBegin()
6310 
      if ftype == TType.STOP:
6311 
        break
6312 
      if fid == 1:
559 chandransh 6313 
        if ftype == TType.I64:
6314 
          self.userid = iprot.readI64();
94 ashish 6315 
        else:
6316 
          iprot.skip(ftype)
559 chandransh 6317 
      elif fid == 2:
6318 
        if ftype == TType.I64:
6319 
          self.addressId = iprot.readI64();
6320 
        else:
6321 
          iprot.skip(ftype)
94 ashish 6322 
      else:
6323 
        iprot.skip(ftype)
6324 
      iprot.readFieldEnd()
6325 
    iprot.readStructEnd()
6326 
 
6327 
  def write(self, oprot):
6328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6330 
      return
559 chandransh 6331 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6332 
    if self.userid is not None:
559 chandransh 6333 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6334 
      oprot.writeI64(self.userid)
94 ashish 6335 
      oprot.writeFieldEnd()
3431 rajveer 6336 
    if self.addressId is not None:
559 chandransh 6337 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6338 
      oprot.writeI64(self.addressId)
6339 
      oprot.writeFieldEnd()
94 ashish 6340 
    oprot.writeFieldStop()
6341 
    oprot.writeStructEnd()
6342 
 
3431 rajveer 6343 
  def validate(self):
6344 
    return
6345 
 
6346 
 
94 ashish 6347 
  def __repr__(self):
6348 
    L = ['%s=%r' % (key, value)
6349 
      for key, value in self.__dict__.iteritems()]
6350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6351 
 
6352 
  def __eq__(self, other):
6353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6354 
 
6355 
  def __ne__(self, other):
6356 
    return not (self == other)
6357 
 
559 chandransh 6358 
class removeAddressForUser_result:
94 ashish 6359 
  """
6360 
  Attributes:
6361 
   - success
6362 
   - ucx
6363 
  """
6364 
 
6365 
  thrift_spec = (
6366 
    (0, TType.BOOL, 'success', None, None, ), # 0
6367 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6368 
  )
6369 
 
6370 
  def __init__(self, success=None, ucx=None,):
6371 
    self.success = success
6372 
    self.ucx = ucx
6373 
 
6374 
  def read(self, iprot):
6375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6377 
      return
6378 
    iprot.readStructBegin()
6379 
    while True:
6380 
      (fname, ftype, fid) = iprot.readFieldBegin()
6381 
      if ftype == TType.STOP:
6382 
        break
6383 
      if fid == 0:
6384 
        if ftype == TType.BOOL:
6385 
          self.success = iprot.readBool();
6386 
        else:
6387 
          iprot.skip(ftype)
6388 
      elif fid == 1:
6389 
        if ftype == TType.STRUCT:
6390 
          self.ucx = UserContextException()
6391 
          self.ucx.read(iprot)
6392 
        else:
6393 
          iprot.skip(ftype)
6394 
      else:
6395 
        iprot.skip(ftype)
6396 
      iprot.readFieldEnd()
6397 
    iprot.readStructEnd()
6398 
 
6399 
  def write(self, oprot):
6400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6402 
      return
559 chandransh 6403 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6404 
    if self.success is not None:
94 ashish 6405 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6406 
      oprot.writeBool(self.success)
6407 
      oprot.writeFieldEnd()
3431 rajveer 6408 
    if self.ucx is not None:
94 ashish 6409 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6410 
      self.ucx.write(oprot)
6411 
      oprot.writeFieldEnd()
6412 
    oprot.writeFieldStop()
6413 
    oprot.writeStructEnd()
6414 
 
3431 rajveer 6415 
  def validate(self):
6416 
    return
6417 
 
6418 
 
94 ashish 6419 
  def __repr__(self):
6420 
    L = ['%s=%r' % (key, value)
6421 
      for key, value in self.__dict__.iteritems()]
6422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6423 
 
6424 
  def __eq__(self, other):
6425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6426 
 
6427 
  def __ne__(self, other):
6428 
    return not (self == other)
6429 
 
559 chandransh 6430 
class setUserAsLoggedIn_args:
94 ashish 6431 
  """
6432 
  Attributes:
559 chandransh 6433 
   - userId
94 ashish 6434 
   - timestamp
6435 
  """
6436 
 
6437 
  thrift_spec = (
6438 
    None, # 0
559 chandransh 6439 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6440 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6441 
  )
6442 
 
559 chandransh 6443 
  def __init__(self, userId=None, timestamp=None,):
6444 
    self.userId = userId
94 ashish 6445 
    self.timestamp = timestamp
6446 
 
6447 
  def read(self, iprot):
6448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6450 
      return
6451 
    iprot.readStructBegin()
6452 
    while True:
6453 
      (fname, ftype, fid) = iprot.readFieldBegin()
6454 
      if ftype == TType.STOP:
6455 
        break
6456 
      if fid == 1:
559 chandransh 6457 
        if ftype == TType.I64:
6458 
          self.userId = iprot.readI64();
94 ashish 6459 
        else:
6460 
          iprot.skip(ftype)
6461 
      elif fid == 2:
6462 
        if ftype == TType.I64:
6463 
          self.timestamp = iprot.readI64();
6464 
        else:
6465 
          iprot.skip(ftype)
6466 
      else:
6467 
        iprot.skip(ftype)
6468 
      iprot.readFieldEnd()
6469 
    iprot.readStructEnd()
6470 
 
6471 
  def write(self, oprot):
6472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6474 
      return
559 chandransh 6475 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6476 
    if self.userId is not None:
559 chandransh 6477 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6478 
      oprot.writeI64(self.userId)
94 ashish 6479 
      oprot.writeFieldEnd()
3431 rajveer 6480 
    if self.timestamp is not None:
94 ashish 6481 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6482 
      oprot.writeI64(self.timestamp)
6483 
      oprot.writeFieldEnd()
6484 
    oprot.writeFieldStop()
6485 
    oprot.writeStructEnd()
6486 
 
3431 rajveer 6487 
  def validate(self):
6488 
    return
6489 
 
6490 
 
94 ashish 6491 
  def __repr__(self):
6492 
    L = ['%s=%r' % (key, value)
6493 
      for key, value in self.__dict__.iteritems()]
6494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6495 
 
6496 
  def __eq__(self, other):
6497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6498 
 
6499 
  def __ne__(self, other):
6500 
    return not (self == other)
6501 
 
559 chandransh 6502 
class setUserAsLoggedIn_result:
94 ashish 6503 
  """
6504 
  Attributes:
6505 
   - success
6506 
   - ucx
6507 
  """
6508 
 
6509 
  thrift_spec = (
6510 
    (0, TType.BOOL, 'success', None, None, ), # 0
6511 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6512 
  )
6513 
 
6514 
  def __init__(self, success=None, ucx=None,):
6515 
    self.success = success
6516 
    self.ucx = ucx
6517 
 
6518 
  def read(self, iprot):
6519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6521 
      return
6522 
    iprot.readStructBegin()
6523 
    while True:
6524 
      (fname, ftype, fid) = iprot.readFieldBegin()
6525 
      if ftype == TType.STOP:
6526 
        break
6527 
      if fid == 0:
6528 
        if ftype == TType.BOOL:
6529 
          self.success = iprot.readBool();
6530 
        else:
6531 
          iprot.skip(ftype)
6532 
      elif fid == 1:
6533 
        if ftype == TType.STRUCT:
6534 
          self.ucx = UserContextException()
6535 
          self.ucx.read(iprot)
6536 
        else:
6537 
          iprot.skip(ftype)
6538 
      else:
6539 
        iprot.skip(ftype)
6540 
      iprot.readFieldEnd()
6541 
    iprot.readStructEnd()
6542 
 
6543 
  def write(self, oprot):
6544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6546 
      return
559 chandransh 6547 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6548 
    if self.success is not None:
94 ashish 6549 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6550 
      oprot.writeBool(self.success)
6551 
      oprot.writeFieldEnd()
3431 rajveer 6552 
    if self.ucx is not None:
94 ashish 6553 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6554 
      self.ucx.write(oprot)
6555 
      oprot.writeFieldEnd()
6556 
    oprot.writeFieldStop()
6557 
    oprot.writeStructEnd()
6558 
 
3431 rajveer 6559 
  def validate(self):
6560 
    return
6561 
 
6562 
 
94 ashish 6563 
  def __repr__(self):
6564 
    L = ['%s=%r' % (key, value)
6565 
      for key, value in self.__dict__.iteritems()]
6566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6567 
 
6568 
  def __eq__(self, other):
6569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6570 
 
6571 
  def __ne__(self, other):
6572 
    return not (self == other)
6573 
 
559 chandransh 6574 
class setUserAsLoggedOut_args:
94 ashish 6575 
  """
6576 
  Attributes:
6577 
   - userid
6578 
   - timestamp
6579 
  """
6580 
 
6581 
  thrift_spec = (
6582 
    None, # 0
559 chandransh 6583 
    (1, TType.I64, 'userid', None, None, ), # 1
6584 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6585 
  )
6586 
 
559 chandransh 6587 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6588 
    self.userid = userid
6589 
    self.timestamp = timestamp
6590 
 
6591 
  def read(self, iprot):
6592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6594 
      return
6595 
    iprot.readStructBegin()
6596 
    while True:
6597 
      (fname, ftype, fid) = iprot.readFieldBegin()
6598 
      if ftype == TType.STOP:
6599 
        break
6600 
      if fid == 1:
6601 
        if ftype == TType.I64:
6602 
          self.userid = iprot.readI64();
6603 
        else:
6604 
          iprot.skip(ftype)
559 chandransh 6605 
      elif fid == 2:
94 ashish 6606 
        if ftype == TType.I64:
6607 
          self.timestamp = iprot.readI64();
6608 
        else:
6609 
          iprot.skip(ftype)
6610 
      else:
6611 
        iprot.skip(ftype)
6612 
      iprot.readFieldEnd()
6613 
    iprot.readStructEnd()
6614 
 
6615 
  def write(self, oprot):
6616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6618 
      return
559 chandransh 6619 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6620 
    if self.userid is not None:
559 chandransh 6621 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6622 
      oprot.writeI64(self.userid)
6623 
      oprot.writeFieldEnd()
3431 rajveer 6624 
    if self.timestamp is not None:
559 chandransh 6625 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6626 
      oprot.writeI64(self.timestamp)
6627 
      oprot.writeFieldEnd()
6628 
    oprot.writeFieldStop()
6629 
    oprot.writeStructEnd()
6630 
 
3431 rajveer 6631 
  def validate(self):
6632 
    return
6633 
 
6634 
 
94 ashish 6635 
  def __repr__(self):
6636 
    L = ['%s=%r' % (key, value)
6637 
      for key, value in self.__dict__.iteritems()]
6638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6639 
 
6640 
  def __eq__(self, other):
6641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6642 
 
6643 
  def __ne__(self, other):
6644 
    return not (self == other)
6645 
 
559 chandransh 6646 
class setUserAsLoggedOut_result:
94 ashish 6647 
  """
6648 
  Attributes:
6649 
   - success
6650 
   - ucx
6651 
  """
6652 
 
6653 
  thrift_spec = (
6654 
    (0, TType.BOOL, 'success', None, None, ), # 0
6655 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6656 
  )
6657 
 
6658 
  def __init__(self, success=None, ucx=None,):
6659 
    self.success = success
6660 
    self.ucx = ucx
6661 
 
6662 
  def read(self, iprot):
6663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6665 
      return
6666 
    iprot.readStructBegin()
6667 
    while True:
6668 
      (fname, ftype, fid) = iprot.readFieldBegin()
6669 
      if ftype == TType.STOP:
6670 
        break
6671 
      if fid == 0:
6672 
        if ftype == TType.BOOL:
6673 
          self.success = iprot.readBool();
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      elif fid == 1:
6677 
        if ftype == TType.STRUCT:
6678 
          self.ucx = UserContextException()
6679 
          self.ucx.read(iprot)
6680 
        else:
6681 
          iprot.skip(ftype)
6682 
      else:
6683 
        iprot.skip(ftype)
6684 
      iprot.readFieldEnd()
6685 
    iprot.readStructEnd()
6686 
 
6687 
  def write(self, oprot):
6688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6690 
      return
559 chandransh 6691 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6692 
    if self.success is not None:
94 ashish 6693 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6694 
      oprot.writeBool(self.success)
6695 
      oprot.writeFieldEnd()
3431 rajveer 6696 
    if self.ucx is not None:
94 ashish 6697 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6698 
      self.ucx.write(oprot)
6699 
      oprot.writeFieldEnd()
6700 
    oprot.writeFieldStop()
6701 
    oprot.writeStructEnd()
6702 
 
3431 rajveer 6703 
  def validate(self):
6704 
    return
6705 
 
6706 
 
94 ashish 6707 
  def __repr__(self):
6708 
    L = ['%s=%r' % (key, value)
6709 
      for key, value in self.__dict__.iteritems()]
6710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6711 
 
6712 
  def __eq__(self, other):
6713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6714 
 
6715 
  def __ne__(self, other):
6716 
    return not (self == other)
6717 
 
559 chandransh 6718 
class setDefaultAddress_args:
94 ashish 6719 
  """
6720 
  Attributes:
6721 
   - userid
6722 
   - addressId
6723 
  """
6724 
 
6725 
  thrift_spec = (
6726 
    None, # 0
6727 
    (1, TType.I64, 'userid', None, None, ), # 1
6728 
    (2, TType.I64, 'addressId', None, None, ), # 2
6729 
  )
6730 
 
6731 
  def __init__(self, userid=None, addressId=None,):
6732 
    self.userid = userid
6733 
    self.addressId = addressId
6734 
 
6735 
  def read(self, iprot):
6736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6738 
      return
6739 
    iprot.readStructBegin()
6740 
    while True:
6741 
      (fname, ftype, fid) = iprot.readFieldBegin()
6742 
      if ftype == TType.STOP:
6743 
        break
6744 
      if fid == 1:
6745 
        if ftype == TType.I64:
6746 
          self.userid = iprot.readI64();
6747 
        else:
6748 
          iprot.skip(ftype)
6749 
      elif fid == 2:
6750 
        if ftype == TType.I64:
6751 
          self.addressId = iprot.readI64();
6752 
        else:
6753 
          iprot.skip(ftype)
6754 
      else:
6755 
        iprot.skip(ftype)
6756 
      iprot.readFieldEnd()
6757 
    iprot.readStructEnd()
6758 
 
6759 
  def write(self, oprot):
6760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6762 
      return
559 chandransh 6763 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6764 
    if self.userid is not None:
94 ashish 6765 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6766 
      oprot.writeI64(self.userid)
6767 
      oprot.writeFieldEnd()
3431 rajveer 6768 
    if self.addressId is not None:
94 ashish 6769 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6770 
      oprot.writeI64(self.addressId)
6771 
      oprot.writeFieldEnd()
6772 
    oprot.writeFieldStop()
6773 
    oprot.writeStructEnd()
6774 
 
3431 rajveer 6775 
  def validate(self):
6776 
    return
6777 
 
6778 
 
94 ashish 6779 
  def __repr__(self):
6780 
    L = ['%s=%r' % (key, value)
6781 
      for key, value in self.__dict__.iteritems()]
6782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6783 
 
6784 
  def __eq__(self, other):
6785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6786 
 
6787 
  def __ne__(self, other):
6788 
    return not (self == other)
6789 
 
559 chandransh 6790 
class setDefaultAddress_result:
94 ashish 6791 
  """
6792 
  Attributes:
6793 
   - success
6794 
   - ucx
6795 
  """
6796 
 
6797 
  thrift_spec = (
6798 
    (0, TType.BOOL, 'success', None, None, ), # 0
6799 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6800 
  )
6801 
 
6802 
  def __init__(self, success=None, ucx=None,):
6803 
    self.success = success
6804 
    self.ucx = ucx
6805 
 
6806 
  def read(self, iprot):
6807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6809 
      return
6810 
    iprot.readStructBegin()
6811 
    while True:
6812 
      (fname, ftype, fid) = iprot.readFieldBegin()
6813 
      if ftype == TType.STOP:
6814 
        break
6815 
      if fid == 0:
6816 
        if ftype == TType.BOOL:
6817 
          self.success = iprot.readBool();
6818 
        else:
6819 
          iprot.skip(ftype)
6820 
      elif fid == 1:
6821 
        if ftype == TType.STRUCT:
6822 
          self.ucx = UserContextException()
6823 
          self.ucx.read(iprot)
6824 
        else:
6825 
          iprot.skip(ftype)
6826 
      else:
6827 
        iprot.skip(ftype)
6828 
      iprot.readFieldEnd()
6829 
    iprot.readStructEnd()
6830 
 
6831 
  def write(self, oprot):
6832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6834 
      return
559 chandransh 6835 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6836 
    if self.success is not None:
94 ashish 6837 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6838 
      oprot.writeBool(self.success)
6839 
      oprot.writeFieldEnd()
3431 rajveer 6840 
    if self.ucx is not None:
94 ashish 6841 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6842 
      self.ucx.write(oprot)
6843 
      oprot.writeFieldEnd()
6844 
    oprot.writeFieldStop()
6845 
    oprot.writeStructEnd()
6846 
 
3431 rajveer 6847 
  def validate(self):
6848 
    return
6849 
 
6850 
 
94 ashish 6851 
  def __repr__(self):
6852 
    L = ['%s=%r' % (key, value)
6853 
      for key, value in self.__dict__.iteritems()]
6854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6855 
 
6856 
  def __eq__(self, other):
6857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6858 
 
6859 
  def __ne__(self, other):
6860 
    return not (self == other)
6861 
 
559 chandransh 6862 
class updatePassword_args:
94 ashish 6863 
  """
6864 
  Attributes:
559 chandransh 6865 
   - userid
594 rajveer 6866 
   - oldPassword
6867 
   - newPassword
94 ashish 6868 
  """
6869 
 
6870 
  thrift_spec = (
6871 
    None, # 0
559 chandransh 6872 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6873 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6874 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6875 
  )
6876 
 
594 rajveer 6877 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6878 
    self.userid = userid
594 rajveer 6879 
    self.oldPassword = oldPassword
6880 
    self.newPassword = newPassword
94 ashish 6881 
 
6882 
  def read(self, iprot):
6883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6885 
      return
6886 
    iprot.readStructBegin()
6887 
    while True:
6888 
      (fname, ftype, fid) = iprot.readFieldBegin()
6889 
      if ftype == TType.STOP:
6890 
        break
6891 
      if fid == 1:
6892 
        if ftype == TType.I64:
559 chandransh 6893 
          self.userid = iprot.readI64();
94 ashish 6894 
        else:
6895 
          iprot.skip(ftype)
6896 
      elif fid == 2:
559 chandransh 6897 
        if ftype == TType.STRING:
594 rajveer 6898 
          self.oldPassword = iprot.readString();
94 ashish 6899 
        else:
6900 
          iprot.skip(ftype)
594 rajveer 6901 
      elif fid == 3:
6902 
        if ftype == TType.STRING:
6903 
          self.newPassword = iprot.readString();
6904 
        else:
6905 
          iprot.skip(ftype)
94 ashish 6906 
      else:
6907 
        iprot.skip(ftype)
6908 
      iprot.readFieldEnd()
6909 
    iprot.readStructEnd()
6910 
 
6911 
  def write(self, oprot):
6912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6914 
      return
559 chandransh 6915 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6916 
    if self.userid is not None:
559 chandransh 6917 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6918 
      oprot.writeI64(self.userid)
94 ashish 6919 
      oprot.writeFieldEnd()
3431 rajveer 6920 
    if self.oldPassword is not None:
594 rajveer 6921 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6922 
      oprot.writeString(self.oldPassword)
94 ashish 6923 
      oprot.writeFieldEnd()
3431 rajveer 6924 
    if self.newPassword is not None:
594 rajveer 6925 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6926 
      oprot.writeString(self.newPassword)
6927 
      oprot.writeFieldEnd()
94 ashish 6928 
    oprot.writeFieldStop()
6929 
    oprot.writeStructEnd()
6930 
 
3431 rajveer 6931 
  def validate(self):
6932 
    return
6933 
 
6934 
 
94 ashish 6935 
  def __repr__(self):
6936 
    L = ['%s=%r' % (key, value)
6937 
      for key, value in self.__dict__.iteritems()]
6938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6939 
 
6940 
  def __eq__(self, other):
6941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6942 
 
6943 
  def __ne__(self, other):
6944 
    return not (self == other)
6945 
 
559 chandransh 6946 
class updatePassword_result:
94 ashish 6947 
  """
6948 
  Attributes:
6949 
   - success
6950 
   - ucx
6951 
  """
6952 
 
6953 
  thrift_spec = (
6954 
    (0, TType.BOOL, 'success', None, None, ), # 0
6955 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6956 
  )
6957 
 
6958 
  def __init__(self, success=None, ucx=None,):
6959 
    self.success = success
6960 
    self.ucx = ucx
6961 
 
6962 
  def read(self, iprot):
6963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6965 
      return
6966 
    iprot.readStructBegin()
6967 
    while True:
6968 
      (fname, ftype, fid) = iprot.readFieldBegin()
6969 
      if ftype == TType.STOP:
6970 
        break
6971 
      if fid == 0:
6972 
        if ftype == TType.BOOL:
6973 
          self.success = iprot.readBool();
6974 
        else:
6975 
          iprot.skip(ftype)
6976 
      elif fid == 1:
6977 
        if ftype == TType.STRUCT:
6978 
          self.ucx = UserContextException()
6979 
          self.ucx.read(iprot)
6980 
        else:
6981 
          iprot.skip(ftype)
6982 
      else:
6983 
        iprot.skip(ftype)
6984 
      iprot.readFieldEnd()
6985 
    iprot.readStructEnd()
6986 
 
6987 
  def write(self, oprot):
6988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6990 
      return
559 chandransh 6991 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6992 
    if self.success is not None:
94 ashish 6993 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6994 
      oprot.writeBool(self.success)
6995 
      oprot.writeFieldEnd()
3431 rajveer 6996 
    if self.ucx is not None:
94 ashish 6997 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6998 
      self.ucx.write(oprot)
6999 
      oprot.writeFieldEnd()
7000 
    oprot.writeFieldStop()
7001 
    oprot.writeStructEnd()
7002 
 
3431 rajveer 7003 
  def validate(self):
7004 
    return
7005 
 
7006 
 
94 ashish 7007 
  def __repr__(self):
7008 
    L = ['%s=%r' % (key, value)
7009 
      for key, value in self.__dict__.iteritems()]
7010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7011 
 
7012 
  def __eq__(self, other):
7013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7014 
 
7015 
  def __ne__(self, other):
7016 
    return not (self == other)
7017 
 
581 rajveer 7018 
class forgotPassword_args:
7019 
  """
7020 
  Attributes:
7021 
   - email
884 rajveer 7022 
   - newPassword
581 rajveer 7023 
  """
7024 
 
7025 
  thrift_spec = (
7026 
    None, # 0
7027 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7028 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7029 
  )
7030 
 
884 rajveer 7031 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7032 
    self.email = email
884 rajveer 7033 
    self.newPassword = newPassword
581 rajveer 7034 
 
7035 
  def read(self, iprot):
7036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7038 
      return
7039 
    iprot.readStructBegin()
7040 
    while True:
7041 
      (fname, ftype, fid) = iprot.readFieldBegin()
7042 
      if ftype == TType.STOP:
7043 
        break
7044 
      if fid == 1:
7045 
        if ftype == TType.STRING:
7046 
          self.email = iprot.readString();
7047 
        else:
7048 
          iprot.skip(ftype)
884 rajveer 7049 
      elif fid == 2:
7050 
        if ftype == TType.STRING:
7051 
          self.newPassword = iprot.readString();
7052 
        else:
7053 
          iprot.skip(ftype)
581 rajveer 7054 
      else:
7055 
        iprot.skip(ftype)
7056 
      iprot.readFieldEnd()
7057 
    iprot.readStructEnd()
7058 
 
7059 
  def write(self, oprot):
7060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7062 
      return
7063 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7064 
    if self.email is not None:
581 rajveer 7065 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7066 
      oprot.writeString(self.email)
7067 
      oprot.writeFieldEnd()
3431 rajveer 7068 
    if self.newPassword is not None:
884 rajveer 7069 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7070 
      oprot.writeString(self.newPassword)
7071 
      oprot.writeFieldEnd()
581 rajveer 7072 
    oprot.writeFieldStop()
7073 
    oprot.writeStructEnd()
7074 
 
3431 rajveer 7075 
  def validate(self):
7076 
    return
7077 
 
7078 
 
581 rajveer 7079 
  def __repr__(self):
7080 
    L = ['%s=%r' % (key, value)
7081 
      for key, value in self.__dict__.iteritems()]
7082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7083 
 
7084 
  def __eq__(self, other):
7085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7086 
 
7087 
  def __ne__(self, other):
7088 
    return not (self == other)
7089 
 
7090 
class forgotPassword_result:
7091 
  """
7092 
  Attributes:
7093 
   - success
7094 
   - ucx
7095 
  """
7096 
 
7097 
  thrift_spec = (
7098 
    (0, TType.BOOL, 'success', None, None, ), # 0
7099 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7100 
  )
7101 
 
7102 
  def __init__(self, success=None, ucx=None,):
7103 
    self.success = success
7104 
    self.ucx = ucx
7105 
 
7106 
  def read(self, iprot):
7107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7109 
      return
7110 
    iprot.readStructBegin()
7111 
    while True:
7112 
      (fname, ftype, fid) = iprot.readFieldBegin()
7113 
      if ftype == TType.STOP:
7114 
        break
7115 
      if fid == 0:
7116 
        if ftype == TType.BOOL:
7117 
          self.success = iprot.readBool();
7118 
        else:
7119 
          iprot.skip(ftype)
7120 
      elif fid == 1:
7121 
        if ftype == TType.STRUCT:
7122 
          self.ucx = UserContextException()
7123 
          self.ucx.read(iprot)
7124 
        else:
7125 
          iprot.skip(ftype)
7126 
      else:
7127 
        iprot.skip(ftype)
7128 
      iprot.readFieldEnd()
7129 
    iprot.readStructEnd()
7130 
 
7131 
  def write(self, oprot):
7132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7134 
      return
7135 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7136 
    if self.success is not None:
581 rajveer 7137 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7138 
      oprot.writeBool(self.success)
7139 
      oprot.writeFieldEnd()
3431 rajveer 7140 
    if self.ucx is not None:
581 rajveer 7141 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7142 
      self.ucx.write(oprot)
7143 
      oprot.writeFieldEnd()
7144 
    oprot.writeFieldStop()
7145 
    oprot.writeStructEnd()
7146 
 
3431 rajveer 7147 
  def validate(self):
7148 
    return
7149 
 
7150 
 
581 rajveer 7151 
  def __repr__(self):
7152 
    L = ['%s=%r' % (key, value)
7153 
      for key, value in self.__dict__.iteritems()]
7154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7155 
 
7156 
  def __eq__(self, other):
7157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7158 
 
7159 
  def __ne__(self, other):
7160 
    return not (self == other)
7161 
 
594 rajveer 7162 
class getAllAddressesForUser_args:
7163 
  """
7164 
  Attributes:
7165 
   - userId
7166 
  """
7167 
 
7168 
  thrift_spec = (
7169 
    None, # 0
7170 
    (1, TType.I64, 'userId', None, None, ), # 1
7171 
  )
7172 
 
7173 
  def __init__(self, userId=None,):
7174 
    self.userId = userId
7175 
 
7176 
  def read(self, iprot):
7177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7179 
      return
7180 
    iprot.readStructBegin()
7181 
    while True:
7182 
      (fname, ftype, fid) = iprot.readFieldBegin()
7183 
      if ftype == TType.STOP:
7184 
        break
7185 
      if fid == 1:
7186 
        if ftype == TType.I64:
7187 
          self.userId = iprot.readI64();
7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      else:
7191 
        iprot.skip(ftype)
7192 
      iprot.readFieldEnd()
7193 
    iprot.readStructEnd()
7194 
 
7195 
  def write(self, oprot):
7196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7198 
      return
7199 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7200 
    if self.userId is not None:
594 rajveer 7201 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7202 
      oprot.writeI64(self.userId)
7203 
      oprot.writeFieldEnd()
7204 
    oprot.writeFieldStop()
7205 
    oprot.writeStructEnd()
7206 
 
3431 rajveer 7207 
  def validate(self):
7208 
    return
7209 
 
7210 
 
594 rajveer 7211 
  def __repr__(self):
7212 
    L = ['%s=%r' % (key, value)
7213 
      for key, value in self.__dict__.iteritems()]
7214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7215 
 
7216 
  def __eq__(self, other):
7217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7218 
 
7219 
  def __ne__(self, other):
7220 
    return not (self == other)
7221 
 
7222 
class getAllAddressesForUser_result:
7223 
  """
7224 
  Attributes:
7225 
   - success
7226 
   - ucx
7227 
  """
7228 
 
7229 
  thrift_spec = (
7230 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7231 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7232 
  )
7233 
 
7234 
  def __init__(self, success=None, ucx=None,):
7235 
    self.success = success
7236 
    self.ucx = ucx
7237 
 
7238 
  def read(self, iprot):
7239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7241 
      return
7242 
    iprot.readStructBegin()
7243 
    while True:
7244 
      (fname, ftype, fid) = iprot.readFieldBegin()
7245 
      if ftype == TType.STOP:
7246 
        break
7247 
      if fid == 0:
7248 
        if ftype == TType.LIST:
7249 
          self.success = []
11592 amit.gupta 7250 
          (_etype100, _size97) = iprot.readListBegin()
7251 
          for _i101 in xrange(_size97):
7252 
            _elem102 = Address()
7253 
            _elem102.read(iprot)
7254 
            self.success.append(_elem102)
594 rajveer 7255 
          iprot.readListEnd()
7256 
        else:
7257 
          iprot.skip(ftype)
7258 
      elif fid == 1:
7259 
        if ftype == TType.STRUCT:
7260 
          self.ucx = UserContextException()
7261 
          self.ucx.read(iprot)
7262 
        else:
7263 
          iprot.skip(ftype)
7264 
      else:
7265 
        iprot.skip(ftype)
7266 
      iprot.readFieldEnd()
7267 
    iprot.readStructEnd()
7268 
 
7269 
  def write(self, oprot):
7270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7272 
      return
7273 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7274 
    if self.success is not None:
594 rajveer 7275 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7276 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7277 
      for iter103 in self.success:
7278 
        iter103.write(oprot)
594 rajveer 7279 
      oprot.writeListEnd()
7280 
      oprot.writeFieldEnd()
3431 rajveer 7281 
    if self.ucx is not None:
594 rajveer 7282 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7283 
      self.ucx.write(oprot)
7284 
      oprot.writeFieldEnd()
7285 
    oprot.writeFieldStop()
7286 
    oprot.writeStructEnd()
7287 
 
3431 rajveer 7288 
  def validate(self):
7289 
    return
7290 
 
7291 
 
594 rajveer 7292 
  def __repr__(self):
7293 
    L = ['%s=%r' % (key, value)
7294 
      for key, value in self.__dict__.iteritems()]
7295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7296 
 
7297 
  def __eq__(self, other):
7298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7299 
 
7300 
  def __ne__(self, other):
7301 
    return not (self == other)
7302 
 
1894 vikas 7303 
class getAddressById_args:
7304 
  """
7305 
  Attributes:
7306 
   - addressId
7307 
  """
7308 
 
7309 
  thrift_spec = (
7310 
    None, # 0
7311 
    (1, TType.I64, 'addressId', None, None, ), # 1
7312 
  )
7313 
 
7314 
  def __init__(self, addressId=None,):
7315 
    self.addressId = addressId
7316 
 
7317 
  def read(self, iprot):
7318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7320 
      return
7321 
    iprot.readStructBegin()
7322 
    while True:
7323 
      (fname, ftype, fid) = iprot.readFieldBegin()
7324 
      if ftype == TType.STOP:
7325 
        break
7326 
      if fid == 1:
7327 
        if ftype == TType.I64:
7328 
          self.addressId = iprot.readI64();
7329 
        else:
7330 
          iprot.skip(ftype)
7331 
      else:
7332 
        iprot.skip(ftype)
7333 
      iprot.readFieldEnd()
7334 
    iprot.readStructEnd()
7335 
 
7336 
  def write(self, oprot):
7337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7339 
      return
7340 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7341 
    if self.addressId is not None:
1894 vikas 7342 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7343 
      oprot.writeI64(self.addressId)
7344 
      oprot.writeFieldEnd()
7345 
    oprot.writeFieldStop()
7346 
    oprot.writeStructEnd()
7347 
 
3431 rajveer 7348 
  def validate(self):
7349 
    return
7350 
 
7351 
 
1894 vikas 7352 
  def __repr__(self):
7353 
    L = ['%s=%r' % (key, value)
7354 
      for key, value in self.__dict__.iteritems()]
7355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7356 
 
7357 
  def __eq__(self, other):
7358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7359 
 
7360 
  def __ne__(self, other):
7361 
    return not (self == other)
7362 
 
7363 
class getAddressById_result:
7364 
  """
7365 
  Attributes:
7366 
   - success
7367 
   - ucx
7368 
  """
7369 
 
7370 
  thrift_spec = (
7371 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7372 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7373 
  )
7374 
 
7375 
  def __init__(self, success=None, ucx=None,):
7376 
    self.success = success
7377 
    self.ucx = ucx
7378 
 
7379 
  def read(self, iprot):
7380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7382 
      return
7383 
    iprot.readStructBegin()
7384 
    while True:
7385 
      (fname, ftype, fid) = iprot.readFieldBegin()
7386 
      if ftype == TType.STOP:
7387 
        break
7388 
      if fid == 0:
7389 
        if ftype == TType.STRUCT:
7390 
          self.success = Address()
7391 
          self.success.read(iprot)
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      elif fid == 1:
7395 
        if ftype == TType.STRUCT:
7396 
          self.ucx = UserContextException()
7397 
          self.ucx.read(iprot)
7398 
        else:
7399 
          iprot.skip(ftype)
7400 
      else:
7401 
        iprot.skip(ftype)
7402 
      iprot.readFieldEnd()
7403 
    iprot.readStructEnd()
7404 
 
7405 
  def write(self, oprot):
7406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7408 
      return
7409 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7410 
    if self.success is not None:
1894 vikas 7411 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7412 
      self.success.write(oprot)
7413 
      oprot.writeFieldEnd()
3431 rajveer 7414 
    if self.ucx is not None:
1894 vikas 7415 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7416 
      self.ucx.write(oprot)
7417 
      oprot.writeFieldEnd()
7418 
    oprot.writeFieldStop()
7419 
    oprot.writeStructEnd()
7420 
 
3431 rajveer 7421 
  def validate(self):
7422 
    return
7423 
 
7424 
 
1894 vikas 7425 
  def __repr__(self):
7426 
    L = ['%s=%r' % (key, value)
7427 
      for key, value in self.__dict__.iteritems()]
7428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7429 
 
7430 
  def __eq__(self, other):
7431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7432 
 
7433 
  def __ne__(self, other):
7434 
    return not (self == other)
7435 
 
594 rajveer 7436 
class getDefaultAddressId_args:
7437 
  """
7438 
  Attributes:
7439 
   - userId
7440 
  """
7441 
 
7442 
  thrift_spec = (
7443 
    None, # 0
7444 
    (1, TType.I64, 'userId', None, None, ), # 1
7445 
  )
7446 
 
7447 
  def __init__(self, userId=None,):
7448 
    self.userId = userId
7449 
 
7450 
  def read(self, iprot):
7451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7453 
      return
7454 
    iprot.readStructBegin()
7455 
    while True:
7456 
      (fname, ftype, fid) = iprot.readFieldBegin()
7457 
      if ftype == TType.STOP:
7458 
        break
7459 
      if fid == 1:
7460 
        if ftype == TType.I64:
7461 
          self.userId = iprot.readI64();
7462 
        else:
7463 
          iprot.skip(ftype)
7464 
      else:
7465 
        iprot.skip(ftype)
7466 
      iprot.readFieldEnd()
7467 
    iprot.readStructEnd()
7468 
 
7469 
  def write(self, oprot):
7470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7472 
      return
7473 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7474 
    if self.userId is not None:
594 rajveer 7475 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7476 
      oprot.writeI64(self.userId)
7477 
      oprot.writeFieldEnd()
7478 
    oprot.writeFieldStop()
7479 
    oprot.writeStructEnd()
7480 
 
3431 rajveer 7481 
  def validate(self):
7482 
    return
7483 
 
7484 
 
594 rajveer 7485 
  def __repr__(self):
7486 
    L = ['%s=%r' % (key, value)
7487 
      for key, value in self.__dict__.iteritems()]
7488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7489 
 
7490 
  def __eq__(self, other):
7491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7492 
 
7493 
  def __ne__(self, other):
7494 
    return not (self == other)
7495 
 
7496 
class getDefaultAddressId_result:
7497 
  """
7498 
  Attributes:
7499 
   - success
7500 
   - ucx
7501 
  """
7502 
 
7503 
  thrift_spec = (
7504 
    (0, TType.I64, 'success', None, None, ), # 0
7505 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7506 
  )
7507 
 
7508 
  def __init__(self, success=None, ucx=None,):
7509 
    self.success = success
7510 
    self.ucx = ucx
7511 
 
7512 
  def read(self, iprot):
7513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7515 
      return
7516 
    iprot.readStructBegin()
7517 
    while True:
7518 
      (fname, ftype, fid) = iprot.readFieldBegin()
7519 
      if ftype == TType.STOP:
7520 
        break
7521 
      if fid == 0:
7522 
        if ftype == TType.I64:
7523 
          self.success = iprot.readI64();
7524 
        else:
7525 
          iprot.skip(ftype)
7526 
      elif fid == 1:
7527 
        if ftype == TType.STRUCT:
7528 
          self.ucx = UserContextException()
7529 
          self.ucx.read(iprot)
7530 
        else:
7531 
          iprot.skip(ftype)
7532 
      else:
7533 
        iprot.skip(ftype)
7534 
      iprot.readFieldEnd()
7535 
    iprot.readStructEnd()
7536 
 
7537 
  def write(self, oprot):
7538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7540 
      return
7541 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7542 
    if self.success is not None:
594 rajveer 7543 
      oprot.writeFieldBegin('success', TType.I64, 0)
7544 
      oprot.writeI64(self.success)
7545 
      oprot.writeFieldEnd()
3431 rajveer 7546 
    if self.ucx is not None:
594 rajveer 7547 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7548 
      self.ucx.write(oprot)
7549 
      oprot.writeFieldEnd()
7550 
    oprot.writeFieldStop()
7551 
    oprot.writeStructEnd()
7552 
 
3431 rajveer 7553 
  def validate(self):
7554 
    return
7555 
 
7556 
 
594 rajveer 7557 
  def __repr__(self):
7558 
    L = ['%s=%r' % (key, value)
7559 
      for key, value in self.__dict__.iteritems()]
7560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7561 
 
7562 
  def __eq__(self, other):
7563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7564 
 
7565 
  def __ne__(self, other):
7566 
    return not (self == other)
7567 
 
785 rajveer 7568 
class getDefaultPincode_args:
7569 
  """
7570 
  Attributes:
7571 
   - userId
7572 
  """
7573 
 
7574 
  thrift_spec = (
7575 
    None, # 0
7576 
    (1, TType.I64, 'userId', None, None, ), # 1
7577 
  )
7578 
 
7579 
  def __init__(self, userId=None,):
7580 
    self.userId = userId
7581 
 
7582 
  def read(self, iprot):
7583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7585 
      return
7586 
    iprot.readStructBegin()
7587 
    while True:
7588 
      (fname, ftype, fid) = iprot.readFieldBegin()
7589 
      if ftype == TType.STOP:
7590 
        break
7591 
      if fid == 1:
7592 
        if ftype == TType.I64:
7593 
          self.userId = iprot.readI64();
7594 
        else:
7595 
          iprot.skip(ftype)
7596 
      else:
7597 
        iprot.skip(ftype)
7598 
      iprot.readFieldEnd()
7599 
    iprot.readStructEnd()
7600 
 
7601 
  def write(self, oprot):
7602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7604 
      return
7605 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7606 
    if self.userId is not None:
785 rajveer 7607 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7608 
      oprot.writeI64(self.userId)
7609 
      oprot.writeFieldEnd()
7610 
    oprot.writeFieldStop()
7611 
    oprot.writeStructEnd()
7612 
 
3431 rajveer 7613 
  def validate(self):
7614 
    return
7615 
 
7616 
 
785 rajveer 7617 
  def __repr__(self):
7618 
    L = ['%s=%r' % (key, value)
7619 
      for key, value in self.__dict__.iteritems()]
7620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7621 
 
7622 
  def __eq__(self, other):
7623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7624 
 
7625 
  def __ne__(self, other):
7626 
    return not (self == other)
7627 
 
7628 
class getDefaultPincode_result:
7629 
  """
7630 
  Attributes:
7631 
   - success
7632 
   - ucx
7633 
  """
7634 
 
7635 
  thrift_spec = (
7636 
    (0, TType.STRING, 'success', None, None, ), # 0
7637 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7638 
  )
7639 
 
7640 
  def __init__(self, success=None, ucx=None,):
7641 
    self.success = success
7642 
    self.ucx = ucx
7643 
 
7644 
  def read(self, iprot):
7645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7647 
      return
7648 
    iprot.readStructBegin()
7649 
    while True:
7650 
      (fname, ftype, fid) = iprot.readFieldBegin()
7651 
      if ftype == TType.STOP:
7652 
        break
7653 
      if fid == 0:
7654 
        if ftype == TType.STRING:
7655 
          self.success = iprot.readString();
7656 
        else:
7657 
          iprot.skip(ftype)
7658 
      elif fid == 1:
7659 
        if ftype == TType.STRUCT:
7660 
          self.ucx = UserContextException()
7661 
          self.ucx.read(iprot)
7662 
        else:
7663 
          iprot.skip(ftype)
7664 
      else:
7665 
        iprot.skip(ftype)
7666 
      iprot.readFieldEnd()
7667 
    iprot.readStructEnd()
7668 
 
7669 
  def write(self, oprot):
7670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7672 
      return
7673 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7674 
    if self.success is not None:
785 rajveer 7675 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7676 
      oprot.writeString(self.success)
7677 
      oprot.writeFieldEnd()
3431 rajveer 7678 
    if self.ucx is not None:
785 rajveer 7679 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7680 
      self.ucx.write(oprot)
7681 
      oprot.writeFieldEnd()
7682 
    oprot.writeFieldStop()
7683 
    oprot.writeStructEnd()
7684 
 
3431 rajveer 7685 
  def validate(self):
7686 
    return
7687 
 
7688 
 
785 rajveer 7689 
  def __repr__(self):
7690 
    L = ['%s=%r' % (key, value)
7691 
      for key, value in self.__dict__.iteritems()]
7692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7693 
 
7694 
  def __eq__(self, other):
7695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7696 
 
7697 
  def __ne__(self, other):
7698 
    return not (self == other)
7699 
 
1274 varun.gupt 7700 
class saveUserCommunication_args:
7701 
  """
7702 
  Attributes:
7703 
   - userId
7704 
   - replyTo
7705 
   - communicationType
7706 
   - orderId
7707 
   - airwaybillNo
7708 
   - productName
7709 
   - subject
7710 
   - message
7711 
  """
7712 
 
7713 
  thrift_spec = (
7714 
    None, # 0
7715 
    (1, TType.I64, 'userId', None, None, ), # 1
7716 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7717 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7718 
    (4, TType.I64, 'orderId', None, None, ), # 4
7719 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7720 
    (6, TType.STRING, 'productName', None, None, ), # 6
7721 
    (7, TType.STRING, 'subject', None, None, ), # 7
7722 
    (8, TType.STRING, 'message', None, None, ), # 8
7723 
  )
7724 
 
7725 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7726 
    self.userId = userId
7727 
    self.replyTo = replyTo
7728 
    self.communicationType = communicationType
7729 
    self.orderId = orderId
7730 
    self.airwaybillNo = airwaybillNo
7731 
    self.productName = productName
7732 
    self.subject = subject
7733 
    self.message = message
7734 
 
7735 
  def read(self, iprot):
7736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7738 
      return
7739 
    iprot.readStructBegin()
7740 
    while True:
7741 
      (fname, ftype, fid) = iprot.readFieldBegin()
7742 
      if ftype == TType.STOP:
7743 
        break
7744 
      if fid == 1:
7745 
        if ftype == TType.I64:
7746 
          self.userId = iprot.readI64();
7747 
        else:
7748 
          iprot.skip(ftype)
7749 
      elif fid == 2:
7750 
        if ftype == TType.STRING:
7751 
          self.replyTo = iprot.readString();
7752 
        else:
7753 
          iprot.skip(ftype)
7754 
      elif fid == 3:
7755 
        if ftype == TType.I64:
7756 
          self.communicationType = iprot.readI64();
7757 
        else:
7758 
          iprot.skip(ftype)
7759 
      elif fid == 4:
7760 
        if ftype == TType.I64:
7761 
          self.orderId = iprot.readI64();
7762 
        else:
7763 
          iprot.skip(ftype)
7764 
      elif fid == 5:
7765 
        if ftype == TType.STRING:
7766 
          self.airwaybillNo = iprot.readString();
7767 
        else:
7768 
          iprot.skip(ftype)
7769 
      elif fid == 6:
7770 
        if ftype == TType.STRING:
7771 
          self.productName = iprot.readString();
7772 
        else:
7773 
          iprot.skip(ftype)
7774 
      elif fid == 7:
7775 
        if ftype == TType.STRING:
7776 
          self.subject = iprot.readString();
7777 
        else:
7778 
          iprot.skip(ftype)
7779 
      elif fid == 8:
7780 
        if ftype == TType.STRING:
7781 
          self.message = iprot.readString();
7782 
        else:
7783 
          iprot.skip(ftype)
7784 
      else:
7785 
        iprot.skip(ftype)
7786 
      iprot.readFieldEnd()
7787 
    iprot.readStructEnd()
7788 
 
7789 
  def write(self, oprot):
7790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7792 
      return
7793 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7794 
    if self.userId is not None:
1274 varun.gupt 7795 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7796 
      oprot.writeI64(self.userId)
7797 
      oprot.writeFieldEnd()
3431 rajveer 7798 
    if self.replyTo is not None:
1274 varun.gupt 7799 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7800 
      oprot.writeString(self.replyTo)
7801 
      oprot.writeFieldEnd()
3431 rajveer 7802 
    if self.communicationType is not None:
1274 varun.gupt 7803 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7804 
      oprot.writeI64(self.communicationType)
7805 
      oprot.writeFieldEnd()
3431 rajveer 7806 
    if self.orderId is not None:
1274 varun.gupt 7807 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7808 
      oprot.writeI64(self.orderId)
7809 
      oprot.writeFieldEnd()
3431 rajveer 7810 
    if self.airwaybillNo is not None:
1274 varun.gupt 7811 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7812 
      oprot.writeString(self.airwaybillNo)
7813 
      oprot.writeFieldEnd()
3431 rajveer 7814 
    if self.productName is not None:
1274 varun.gupt 7815 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7816 
      oprot.writeString(self.productName)
7817 
      oprot.writeFieldEnd()
3431 rajveer 7818 
    if self.subject is not None:
1274 varun.gupt 7819 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7820 
      oprot.writeString(self.subject)
7821 
      oprot.writeFieldEnd()
3431 rajveer 7822 
    if self.message is not None:
1274 varun.gupt 7823 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7824 
      oprot.writeString(self.message)
7825 
      oprot.writeFieldEnd()
7826 
    oprot.writeFieldStop()
7827 
    oprot.writeStructEnd()
7828 
 
3431 rajveer 7829 
  def validate(self):
7830 
    return
7831 
 
7832 
 
1274 varun.gupt 7833 
  def __repr__(self):
7834 
    L = ['%s=%r' % (key, value)
7835 
      for key, value in self.__dict__.iteritems()]
7836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7837 
 
7838 
  def __eq__(self, other):
7839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7840 
 
7841 
  def __ne__(self, other):
7842 
    return not (self == other)
7843 
 
7844 
class saveUserCommunication_result:
7845 
  """
7846 
  Attributes:
7847 
   - success
7848 
   - ucx
7849 
  """
7850 
 
7851 
  thrift_spec = (
7852 
    (0, TType.BOOL, 'success', None, None, ), # 0
7853 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7854 
  )
7855 
 
7856 
  def __init__(self, success=None, ucx=None,):
7857 
    self.success = success
7858 
    self.ucx = ucx
7859 
 
7860 
  def read(self, iprot):
7861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7863 
      return
7864 
    iprot.readStructBegin()
7865 
    while True:
7866 
      (fname, ftype, fid) = iprot.readFieldBegin()
7867 
      if ftype == TType.STOP:
7868 
        break
7869 
      if fid == 0:
7870 
        if ftype == TType.BOOL:
7871 
          self.success = iprot.readBool();
7872 
        else:
7873 
          iprot.skip(ftype)
7874 
      elif fid == 1:
7875 
        if ftype == TType.STRUCT:
7876 
          self.ucx = UserCommunicationException()
7877 
          self.ucx.read(iprot)
7878 
        else:
7879 
          iprot.skip(ftype)
7880 
      else:
7881 
        iprot.skip(ftype)
7882 
      iprot.readFieldEnd()
7883 
    iprot.readStructEnd()
7884 
 
7885 
  def write(self, oprot):
7886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7888 
      return
7889 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7890 
    if self.success is not None:
1274 varun.gupt 7891 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7892 
      oprot.writeBool(self.success)
7893 
      oprot.writeFieldEnd()
3431 rajveer 7894 
    if self.ucx is not None:
1274 varun.gupt 7895 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7896 
      self.ucx.write(oprot)
7897 
      oprot.writeFieldEnd()
7898 
    oprot.writeFieldStop()
7899 
    oprot.writeStructEnd()
7900 
 
3431 rajveer 7901 
  def validate(self):
7902 
    return
7903 
 
7904 
 
1274 varun.gupt 7905 
  def __repr__(self):
7906 
    L = ['%s=%r' % (key, value)
7907 
      for key, value in self.__dict__.iteritems()]
7908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7909 
 
7910 
  def __eq__(self, other):
7911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7912 
 
7913 
  def __ne__(self, other):
7914 
    return not (self == other)
7915 
 
1590 varun.gupt 7916 
class getUserCommunicationById_args:
7917 
  """
7918 
  Attributes:
7919 
   - id
7920 
  """
7921 
 
7922 
  thrift_spec = (
7923 
    None, # 0
7924 
    (1, TType.I64, 'id', None, None, ), # 1
7925 
  )
7926 
 
7927 
  def __init__(self, id=None,):
7928 
    self.id = id
7929 
 
7930 
  def read(self, iprot):
7931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7933 
      return
7934 
    iprot.readStructBegin()
7935 
    while True:
7936 
      (fname, ftype, fid) = iprot.readFieldBegin()
7937 
      if ftype == TType.STOP:
7938 
        break
7939 
      if fid == 1:
7940 
        if ftype == TType.I64:
7941 
          self.id = iprot.readI64();
7942 
        else:
7943 
          iprot.skip(ftype)
7944 
      else:
7945 
        iprot.skip(ftype)
7946 
      iprot.readFieldEnd()
7947 
    iprot.readStructEnd()
7948 
 
7949 
  def write(self, oprot):
7950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7952 
      return
7953 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7954 
    if self.id is not None:
1590 varun.gupt 7955 
      oprot.writeFieldBegin('id', TType.I64, 1)
7956 
      oprot.writeI64(self.id)
7957 
      oprot.writeFieldEnd()
7958 
    oprot.writeFieldStop()
7959 
    oprot.writeStructEnd()
7960 
 
3431 rajveer 7961 
  def validate(self):
7962 
    return
7963 
 
7964 
 
1590 varun.gupt 7965 
  def __repr__(self):
7966 
    L = ['%s=%r' % (key, value)
7967 
      for key, value in self.__dict__.iteritems()]
7968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7969 
 
7970 
  def __eq__(self, other):
7971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7972 
 
7973 
  def __ne__(self, other):
7974 
    return not (self == other)
7975 
 
7976 
class getUserCommunicationById_result:
7977 
  """
7978 
  Attributes:
7979 
   - success
7980 
   - ucx
7981 
  """
7982 
 
7983 
  thrift_spec = (
7984 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7985 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7986 
  )
7987 
 
7988 
  def __init__(self, success=None, ucx=None,):
7989 
    self.success = success
7990 
    self.ucx = ucx
7991 
 
7992 
  def read(self, iprot):
7993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7995 
      return
7996 
    iprot.readStructBegin()
7997 
    while True:
7998 
      (fname, ftype, fid) = iprot.readFieldBegin()
7999 
      if ftype == TType.STOP:
8000 
        break
8001 
      if fid == 0:
8002 
        if ftype == TType.STRUCT:
8003 
          self.success = UserCommunication()
8004 
          self.success.read(iprot)
8005 
        else:
8006 
          iprot.skip(ftype)
8007 
      elif fid == 1:
8008 
        if ftype == TType.STRUCT:
8009 
          self.ucx = UserCommunicationException()
8010 
          self.ucx.read(iprot)
8011 
        else:
8012 
          iprot.skip(ftype)
8013 
      else:
8014 
        iprot.skip(ftype)
8015 
      iprot.readFieldEnd()
8016 
    iprot.readStructEnd()
8017 
 
8018 
  def write(self, oprot):
8019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8021 
      return
8022 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8023 
    if self.success is not None:
1590 varun.gupt 8024 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8025 
      self.success.write(oprot)
8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.ucx is not None:
1590 varun.gupt 8028 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8029 
      self.ucx.write(oprot)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
1590 varun.gupt 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
8049 
class getUserCommunicationByUser_args:
8050 
  """
8051 
  Attributes:
8052 
   - userId
8053 
  """
8054 
 
8055 
  thrift_spec = (
8056 
    None, # 0
8057 
    (1, TType.I64, 'userId', None, None, ), # 1
8058 
  )
8059 
 
8060 
  def __init__(self, userId=None,):
8061 
    self.userId = userId
8062 
 
8063 
  def read(self, iprot):
8064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8066 
      return
8067 
    iprot.readStructBegin()
8068 
    while True:
8069 
      (fname, ftype, fid) = iprot.readFieldBegin()
8070 
      if ftype == TType.STOP:
8071 
        break
8072 
      if fid == 1:
8073 
        if ftype == TType.I64:
8074 
          self.userId = iprot.readI64();
8075 
        else:
8076 
          iprot.skip(ftype)
8077 
      else:
8078 
        iprot.skip(ftype)
8079 
      iprot.readFieldEnd()
8080 
    iprot.readStructEnd()
8081 
 
8082 
  def write(self, oprot):
8083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8085 
      return
8086 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8087 
    if self.userId is not None:
1590 varun.gupt 8088 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8089 
      oprot.writeI64(self.userId)
8090 
      oprot.writeFieldEnd()
8091 
    oprot.writeFieldStop()
8092 
    oprot.writeStructEnd()
8093 
 
3431 rajveer 8094 
  def validate(self):
8095 
    return
8096 
 
8097 
 
1590 varun.gupt 8098 
  def __repr__(self):
8099 
    L = ['%s=%r' % (key, value)
8100 
      for key, value in self.__dict__.iteritems()]
8101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8102 
 
8103 
  def __eq__(self, other):
8104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8105 
 
8106 
  def __ne__(self, other):
8107 
    return not (self == other)
8108 
 
8109 
class getUserCommunicationByUser_result:
8110 
  """
8111 
  Attributes:
8112 
   - success
8113 
   - ucx
8114 
  """
8115 
 
8116 
  thrift_spec = (
8117 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8118 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8119 
  )
8120 
 
8121 
  def __init__(self, success=None, ucx=None,):
8122 
    self.success = success
8123 
    self.ucx = ucx
8124 
 
8125 
  def read(self, iprot):
8126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8128 
      return
8129 
    iprot.readStructBegin()
8130 
    while True:
8131 
      (fname, ftype, fid) = iprot.readFieldBegin()
8132 
      if ftype == TType.STOP:
8133 
        break
8134 
      if fid == 0:
8135 
        if ftype == TType.LIST:
8136 
          self.success = []
11592 amit.gupta 8137 
          (_etype107, _size104) = iprot.readListBegin()
8138 
          for _i108 in xrange(_size104):
8139 
            _elem109 = UserCommunication()
8140 
            _elem109.read(iprot)
8141 
            self.success.append(_elem109)
1590 varun.gupt 8142 
          iprot.readListEnd()
8143 
        else:
8144 
          iprot.skip(ftype)
8145 
      elif fid == 1:
8146 
        if ftype == TType.STRUCT:
8147 
          self.ucx = UserCommunicationException()
8148 
          self.ucx.read(iprot)
8149 
        else:
8150 
          iprot.skip(ftype)
8151 
      else:
8152 
        iprot.skip(ftype)
8153 
      iprot.readFieldEnd()
8154 
    iprot.readStructEnd()
8155 
 
8156 
  def write(self, oprot):
8157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8159 
      return
8160 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8161 
    if self.success is not None:
1590 varun.gupt 8162 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8163 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8164 
      for iter110 in self.success:
8165 
        iter110.write(oprot)
1590 varun.gupt 8166 
      oprot.writeListEnd()
8167 
      oprot.writeFieldEnd()
3431 rajveer 8168 
    if self.ucx is not None:
1590 varun.gupt 8169 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8170 
      self.ucx.write(oprot)
8171 
      oprot.writeFieldEnd()
8172 
    oprot.writeFieldStop()
8173 
    oprot.writeStructEnd()
8174 
 
3431 rajveer 8175 
  def validate(self):
8176 
    return
8177 
 
8178 
 
1590 varun.gupt 8179 
  def __repr__(self):
8180 
    L = ['%s=%r' % (key, value)
8181 
      for key, value in self.__dict__.iteritems()]
8182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8183 
 
8184 
  def __eq__(self, other):
8185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8186 
 
8187 
  def __ne__(self, other):
8188 
    return not (self == other)
8189 
 
8190 
class getAllUserCommunications_args:
8191 
 
8192 
  thrift_spec = (
8193 
  )
8194 
 
8195 
  def read(self, iprot):
8196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8198 
      return
8199 
    iprot.readStructBegin()
8200 
    while True:
8201 
      (fname, ftype, fid) = iprot.readFieldBegin()
8202 
      if ftype == TType.STOP:
8203 
        break
8204 
      else:
8205 
        iprot.skip(ftype)
8206 
      iprot.readFieldEnd()
8207 
    iprot.readStructEnd()
8208 
 
8209 
  def write(self, oprot):
8210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8212 
      return
8213 
    oprot.writeStructBegin('getAllUserCommunications_args')
8214 
    oprot.writeFieldStop()
8215 
    oprot.writeStructEnd()
8216 
 
3431 rajveer 8217 
  def validate(self):
8218 
    return
8219 
 
8220 
 
1590 varun.gupt 8221 
  def __repr__(self):
8222 
    L = ['%s=%r' % (key, value)
8223 
      for key, value in self.__dict__.iteritems()]
8224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8225 
 
8226 
  def __eq__(self, other):
8227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8228 
 
8229 
  def __ne__(self, other):
8230 
    return not (self == other)
8231 
 
8232 
class getAllUserCommunications_result:
8233 
  """
8234 
  Attributes:
8235 
   - success
8236 
   - ucx
8237 
  """
8238 
 
8239 
  thrift_spec = (
8240 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8241 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8242 
  )
8243 
 
8244 
  def __init__(self, success=None, ucx=None,):
8245 
    self.success = success
8246 
    self.ucx = ucx
8247 
 
8248 
  def read(self, iprot):
8249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8251 
      return
8252 
    iprot.readStructBegin()
8253 
    while True:
8254 
      (fname, ftype, fid) = iprot.readFieldBegin()
8255 
      if ftype == TType.STOP:
8256 
        break
8257 
      if fid == 0:
8258 
        if ftype == TType.LIST:
8259 
          self.success = []
11592 amit.gupta 8260 
          (_etype114, _size111) = iprot.readListBegin()
8261 
          for _i115 in xrange(_size111):
8262 
            _elem116 = UserCommunication()
8263 
            _elem116.read(iprot)
8264 
            self.success.append(_elem116)
1590 varun.gupt 8265 
          iprot.readListEnd()
8266 
        else:
8267 
          iprot.skip(ftype)
8268 
      elif fid == 1:
8269 
        if ftype == TType.STRUCT:
8270 
          self.ucx = UserCommunicationException()
8271 
          self.ucx.read(iprot)
8272 
        else:
8273 
          iprot.skip(ftype)
8274 
      else:
8275 
        iprot.skip(ftype)
8276 
      iprot.readFieldEnd()
8277 
    iprot.readStructEnd()
8278 
 
8279 
  def write(self, oprot):
8280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8282 
      return
8283 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8284 
    if self.success is not None:
1590 varun.gupt 8285 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8286 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8287 
      for iter117 in self.success:
8288 
        iter117.write(oprot)
1590 varun.gupt 8289 
      oprot.writeListEnd()
8290 
      oprot.writeFieldEnd()
3431 rajveer 8291 
    if self.ucx is not None:
1590 varun.gupt 8292 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8293 
      self.ucx.write(oprot)
8294 
      oprot.writeFieldEnd()
8295 
    oprot.writeFieldStop()
8296 
    oprot.writeStructEnd()
8297 
 
3431 rajveer 8298 
  def validate(self):
8299 
    return
8300 
 
8301 
 
1590 varun.gupt 8302 
  def __repr__(self):
8303 
    L = ['%s=%r' % (key, value)
8304 
      for key, value in self.__dict__.iteritems()]
8305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8306 
 
8307 
  def __eq__(self, other):
8308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8309 
 
8310 
  def __ne__(self, other):
8311 
    return not (self == other)
8312 
 
5407 amar.kumar 8313 
class removeUserCommunication_args:
8314 
  """
8315 
  Attributes:
8316 
   - id
8317 
  """
8318 
 
8319 
  thrift_spec = (
8320 
    None, # 0
8321 
    (1, TType.I64, 'id', None, None, ), # 1
8322 
  )
8323 
 
8324 
  def __init__(self, id=None,):
8325 
    self.id = id
8326 
 
8327 
  def read(self, iprot):
8328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8330 
      return
8331 
    iprot.readStructBegin()
8332 
    while True:
8333 
      (fname, ftype, fid) = iprot.readFieldBegin()
8334 
      if ftype == TType.STOP:
8335 
        break
8336 
      if fid == 1:
8337 
        if ftype == TType.I64:
8338 
          self.id = iprot.readI64();
8339 
        else:
8340 
          iprot.skip(ftype)
8341 
      else:
8342 
        iprot.skip(ftype)
8343 
      iprot.readFieldEnd()
8344 
    iprot.readStructEnd()
8345 
 
8346 
  def write(self, oprot):
8347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8349 
      return
8350 
    oprot.writeStructBegin('removeUserCommunication_args')
8351 
    if self.id is not None:
8352 
      oprot.writeFieldBegin('id', TType.I64, 1)
8353 
      oprot.writeI64(self.id)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
8372 
 
8373 
class removeUserCommunication_result:
8374 
  """
8375 
  Attributes:
8376 
   - ucx
8377 
  """
8378 
 
8379 
  thrift_spec = (
8380 
    None, # 0
8381 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8382 
  )
8383 
 
8384 
  def __init__(self, ucx=None,):
8385 
    self.ucx = ucx
8386 
 
8387 
  def read(self, iprot):
8388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8390 
      return
8391 
    iprot.readStructBegin()
8392 
    while True:
8393 
      (fname, ftype, fid) = iprot.readFieldBegin()
8394 
      if ftype == TType.STOP:
8395 
        break
8396 
      if fid == 1:
8397 
        if ftype == TType.STRUCT:
8398 
          self.ucx = UserCommunicationException()
8399 
          self.ucx.read(iprot)
8400 
        else:
8401 
          iprot.skip(ftype)
8402 
      else:
8403 
        iprot.skip(ftype)
8404 
      iprot.readFieldEnd()
8405 
    iprot.readStructEnd()
8406 
 
8407 
  def write(self, oprot):
8408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8410 
      return
8411 
    oprot.writeStructBegin('removeUserCommunication_result')
8412 
    if self.ucx is not None:
8413 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8414 
      self.ucx.write(oprot)
8415 
      oprot.writeFieldEnd()
8416 
    oprot.writeFieldStop()
8417 
    oprot.writeStructEnd()
8418 
 
8419 
  def validate(self):
8420 
    return
8421 
 
8422 
 
8423 
  def __repr__(self):
8424 
    L = ['%s=%r' % (key, value)
8425 
      for key, value in self.__dict__.iteritems()]
8426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8427 
 
8428 
  def __eq__(self, other):
8429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8430 
 
8431 
  def __ne__(self, other):
8432 
    return not (self == other)
8433 
 
1845 vikas 8434 
class createMasterAffiliate_args:
8435 
  """
8436 
  Attributes:
8437 
   - name
1859 vikas 8438 
   - addedOn
1845 vikas 8439 
  """
8440 
 
8441 
  thrift_spec = (
8442 
    None, # 0
8443 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8444 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8445 
  )
8446 
 
1859 vikas 8447 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8448 
    self.name = name
1859 vikas 8449 
    self.addedOn = addedOn
1845 vikas 8450 
 
8451 
  def read(self, iprot):
8452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8454 
      return
8455 
    iprot.readStructBegin()
8456 
    while True:
8457 
      (fname, ftype, fid) = iprot.readFieldBegin()
8458 
      if ftype == TType.STOP:
8459 
        break
8460 
      if fid == 1:
8461 
        if ftype == TType.STRING:
8462 
          self.name = iprot.readString();
8463 
        else:
8464 
          iprot.skip(ftype)
1859 vikas 8465 
      elif fid == 2:
8466 
        if ftype == TType.I64:
8467 
          self.addedOn = iprot.readI64();
8468 
        else:
8469 
          iprot.skip(ftype)
1845 vikas 8470 
      else:
8471 
        iprot.skip(ftype)
8472 
      iprot.readFieldEnd()
8473 
    iprot.readStructEnd()
8474 
 
8475 
  def write(self, oprot):
8476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8478 
      return
8479 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8480 
    if self.name is not None:
1845 vikas 8481 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8482 
      oprot.writeString(self.name)
8483 
      oprot.writeFieldEnd()
3431 rajveer 8484 
    if self.addedOn is not None:
1859 vikas 8485 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8486 
      oprot.writeI64(self.addedOn)
8487 
      oprot.writeFieldEnd()
1845 vikas 8488 
    oprot.writeFieldStop()
8489 
    oprot.writeStructEnd()
8490 
 
3431 rajveer 8491 
  def validate(self):
8492 
    return
8493 
 
8494 
 
1845 vikas 8495 
  def __repr__(self):
8496 
    L = ['%s=%r' % (key, value)
8497 
      for key, value in self.__dict__.iteritems()]
8498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8499 
 
8500 
  def __eq__(self, other):
8501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8502 
 
8503 
  def __ne__(self, other):
8504 
    return not (self == other)
8505 
 
8506 
class createMasterAffiliate_result:
8507 
  """
8508 
  Attributes:
8509 
   - success
8510 
   - utx
8511 
  """
8512 
 
8513 
  thrift_spec = (
8514 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8515 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8516 
  )
8517 
 
8518 
  def __init__(self, success=None, utx=None,):
8519 
    self.success = success
8520 
    self.utx = utx
8521 
 
8522 
  def read(self, iprot):
8523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8525 
      return
8526 
    iprot.readStructBegin()
8527 
    while True:
8528 
      (fname, ftype, fid) = iprot.readFieldBegin()
8529 
      if ftype == TType.STOP:
8530 
        break
8531 
      if fid == 0:
8532 
        if ftype == TType.STRUCT:
8533 
          self.success = MasterAffiliate()
8534 
          self.success.read(iprot)
8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      elif fid == 1:
8538 
        if ftype == TType.STRUCT:
1996 vikas 8539 
          self.utx = UserAffiliateException()
1845 vikas 8540 
          self.utx.read(iprot)
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      else:
8544 
        iprot.skip(ftype)
8545 
      iprot.readFieldEnd()
8546 
    iprot.readStructEnd()
8547 
 
8548 
  def write(self, oprot):
8549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8551 
      return
8552 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8553 
    if self.success is not None:
1845 vikas 8554 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8555 
      self.success.write(oprot)
8556 
      oprot.writeFieldEnd()
3431 rajveer 8557 
    if self.utx is not None:
1845 vikas 8558 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8559 
      self.utx.write(oprot)
8560 
      oprot.writeFieldEnd()
8561 
    oprot.writeFieldStop()
8562 
    oprot.writeStructEnd()
8563 
 
3431 rajveer 8564 
  def validate(self):
8565 
    return
8566 
 
8567 
 
1845 vikas 8568 
  def __repr__(self):
8569 
    L = ['%s=%r' % (key, value)
8570 
      for key, value in self.__dict__.iteritems()]
8571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8572 
 
8573 
  def __eq__(self, other):
8574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8575 
 
8576 
  def __ne__(self, other):
8577 
    return not (self == other)
8578 
 
1899 vikas 8579 
class getAllMasterAffiliates_args:
8580 
 
8581 
  thrift_spec = (
8582 
  )
8583 
 
8584 
  def read(self, iprot):
8585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8587 
      return
8588 
    iprot.readStructBegin()
8589 
    while True:
8590 
      (fname, ftype, fid) = iprot.readFieldBegin()
8591 
      if ftype == TType.STOP:
8592 
        break
8593 
      else:
8594 
        iprot.skip(ftype)
8595 
      iprot.readFieldEnd()
8596 
    iprot.readStructEnd()
8597 
 
8598 
  def write(self, oprot):
8599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8601 
      return
8602 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8603 
    oprot.writeFieldStop()
8604 
    oprot.writeStructEnd()
8605 
 
3431 rajveer 8606 
  def validate(self):
8607 
    return
8608 
 
8609 
 
1899 vikas 8610 
  def __repr__(self):
8611 
    L = ['%s=%r' % (key, value)
8612 
      for key, value in self.__dict__.iteritems()]
8613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8614 
 
8615 
  def __eq__(self, other):
8616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8617 
 
8618 
  def __ne__(self, other):
8619 
    return not (self == other)
8620 
 
8621 
class getAllMasterAffiliates_result:
8622 
  """
8623 
  Attributes:
8624 
   - success
8625 
   - utx
8626 
  """
8627 
 
8628 
  thrift_spec = (
8629 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8630 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8631 
  )
8632 
 
8633 
  def __init__(self, success=None, utx=None,):
8634 
    self.success = success
8635 
    self.utx = utx
8636 
 
8637 
  def read(self, iprot):
8638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8640 
      return
8641 
    iprot.readStructBegin()
8642 
    while True:
8643 
      (fname, ftype, fid) = iprot.readFieldBegin()
8644 
      if ftype == TType.STOP:
8645 
        break
8646 
      if fid == 0:
8647 
        if ftype == TType.LIST:
8648 
          self.success = []
11592 amit.gupta 8649 
          (_etype121, _size118) = iprot.readListBegin()
8650 
          for _i122 in xrange(_size118):
8651 
            _elem123 = MasterAffiliate()
8652 
            _elem123.read(iprot)
8653 
            self.success.append(_elem123)
1899 vikas 8654 
          iprot.readListEnd()
8655 
        else:
8656 
          iprot.skip(ftype)
8657 
      elif fid == 1:
8658 
        if ftype == TType.STRUCT:
1996 vikas 8659 
          self.utx = UserAffiliateException()
1899 vikas 8660 
          self.utx.read(iprot)
8661 
        else:
8662 
          iprot.skip(ftype)
8663 
      else:
8664 
        iprot.skip(ftype)
8665 
      iprot.readFieldEnd()
8666 
    iprot.readStructEnd()
8667 
 
8668 
  def write(self, oprot):
8669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8671 
      return
8672 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8673 
    if self.success is not None:
1899 vikas 8674 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8675 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8676 
      for iter124 in self.success:
8677 
        iter124.write(oprot)
1899 vikas 8678 
      oprot.writeListEnd()
8679 
      oprot.writeFieldEnd()
3431 rajveer 8680 
    if self.utx is not None:
1899 vikas 8681 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8682 
      self.utx.write(oprot)
8683 
      oprot.writeFieldEnd()
8684 
    oprot.writeFieldStop()
8685 
    oprot.writeStructEnd()
8686 
 
3431 rajveer 8687 
  def validate(self):
8688 
    return
8689 
 
8690 
 
1899 vikas 8691 
  def __repr__(self):
8692 
    L = ['%s=%r' % (key, value)
8693 
      for key, value in self.__dict__.iteritems()]
8694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8695 
 
8696 
  def __eq__(self, other):
8697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8698 
 
8699 
  def __ne__(self, other):
8700 
    return not (self == other)
8701 
 
1845 vikas 8702 
class getMasterAffiliateById_args:
8703 
  """
8704 
  Attributes:
8705 
   - id
8706 
  """
8707 
 
8708 
  thrift_spec = (
8709 
    None, # 0
8710 
    (1, TType.I64, 'id', None, None, ), # 1
8711 
  )
8712 
 
8713 
  def __init__(self, id=None,):
8714 
    self.id = id
8715 
 
8716 
  def read(self, iprot):
8717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8719 
      return
8720 
    iprot.readStructBegin()
8721 
    while True:
8722 
      (fname, ftype, fid) = iprot.readFieldBegin()
8723 
      if ftype == TType.STOP:
8724 
        break
8725 
      if fid == 1:
8726 
        if ftype == TType.I64:
8727 
          self.id = iprot.readI64();
8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      else:
8731 
        iprot.skip(ftype)
8732 
      iprot.readFieldEnd()
8733 
    iprot.readStructEnd()
8734 
 
8735 
  def write(self, oprot):
8736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8738 
      return
8739 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8740 
    if self.id is not None:
1845 vikas 8741 
      oprot.writeFieldBegin('id', TType.I64, 1)
8742 
      oprot.writeI64(self.id)
8743 
      oprot.writeFieldEnd()
8744 
    oprot.writeFieldStop()
8745 
    oprot.writeStructEnd()
8746 
 
3431 rajveer 8747 
  def validate(self):
8748 
    return
8749 
 
8750 
 
1845 vikas 8751 
  def __repr__(self):
8752 
    L = ['%s=%r' % (key, value)
8753 
      for key, value in self.__dict__.iteritems()]
8754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8755 
 
8756 
  def __eq__(self, other):
8757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8758 
 
8759 
  def __ne__(self, other):
8760 
    return not (self == other)
8761 
 
8762 
class getMasterAffiliateById_result:
8763 
  """
8764 
  Attributes:
8765 
   - success
8766 
   - utx
8767 
  """
8768 
 
8769 
  thrift_spec = (
8770 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8771 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8772 
  )
8773 
 
8774 
  def __init__(self, success=None, utx=None,):
8775 
    self.success = success
8776 
    self.utx = utx
8777 
 
8778 
  def read(self, iprot):
8779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8781 
      return
8782 
    iprot.readStructBegin()
8783 
    while True:
8784 
      (fname, ftype, fid) = iprot.readFieldBegin()
8785 
      if ftype == TType.STOP:
8786 
        break
8787 
      if fid == 0:
8788 
        if ftype == TType.STRUCT:
8789 
          self.success = MasterAffiliate()
8790 
          self.success.read(iprot)
8791 
        else:
8792 
          iprot.skip(ftype)
8793 
      elif fid == 1:
8794 
        if ftype == TType.STRUCT:
1996 vikas 8795 
          self.utx = UserAffiliateException()
1845 vikas 8796 
          self.utx.read(iprot)
8797 
        else:
8798 
          iprot.skip(ftype)
8799 
      else:
8800 
        iprot.skip(ftype)
8801 
      iprot.readFieldEnd()
8802 
    iprot.readStructEnd()
8803 
 
8804 
  def write(self, oprot):
8805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8807 
      return
8808 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8809 
    if self.success is not None:
1845 vikas 8810 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8811 
      self.success.write(oprot)
8812 
      oprot.writeFieldEnd()
3431 rajveer 8813 
    if self.utx is not None:
1845 vikas 8814 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8815 
      self.utx.write(oprot)
8816 
      oprot.writeFieldEnd()
8817 
    oprot.writeFieldStop()
8818 
    oprot.writeStructEnd()
8819 
 
3431 rajveer 8820 
  def validate(self):
8821 
    return
8822 
 
8823 
 
1845 vikas 8824 
  def __repr__(self):
8825 
    L = ['%s=%r' % (key, value)
8826 
      for key, value in self.__dict__.iteritems()]
8827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8828 
 
8829 
  def __eq__(self, other):
8830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8831 
 
8832 
  def __ne__(self, other):
8833 
    return not (self == other)
8834 
 
8835 
class getMasterAffiliateByName_args:
8836 
  """
8837 
  Attributes:
8838 
   - name
8839 
  """
8840 
 
8841 
  thrift_spec = (
8842 
    None, # 0
8843 
    (1, TType.STRING, 'name', None, None, ), # 1
8844 
  )
8845 
 
8846 
  def __init__(self, name=None,):
8847 
    self.name = name
8848 
 
8849 
  def read(self, iprot):
8850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8852 
      return
8853 
    iprot.readStructBegin()
8854 
    while True:
8855 
      (fname, ftype, fid) = iprot.readFieldBegin()
8856 
      if ftype == TType.STOP:
8857 
        break
8858 
      if fid == 1:
8859 
        if ftype == TType.STRING:
8860 
          self.name = iprot.readString();
8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
8872 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8873 
    if self.name is not None:
1845 vikas 8874 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8875 
      oprot.writeString(self.name)
8876 
      oprot.writeFieldEnd()
8877 
    oprot.writeFieldStop()
8878 
    oprot.writeStructEnd()
8879 
 
3431 rajveer 8880 
  def validate(self):
8881 
    return
8882 
 
8883 
 
1845 vikas 8884 
  def __repr__(self):
8885 
    L = ['%s=%r' % (key, value)
8886 
      for key, value in self.__dict__.iteritems()]
8887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8888 
 
8889 
  def __eq__(self, other):
8890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8891 
 
8892 
  def __ne__(self, other):
8893 
    return not (self == other)
8894 
 
8895 
class getMasterAffiliateByName_result:
8896 
  """
8897 
  Attributes:
8898 
   - success
8899 
   - utx
8900 
  """
8901 
 
8902 
  thrift_spec = (
8903 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8904 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8905 
  )
8906 
 
8907 
  def __init__(self, success=None, utx=None,):
8908 
    self.success = success
8909 
    self.utx = utx
8910 
 
8911 
  def read(self, iprot):
8912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8914 
      return
8915 
    iprot.readStructBegin()
8916 
    while True:
8917 
      (fname, ftype, fid) = iprot.readFieldBegin()
8918 
      if ftype == TType.STOP:
8919 
        break
8920 
      if fid == 0:
8921 
        if ftype == TType.STRUCT:
8922 
          self.success = MasterAffiliate()
8923 
          self.success.read(iprot)
8924 
        else:
8925 
          iprot.skip(ftype)
8926 
      elif fid == 1:
8927 
        if ftype == TType.STRUCT:
1996 vikas 8928 
          self.utx = UserAffiliateException()
1845 vikas 8929 
          self.utx.read(iprot)
8930 
        else:
8931 
          iprot.skip(ftype)
8932 
      else:
8933 
        iprot.skip(ftype)
8934 
      iprot.readFieldEnd()
8935 
    iprot.readStructEnd()
8936 
 
8937 
  def write(self, oprot):
8938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8940 
      return
8941 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8942 
    if self.success is not None:
1845 vikas 8943 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8944 
      self.success.write(oprot)
8945 
      oprot.writeFieldEnd()
3431 rajveer 8946 
    if self.utx is not None:
1845 vikas 8947 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8948 
      self.utx.write(oprot)
8949 
      oprot.writeFieldEnd()
8950 
    oprot.writeFieldStop()
8951 
    oprot.writeStructEnd()
8952 
 
3431 rajveer 8953 
  def validate(self):
8954 
    return
8955 
 
8956 
 
1845 vikas 8957 
  def __repr__(self):
8958 
    L = ['%s=%r' % (key, value)
8959 
      for key, value in self.__dict__.iteritems()]
8960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8961 
 
8962 
  def __eq__(self, other):
8963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8964 
 
8965 
  def __ne__(self, other):
8966 
    return not (self == other)
8967 
 
8968 
class createAffiliate_args:
8969 
  """
8970 
  Attributes:
8971 
   - name
8972 
   - url
8973 
   - masterAffiliateId
1859 vikas 8974 
   - addedOn
1845 vikas 8975 
  """
8976 
 
8977 
  thrift_spec = (
8978 
    None, # 0
8979 
    (1, TType.STRING, 'name', None, None, ), # 1
8980 
    (2, TType.STRING, 'url', None, None, ), # 2
8981 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8982 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8983 
  )
8984 
 
1859 vikas 8985 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8986 
    self.name = name
8987 
    self.url = url
8988 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8989 
    self.addedOn = addedOn
1845 vikas 8990 
 
8991 
  def read(self, iprot):
8992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8994 
      return
8995 
    iprot.readStructBegin()
8996 
    while True:
8997 
      (fname, ftype, fid) = iprot.readFieldBegin()
8998 
      if ftype == TType.STOP:
8999 
        break
9000 
      if fid == 1:
9001 
        if ftype == TType.STRING:
9002 
          self.name = iprot.readString();
9003 
        else:
9004 
          iprot.skip(ftype)
9005 
      elif fid == 2:
9006 
        if ftype == TType.STRING:
9007 
          self.url = iprot.readString();
9008 
        else:
9009 
          iprot.skip(ftype)
9010 
      elif fid == 3:
9011 
        if ftype == TType.I64:
9012 
          self.masterAffiliateId = iprot.readI64();
9013 
        else:
9014 
          iprot.skip(ftype)
1859 vikas 9015 
      elif fid == 4:
9016 
        if ftype == TType.I64:
9017 
          self.addedOn = iprot.readI64();
9018 
        else:
9019 
          iprot.skip(ftype)
1845 vikas 9020 
      else:
9021 
        iprot.skip(ftype)
9022 
      iprot.readFieldEnd()
9023 
    iprot.readStructEnd()
9024 
 
9025 
  def write(self, oprot):
9026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9028 
      return
9029 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9030 
    if self.name is not None:
1845 vikas 9031 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9032 
      oprot.writeString(self.name)
9033 
      oprot.writeFieldEnd()
3431 rajveer 9034 
    if self.url is not None:
1845 vikas 9035 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9036 
      oprot.writeString(self.url)
9037 
      oprot.writeFieldEnd()
3431 rajveer 9038 
    if self.masterAffiliateId is not None:
1845 vikas 9039 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9040 
      oprot.writeI64(self.masterAffiliateId)
9041 
      oprot.writeFieldEnd()
3431 rajveer 9042 
    if self.addedOn is not None:
1859 vikas 9043 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9044 
      oprot.writeI64(self.addedOn)
9045 
      oprot.writeFieldEnd()
1845 vikas 9046 
    oprot.writeFieldStop()
9047 
    oprot.writeStructEnd()
9048 
 
3431 rajveer 9049 
  def validate(self):
9050 
    return
9051 
 
9052 
 
1845 vikas 9053 
  def __repr__(self):
9054 
    L = ['%s=%r' % (key, value)
9055 
      for key, value in self.__dict__.iteritems()]
9056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9057 
 
9058 
  def __eq__(self, other):
9059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9060 
 
9061 
  def __ne__(self, other):
9062 
    return not (self == other)
9063 
 
9064 
class createAffiliate_result:
9065 
  """
9066 
  Attributes:
9067 
   - success
9068 
   - utx
9069 
  """
9070 
 
9071 
  thrift_spec = (
9072 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9073 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9074 
  )
9075 
 
9076 
  def __init__(self, success=None, utx=None,):
9077 
    self.success = success
9078 
    self.utx = utx
9079 
 
9080 
  def read(self, iprot):
9081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9083 
      return
9084 
    iprot.readStructBegin()
9085 
    while True:
9086 
      (fname, ftype, fid) = iprot.readFieldBegin()
9087 
      if ftype == TType.STOP:
9088 
        break
9089 
      if fid == 0:
9090 
        if ftype == TType.STRUCT:
9091 
          self.success = Affiliate()
9092 
          self.success.read(iprot)
9093 
        else:
9094 
          iprot.skip(ftype)
9095 
      elif fid == 1:
9096 
        if ftype == TType.STRUCT:
1996 vikas 9097 
          self.utx = UserAffiliateException()
1845 vikas 9098 
          self.utx.read(iprot)
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      else:
9102 
        iprot.skip(ftype)
9103 
      iprot.readFieldEnd()
9104 
    iprot.readStructEnd()
9105 
 
9106 
  def write(self, oprot):
9107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9109 
      return
9110 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9111 
    if self.success is not None:
1845 vikas 9112 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9113 
      self.success.write(oprot)
9114 
      oprot.writeFieldEnd()
3431 rajveer 9115 
    if self.utx is not None:
1845 vikas 9116 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9117 
      self.utx.write(oprot)
9118 
      oprot.writeFieldEnd()
9119 
    oprot.writeFieldStop()
9120 
    oprot.writeStructEnd()
9121 
 
3431 rajveer 9122 
  def validate(self):
9123 
    return
9124 
 
9125 
 
1845 vikas 9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
9137 
class getAffiliateById_args:
9138 
  """
9139 
  Attributes:
9140 
   - id
9141 
  """
9142 
 
9143 
  thrift_spec = (
9144 
    None, # 0
9145 
    (1, TType.I64, 'id', None, None, ), # 1
9146 
  )
9147 
 
9148 
  def __init__(self, id=None,):
9149 
    self.id = id
9150 
 
9151 
  def read(self, iprot):
9152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9154 
      return
9155 
    iprot.readStructBegin()
9156 
    while True:
9157 
      (fname, ftype, fid) = iprot.readFieldBegin()
9158 
      if ftype == TType.STOP:
9159 
        break
9160 
      if fid == 1:
9161 
        if ftype == TType.I64:
9162 
          self.id = iprot.readI64();
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9175 
    if self.id is not None:
1845 vikas 9176 
      oprot.writeFieldBegin('id', TType.I64, 1)
9177 
      oprot.writeI64(self.id)
9178 
      oprot.writeFieldEnd()
9179 
    oprot.writeFieldStop()
9180 
    oprot.writeStructEnd()
9181 
 
3431 rajveer 9182 
  def validate(self):
9183 
    return
9184 
 
9185 
 
1845 vikas 9186 
  def __repr__(self):
9187 
    L = ['%s=%r' % (key, value)
9188 
      for key, value in self.__dict__.iteritems()]
9189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9190 
 
9191 
  def __eq__(self, other):
9192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9193 
 
9194 
  def __ne__(self, other):
9195 
    return not (self == other)
9196 
 
9197 
class getAffiliateById_result:
9198 
  """
9199 
  Attributes:
9200 
   - success
9201 
   - utx
9202 
  """
9203 
 
9204 
  thrift_spec = (
9205 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9206 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9207 
  )
9208 
 
9209 
  def __init__(self, success=None, utx=None,):
9210 
    self.success = success
9211 
    self.utx = utx
9212 
 
9213 
  def read(self, iprot):
9214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9216 
      return
9217 
    iprot.readStructBegin()
9218 
    while True:
9219 
      (fname, ftype, fid) = iprot.readFieldBegin()
9220 
      if ftype == TType.STOP:
9221 
        break
9222 
      if fid == 0:
9223 
        if ftype == TType.STRUCT:
9224 
          self.success = Affiliate()
9225 
          self.success.read(iprot)
9226 
        else:
9227 
          iprot.skip(ftype)
9228 
      elif fid == 1:
9229 
        if ftype == TType.STRUCT:
1996 vikas 9230 
          self.utx = UserAffiliateException()
1845 vikas 9231 
          self.utx.read(iprot)
9232 
        else:
9233 
          iprot.skip(ftype)
9234 
      else:
9235 
        iprot.skip(ftype)
9236 
      iprot.readFieldEnd()
9237 
    iprot.readStructEnd()
9238 
 
9239 
  def write(self, oprot):
9240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9242 
      return
9243 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9244 
    if self.success is not None:
1845 vikas 9245 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9246 
      self.success.write(oprot)
9247 
      oprot.writeFieldEnd()
3431 rajveer 9248 
    if self.utx is not None:
1845 vikas 9249 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9250 
      self.utx.write(oprot)
9251 
      oprot.writeFieldEnd()
9252 
    oprot.writeFieldStop()
9253 
    oprot.writeStructEnd()
9254 
 
3431 rajveer 9255 
  def validate(self):
9256 
    return
9257 
 
9258 
 
1845 vikas 9259 
  def __repr__(self):
9260 
    L = ['%s=%r' % (key, value)
9261 
      for key, value in self.__dict__.iteritems()]
9262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9263 
 
9264 
  def __eq__(self, other):
9265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9266 
 
9267 
  def __ne__(self, other):
9268 
    return not (self == other)
9269 
 
9270 
class getAffiliateByName_args:
9271 
  """
9272 
  Attributes:
9273 
   - name
9274 
  """
9275 
 
9276 
  thrift_spec = (
9277 
    None, # 0
9278 
    (1, TType.STRING, 'name', None, None, ), # 1
9279 
  )
9280 
 
9281 
  def __init__(self, name=None,):
9282 
    self.name = name
9283 
 
9284 
  def read(self, iprot):
9285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9287 
      return
9288 
    iprot.readStructBegin()
9289 
    while True:
9290 
      (fname, ftype, fid) = iprot.readFieldBegin()
9291 
      if ftype == TType.STOP:
9292 
        break
9293 
      if fid == 1:
9294 
        if ftype == TType.STRING:
9295 
          self.name = iprot.readString();
9296 
        else:
9297 
          iprot.skip(ftype)
9298 
      else:
9299 
        iprot.skip(ftype)
9300 
      iprot.readFieldEnd()
9301 
    iprot.readStructEnd()
9302 
 
9303 
  def write(self, oprot):
9304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9306 
      return
9307 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9308 
    if self.name is not None:
1845 vikas 9309 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9310 
      oprot.writeString(self.name)
9311 
      oprot.writeFieldEnd()
9312 
    oprot.writeFieldStop()
9313 
    oprot.writeStructEnd()
9314 
 
3431 rajveer 9315 
  def validate(self):
9316 
    return
9317 
 
9318 
 
1845 vikas 9319 
  def __repr__(self):
9320 
    L = ['%s=%r' % (key, value)
9321 
      for key, value in self.__dict__.iteritems()]
9322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9323 
 
9324 
  def __eq__(self, other):
9325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9326 
 
9327 
  def __ne__(self, other):
9328 
    return not (self == other)
9329 
 
9330 
class getAffiliateByName_result:
9331 
  """
9332 
  Attributes:
9333 
   - success
9334 
   - utx
9335 
  """
9336 
 
9337 
  thrift_spec = (
9338 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9339 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9340 
  )
9341 
 
9342 
  def __init__(self, success=None, utx=None,):
9343 
    self.success = success
9344 
    self.utx = utx
9345 
 
9346 
  def read(self, iprot):
9347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9349 
      return
9350 
    iprot.readStructBegin()
9351 
    while True:
9352 
      (fname, ftype, fid) = iprot.readFieldBegin()
9353 
      if ftype == TType.STOP:
9354 
        break
9355 
      if fid == 0:
9356 
        if ftype == TType.STRUCT:
9357 
          self.success = Affiliate()
9358 
          self.success.read(iprot)
9359 
        else:
9360 
          iprot.skip(ftype)
9361 
      elif fid == 1:
9362 
        if ftype == TType.STRUCT:
1996 vikas 9363 
          self.utx = UserAffiliateException()
1845 vikas 9364 
          self.utx.read(iprot)
9365 
        else:
9366 
          iprot.skip(ftype)
9367 
      else:
9368 
        iprot.skip(ftype)
9369 
      iprot.readFieldEnd()
9370 
    iprot.readStructEnd()
9371 
 
9372 
  def write(self, oprot):
9373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9375 
      return
9376 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9377 
    if self.success is not None:
1845 vikas 9378 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9379 
      self.success.write(oprot)
9380 
      oprot.writeFieldEnd()
3431 rajveer 9381 
    if self.utx is not None:
1845 vikas 9382 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9383 
      self.utx.write(oprot)
9384 
      oprot.writeFieldEnd()
9385 
    oprot.writeFieldStop()
9386 
    oprot.writeStructEnd()
9387 
 
3431 rajveer 9388 
  def validate(self):
9389 
    return
9390 
 
9391 
 
1845 vikas 9392 
  def __repr__(self):
9393 
    L = ['%s=%r' % (key, value)
9394 
      for key, value in self.__dict__.iteritems()]
9395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9396 
 
9397 
  def __eq__(self, other):
9398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9399 
 
9400 
  def __ne__(self, other):
9401 
    return not (self == other)
9402 
 
1996 vikas 9403 
class getTrackerById_args:
1845 vikas 9404 
  """
9405 
  Attributes:
9406 
   - id
9407 
  """
9408 
 
9409 
  thrift_spec = (
9410 
    None, # 0
9411 
    (1, TType.I64, 'id', None, None, ), # 1
9412 
  )
9413 
 
9414 
  def __init__(self, id=None,):
9415 
    self.id = id
9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      if fid == 1:
9427 
        if ftype == TType.I64:
9428 
          self.id = iprot.readI64();
9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      else:
9432 
        iprot.skip(ftype)
9433 
      iprot.readFieldEnd()
9434 
    iprot.readStructEnd()
9435 
 
9436 
  def write(self, oprot):
9437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9439 
      return
1996 vikas 9440 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9441 
    if self.id is not None:
1845 vikas 9442 
      oprot.writeFieldBegin('id', TType.I64, 1)
9443 
      oprot.writeI64(self.id)
9444 
      oprot.writeFieldEnd()
9445 
    oprot.writeFieldStop()
9446 
    oprot.writeStructEnd()
9447 
 
3431 rajveer 9448 
  def validate(self):
9449 
    return
9450 
 
9451 
 
1845 vikas 9452 
  def __repr__(self):
9453 
    L = ['%s=%r' % (key, value)
9454 
      for key, value in self.__dict__.iteritems()]
9455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9456 
 
9457 
  def __eq__(self, other):
9458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9459 
 
9460 
  def __ne__(self, other):
9461 
    return not (self == other)
9462 
 
9463 
class getTrackerById_result:
9464 
  """
9465 
  Attributes:
9466 
   - success
9467 
   - utx
9468 
  """
9469 
 
9470 
  thrift_spec = (
9471 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9472 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9473 
  )
9474 
 
9475 
  def __init__(self, success=None, utx=None,):
9476 
    self.success = success
9477 
    self.utx = utx
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 0:
9489 
        if ftype == TType.STRUCT:
9490 
          self.success = Tracker()
9491 
          self.success.read(iprot)
9492 
        else:
9493 
          iprot.skip(ftype)
9494 
      elif fid == 1:
9495 
        if ftype == TType.STRUCT:
1996 vikas 9496 
          self.utx = UserAffiliateException()
1845 vikas 9497 
          self.utx.read(iprot)
9498 
        else:
9499 
          iprot.skip(ftype)
9500 
      else:
9501 
        iprot.skip(ftype)
9502 
      iprot.readFieldEnd()
9503 
    iprot.readStructEnd()
9504 
 
9505 
  def write(self, oprot):
9506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9508 
      return
9509 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9510 
    if self.success is not None:
1845 vikas 9511 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9512 
      self.success.write(oprot)
9513 
      oprot.writeFieldEnd()
3431 rajveer 9514 
    if self.utx is not None:
1845 vikas 9515 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9516 
      self.utx.write(oprot)
9517 
      oprot.writeFieldEnd()
9518 
    oprot.writeFieldStop()
9519 
    oprot.writeStructEnd()
9520 
 
3431 rajveer 9521 
  def validate(self):
9522 
    return
9523 
 
9524 
 
1845 vikas 9525 
  def __repr__(self):
9526 
    L = ['%s=%r' % (key, value)
9527 
      for key, value in self.__dict__.iteritems()]
9528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9529 
 
9530 
  def __eq__(self, other):
9531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9532 
 
9533 
  def __ne__(self, other):
9534 
    return not (self == other)
9535 
 
1996 vikas 9536 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9537 
  """
9538 
  Attributes:
1996 vikas 9539 
   - id
1845 vikas 9540 
  """
9541 
 
9542 
  thrift_spec = (
9543 
    None, # 0
1996 vikas 9544 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9545 
  )
9546 
 
1996 vikas 9547 
  def __init__(self, id=None,):
9548 
    self.id = id
1845 vikas 9549 
 
9550 
  def read(self, iprot):
9551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9553 
      return
9554 
    iprot.readStructBegin()
9555 
    while True:
9556 
      (fname, ftype, fid) = iprot.readFieldBegin()
9557 
      if ftype == TType.STOP:
9558 
        break
9559 
      if fid == 1:
9560 
        if ftype == TType.I64:
1996 vikas 9561 
          self.id = iprot.readI64();
1845 vikas 9562 
        else:
9563 
          iprot.skip(ftype)
9564 
      else:
9565 
        iprot.skip(ftype)
9566 
      iprot.readFieldEnd()
9567 
    iprot.readStructEnd()
9568 
 
9569 
  def write(self, oprot):
9570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9572 
      return
1996 vikas 9573 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9574 
    if self.id is not None:
1996 vikas 9575 
      oprot.writeFieldBegin('id', TType.I64, 1)
9576 
      oprot.writeI64(self.id)
1845 vikas 9577 
      oprot.writeFieldEnd()
9578 
    oprot.writeFieldStop()
9579 
    oprot.writeStructEnd()
9580 
 
3431 rajveer 9581 
  def validate(self):
9582 
    return
9583 
 
9584 
 
1845 vikas 9585 
  def __repr__(self):
9586 
    L = ['%s=%r' % (key, value)
9587 
      for key, value in self.__dict__.iteritems()]
9588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9589 
 
9590 
  def __eq__(self, other):
9591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9592 
 
9593 
  def __ne__(self, other):
9594 
    return not (self == other)
9595 
 
1996 vikas 9596 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9597 
  """
9598 
  Attributes:
9599 
   - success
9600 
   - utx
9601 
  """
9602 
 
9603 
  thrift_spec = (
1996 vikas 9604 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9605 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9606 
  )
9607 
 
9608 
  def __init__(self, success=None, utx=None,):
9609 
    self.success = success
9610 
    self.utx = utx
9611 
 
9612 
  def read(self, iprot):
9613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9615 
      return
9616 
    iprot.readStructBegin()
9617 
    while True:
9618 
      (fname, ftype, fid) = iprot.readFieldBegin()
9619 
      if ftype == TType.STOP:
9620 
        break
9621 
      if fid == 0:
9622 
        if ftype == TType.LIST:
9623 
          self.success = []
11592 amit.gupta 9624 
          (_etype128, _size125) = iprot.readListBegin()
9625 
          for _i129 in xrange(_size125):
9626 
            _elem130 = Affiliate()
9627 
            _elem130.read(iprot)
9628 
            self.success.append(_elem130)
1845 vikas 9629 
          iprot.readListEnd()
9630 
        else:
9631 
          iprot.skip(ftype)
9632 
      elif fid == 1:
9633 
        if ftype == TType.STRUCT:
1996 vikas 9634 
          self.utx = UserAffiliateException()
1845 vikas 9635 
          self.utx.read(iprot)
9636 
        else:
9637 
          iprot.skip(ftype)
9638 
      else:
9639 
        iprot.skip(ftype)
9640 
      iprot.readFieldEnd()
9641 
    iprot.readStructEnd()
9642 
 
9643 
  def write(self, oprot):
9644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9646 
      return
1996 vikas 9647 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9648 
    if self.success is not None:
1845 vikas 9649 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9650 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9651 
      for iter131 in self.success:
9652 
        iter131.write(oprot)
1845 vikas 9653 
      oprot.writeListEnd()
9654 
      oprot.writeFieldEnd()
3431 rajveer 9655 
    if self.utx is not None:
1845 vikas 9656 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9657 
      self.utx.write(oprot)
9658 
      oprot.writeFieldEnd()
9659 
    oprot.writeFieldStop()
9660 
    oprot.writeStructEnd()
9661 
 
3431 rajveer 9662 
  def validate(self):
9663 
    return
9664 
 
9665 
 
1845 vikas 9666 
  def __repr__(self):
9667 
    L = ['%s=%r' % (key, value)
9668 
      for key, value in self.__dict__.iteritems()]
9669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9670 
 
9671 
  def __eq__(self, other):
9672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9673 
 
9674 
  def __ne__(self, other):
9675 
    return not (self == other)
9676 
 
9677 
class addTrackLog_args:
9678 
  """
9679 
  Attributes:
1996 vikas 9680 
   - affiliateId
1845 vikas 9681 
   - userId
9682 
   - event
9683 
   - url
9684 
   - data
1859 vikas 9685 
   - addedOn
1845 vikas 9686 
  """
9687 
 
9688 
  thrift_spec = (
9689 
    None, # 0
1996 vikas 9690 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9691 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9692 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9693 
    (4, TType.STRING, 'url', None, None, ), # 4
9694 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9695 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9696 
  )
9697 
 
1996 vikas 9698 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9699 
    self.affiliateId = affiliateId
1845 vikas 9700 
    self.userId = userId
9701 
    self.event = event
9702 
    self.url = url
9703 
    self.data = data
1859 vikas 9704 
    self.addedOn = addedOn
1845 vikas 9705 
 
9706 
  def read(self, iprot):
9707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9709 
      return
9710 
    iprot.readStructBegin()
9711 
    while True:
9712 
      (fname, ftype, fid) = iprot.readFieldBegin()
9713 
      if ftype == TType.STOP:
9714 
        break
9715 
      if fid == 1:
9716 
        if ftype == TType.I64:
1996 vikas 9717 
          self.affiliateId = iprot.readI64();
1845 vikas 9718 
        else:
9719 
          iprot.skip(ftype)
9720 
      elif fid == 2:
9721 
        if ftype == TType.I64:
9722 
          self.userId = iprot.readI64();
9723 
        else:
9724 
          iprot.skip(ftype)
9725 
      elif fid == 3:
3378 vikas 9726 
        if ftype == TType.I32:
9727 
          self.event = iprot.readI32();
1845 vikas 9728 
        else:
9729 
          iprot.skip(ftype)
9730 
      elif fid == 4:
9731 
        if ftype == TType.STRING:
9732 
          self.url = iprot.readString();
9733 
        else:
9734 
          iprot.skip(ftype)
9735 
      elif fid == 5:
9736 
        if ftype == TType.STRING:
9737 
          self.data = iprot.readString();
9738 
        else:
9739 
          iprot.skip(ftype)
1859 vikas 9740 
      elif fid == 6:
9741 
        if ftype == TType.I64:
9742 
          self.addedOn = iprot.readI64();
9743 
        else:
9744 
          iprot.skip(ftype)
1845 vikas 9745 
      else:
9746 
        iprot.skip(ftype)
9747 
      iprot.readFieldEnd()
9748 
    iprot.readStructEnd()
9749 
 
9750 
  def write(self, oprot):
9751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9753 
      return
9754 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9755 
    if self.affiliateId is not None:
1996 vikas 9756 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9757 
      oprot.writeI64(self.affiliateId)
1845 vikas 9758 
      oprot.writeFieldEnd()
3431 rajveer 9759 
    if self.userId is not None:
1845 vikas 9760 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9761 
      oprot.writeI64(self.userId)
9762 
      oprot.writeFieldEnd()
3431 rajveer 9763 
    if self.event is not None:
3378 vikas 9764 
      oprot.writeFieldBegin('event', TType.I32, 3)
9765 
      oprot.writeI32(self.event)
1845 vikas 9766 
      oprot.writeFieldEnd()
3431 rajveer 9767 
    if self.url is not None:
1845 vikas 9768 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9769 
      oprot.writeString(self.url)
9770 
      oprot.writeFieldEnd()
3431 rajveer 9771 
    if self.data is not None:
1845 vikas 9772 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9773 
      oprot.writeString(self.data)
9774 
      oprot.writeFieldEnd()
3431 rajveer 9775 
    if self.addedOn is not None:
1859 vikas 9776 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9777 
      oprot.writeI64(self.addedOn)
9778 
      oprot.writeFieldEnd()
1845 vikas 9779 
    oprot.writeFieldStop()
9780 
    oprot.writeStructEnd()
9781 
 
3431 rajveer 9782 
  def validate(self):
9783 
    return
9784 
 
9785 
 
1845 vikas 9786 
  def __repr__(self):
9787 
    L = ['%s=%r' % (key, value)
9788 
      for key, value in self.__dict__.iteritems()]
9789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9790 
 
9791 
  def __eq__(self, other):
9792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9793 
 
9794 
  def __ne__(self, other):
9795 
    return not (self == other)
9796 
 
9797 
class addTrackLog_result:
9798 
  """
9799 
  Attributes:
9800 
   - success
9801 
   - utx
9802 
  """
9803 
 
9804 
  thrift_spec = (
9805 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9806 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9807 
  )
9808 
 
9809 
  def __init__(self, success=None, utx=None,):
9810 
    self.success = success
9811 
    self.utx = utx
9812 
 
9813 
  def read(self, iprot):
9814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9816 
      return
9817 
    iprot.readStructBegin()
9818 
    while True:
9819 
      (fname, ftype, fid) = iprot.readFieldBegin()
9820 
      if ftype == TType.STOP:
9821 
        break
9822 
      if fid == 0:
9823 
        if ftype == TType.I64:
9824 
          self.success = iprot.readI64();
9825 
        else:
9826 
          iprot.skip(ftype)
9827 
      elif fid == 1:
9828 
        if ftype == TType.STRUCT:
1996 vikas 9829 
          self.utx = UserAffiliateException()
1845 vikas 9830 
          self.utx.read(iprot)
9831 
        else:
9832 
          iprot.skip(ftype)
9833 
      else:
9834 
        iprot.skip(ftype)
9835 
      iprot.readFieldEnd()
9836 
    iprot.readStructEnd()
9837 
 
9838 
  def write(self, oprot):
9839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9841 
      return
9842 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9843 
    if self.success is not None:
1845 vikas 9844 
      oprot.writeFieldBegin('success', TType.I64, 0)
9845 
      oprot.writeI64(self.success)
9846 
      oprot.writeFieldEnd()
3431 rajveer 9847 
    if self.utx is not None:
1845 vikas 9848 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9849 
      self.utx.write(oprot)
9850 
      oprot.writeFieldEnd()
9851 
    oprot.writeFieldStop()
9852 
    oprot.writeStructEnd()
9853 
 
3431 rajveer 9854 
  def validate(self):
9855 
    return
9856 
 
9857 
 
1845 vikas 9858 
  def __repr__(self):
9859 
    L = ['%s=%r' % (key, value)
9860 
      for key, value in self.__dict__.iteritems()]
9861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9862 
 
9863 
  def __eq__(self, other):
9864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9865 
 
9866 
  def __ne__(self, other):
9867 
    return not (self == other)
9868 
 
9869 
class getTrackLogById_args:
9870 
  """
9871 
  Attributes:
9872 
   - id
9873 
  """
9874 
 
9875 
  thrift_spec = (
9876 
    None, # 0
9877 
    (1, TType.I64, 'id', None, None, ), # 1
9878 
  )
9879 
 
9880 
  def __init__(self, id=None,):
9881 
    self.id = id
9882 
 
9883 
  def read(self, iprot):
9884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9886 
      return
9887 
    iprot.readStructBegin()
9888 
    while True:
9889 
      (fname, ftype, fid) = iprot.readFieldBegin()
9890 
      if ftype == TType.STOP:
9891 
        break
9892 
      if fid == 1:
9893 
        if ftype == TType.I64:
9894 
          self.id = iprot.readI64();
9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      else:
9898 
        iprot.skip(ftype)
9899 
      iprot.readFieldEnd()
9900 
    iprot.readStructEnd()
9901 
 
9902 
  def write(self, oprot):
9903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9905 
      return
9906 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9907 
    if self.id is not None:
1845 vikas 9908 
      oprot.writeFieldBegin('id', TType.I64, 1)
9909 
      oprot.writeI64(self.id)
9910 
      oprot.writeFieldEnd()
9911 
    oprot.writeFieldStop()
9912 
    oprot.writeStructEnd()
9913 
 
3431 rajveer 9914 
  def validate(self):
9915 
    return
9916 
 
9917 
 
1845 vikas 9918 
  def __repr__(self):
9919 
    L = ['%s=%r' % (key, value)
9920 
      for key, value in self.__dict__.iteritems()]
9921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9922 
 
9923 
  def __eq__(self, other):
9924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9925 
 
9926 
  def __ne__(self, other):
9927 
    return not (self == other)
9928 
 
9929 
class getTrackLogById_result:
9930 
  """
9931 
  Attributes:
9932 
   - success
9933 
   - utx
9934 
  """
9935 
 
9936 
  thrift_spec = (
9937 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9938 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9939 
  )
9940 
 
9941 
  def __init__(self, success=None, utx=None,):
9942 
    self.success = success
9943 
    self.utx = utx
9944 
 
9945 
  def read(self, iprot):
9946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9948 
      return
9949 
    iprot.readStructBegin()
9950 
    while True:
9951 
      (fname, ftype, fid) = iprot.readFieldBegin()
9952 
      if ftype == TType.STOP:
9953 
        break
9954 
      if fid == 0:
9955 
        if ftype == TType.STRUCT:
9956 
          self.success = TrackLog()
9957 
          self.success.read(iprot)
9958 
        else:
9959 
          iprot.skip(ftype)
9960 
      elif fid == 1:
9961 
        if ftype == TType.STRUCT:
1996 vikas 9962 
          self.utx = UserAffiliateException()
1845 vikas 9963 
          self.utx.read(iprot)
9964 
        else:
9965 
          iprot.skip(ftype)
9966 
      else:
9967 
        iprot.skip(ftype)
9968 
      iprot.readFieldEnd()
9969 
    iprot.readStructEnd()
9970 
 
9971 
  def write(self, oprot):
9972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9974 
      return
9975 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9976 
    if self.success is not None:
1845 vikas 9977 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9978 
      self.success.write(oprot)
9979 
      oprot.writeFieldEnd()
3431 rajveer 9980 
    if self.utx is not None:
1845 vikas 9981 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9982 
      self.utx.write(oprot)
9983 
      oprot.writeFieldEnd()
9984 
    oprot.writeFieldStop()
9985 
    oprot.writeStructEnd()
9986 
 
3431 rajveer 9987 
  def validate(self):
9988 
    return
9989 
 
9990 
 
1845 vikas 9991 
  def __repr__(self):
9992 
    L = ['%s=%r' % (key, value)
9993 
      for key, value in self.__dict__.iteritems()]
9994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9995 
 
9996 
  def __eq__(self, other):
9997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9998 
 
9999 
  def __ne__(self, other):
10000 
    return not (self == other)
10001 
 
1996 vikas 10002 
class getTrackLogsByAffiliate_args:
1845 vikas 10003 
  """
10004 
  Attributes:
1996 vikas 10005 
   - affiliateId
3293 vikas 10006 
   - startDate
10007 
   - endDate
1845 vikas 10008 
  """
10009 
 
10010 
  thrift_spec = (
10011 
    None, # 0
1996 vikas 10012 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10013 
    (2, TType.I64, 'startDate', None, None, ), # 2
10014 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10015 
  )
10016 
 
3293 vikas 10017 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10018 
    self.affiliateId = affiliateId
3293 vikas 10019 
    self.startDate = startDate
10020 
    self.endDate = endDate
1845 vikas 10021 
 
10022 
  def read(self, iprot):
10023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10025 
      return
10026 
    iprot.readStructBegin()
10027 
    while True:
10028 
      (fname, ftype, fid) = iprot.readFieldBegin()
10029 
      if ftype == TType.STOP:
10030 
        break
10031 
      if fid == 1:
10032 
        if ftype == TType.I64:
1996 vikas 10033 
          self.affiliateId = iprot.readI64();
1845 vikas 10034 
        else:
10035 
          iprot.skip(ftype)
3293 vikas 10036 
      elif fid == 2:
10037 
        if ftype == TType.I64:
10038 
          self.startDate = iprot.readI64();
10039 
        else:
10040 
          iprot.skip(ftype)
10041 
      elif fid == 3:
10042 
        if ftype == TType.I64:
10043 
          self.endDate = iprot.readI64();
10044 
        else:
10045 
          iprot.skip(ftype)
1845 vikas 10046 
      else:
10047 
        iprot.skip(ftype)
10048 
      iprot.readFieldEnd()
10049 
    iprot.readStructEnd()
10050 
 
10051 
  def write(self, oprot):
10052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10054 
      return
1996 vikas 10055 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10056 
    if self.affiliateId is not None:
1996 vikas 10057 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10058 
      oprot.writeI64(self.affiliateId)
1845 vikas 10059 
      oprot.writeFieldEnd()
3431 rajveer 10060 
    if self.startDate is not None:
3293 vikas 10061 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10062 
      oprot.writeI64(self.startDate)
10063 
      oprot.writeFieldEnd()
3431 rajveer 10064 
    if self.endDate is not None:
3293 vikas 10065 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10066 
      oprot.writeI64(self.endDate)
10067 
      oprot.writeFieldEnd()
1845 vikas 10068 
    oprot.writeFieldStop()
10069 
    oprot.writeStructEnd()
10070 
 
3431 rajveer 10071 
  def validate(self):
10072 
    return
10073 
 
10074 
 
1845 vikas 10075 
  def __repr__(self):
10076 
    L = ['%s=%r' % (key, value)
10077 
      for key, value in self.__dict__.iteritems()]
10078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10079 
 
10080 
  def __eq__(self, other):
10081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10082 
 
10083 
  def __ne__(self, other):
10084 
    return not (self == other)
10085 
 
1996 vikas 10086 
class getTrackLogsByAffiliate_result:
1845 vikas 10087 
  """
10088 
  Attributes:
10089 
   - success
10090 
   - utx
10091 
  """
10092 
 
10093 
  thrift_spec = (
10094 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10095 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10096 
  )
10097 
 
10098 
  def __init__(self, success=None, utx=None,):
10099 
    self.success = success
10100 
    self.utx = utx
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      if fid == 0:
10112 
        if ftype == TType.LIST:
10113 
          self.success = []
11592 amit.gupta 10114 
          (_etype135, _size132) = iprot.readListBegin()
10115 
          for _i136 in xrange(_size132):
10116 
            _elem137 = TrackLog()
10117 
            _elem137.read(iprot)
10118 
            self.success.append(_elem137)
1845 vikas 10119 
          iprot.readListEnd()
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      elif fid == 1:
10123 
        if ftype == TType.STRUCT:
1996 vikas 10124 
          self.utx = UserAffiliateException()
1845 vikas 10125 
          self.utx.read(iprot)
10126 
        else:
10127 
          iprot.skip(ftype)
10128 
      else:
10129 
        iprot.skip(ftype)
10130 
      iprot.readFieldEnd()
10131 
    iprot.readStructEnd()
10132 
 
10133 
  def write(self, oprot):
10134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10136 
      return
1996 vikas 10137 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10138 
    if self.success is not None:
1845 vikas 10139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10141 
      for iter138 in self.success:
10142 
        iter138.write(oprot)
1845 vikas 10143 
      oprot.writeListEnd()
10144 
      oprot.writeFieldEnd()
3431 rajveer 10145 
    if self.utx is not None:
1845 vikas 10146 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10147 
      self.utx.write(oprot)
10148 
      oprot.writeFieldEnd()
10149 
    oprot.writeFieldStop()
10150 
    oprot.writeStructEnd()
10151 
 
3431 rajveer 10152 
  def validate(self):
10153 
    return
10154 
 
10155 
 
1845 vikas 10156 
  def __repr__(self):
10157 
    L = ['%s=%r' % (key, value)
10158 
      for key, value in self.__dict__.iteritems()]
10159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10160 
 
10161 
  def __eq__(self, other):
10162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10163 
 
10164 
  def __ne__(self, other):
10165 
    return not (self == other)
10166 
 
10167 
class getTrackLogsByUser_args:
10168 
  """
10169 
  Attributes:
10170 
   - userId
10171 
  """
10172 
 
10173 
  thrift_spec = (
10174 
    None, # 0
10175 
    (1, TType.I64, 'userId', None, None, ), # 1
10176 
  )
10177 
 
10178 
  def __init__(self, userId=None,):
10179 
    self.userId = userId
10180 
 
10181 
  def read(self, iprot):
10182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10184 
      return
10185 
    iprot.readStructBegin()
10186 
    while True:
10187 
      (fname, ftype, fid) = iprot.readFieldBegin()
10188 
      if ftype == TType.STOP:
10189 
        break
10190 
      if fid == 1:
10191 
        if ftype == TType.I64:
10192 
          self.userId = iprot.readI64();
10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      else:
10196 
        iprot.skip(ftype)
10197 
      iprot.readFieldEnd()
10198 
    iprot.readStructEnd()
10199 
 
10200 
  def write(self, oprot):
10201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10203 
      return
10204 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10205 
    if self.userId is not None:
1845 vikas 10206 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10207 
      oprot.writeI64(self.userId)
10208 
      oprot.writeFieldEnd()
10209 
    oprot.writeFieldStop()
10210 
    oprot.writeStructEnd()
10211 
 
3431 rajveer 10212 
  def validate(self):
10213 
    return
10214 
 
10215 
 
1845 vikas 10216 
  def __repr__(self):
10217 
    L = ['%s=%r' % (key, value)
10218 
      for key, value in self.__dict__.iteritems()]
10219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10220 
 
10221 
  def __eq__(self, other):
10222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10223 
 
10224 
  def __ne__(self, other):
10225 
    return not (self == other)
10226 
 
10227 
class getTrackLogsByUser_result:
10228 
  """
10229 
  Attributes:
10230 
   - success
10231 
   - utx
10232 
  """
10233 
 
10234 
  thrift_spec = (
10235 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10236 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10237 
  )
10238 
 
10239 
  def __init__(self, success=None, utx=None,):
10240 
    self.success = success
10241 
    self.utx = utx
10242 
 
10243 
  def read(self, iprot):
10244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10246 
      return
10247 
    iprot.readStructBegin()
10248 
    while True:
10249 
      (fname, ftype, fid) = iprot.readFieldBegin()
10250 
      if ftype == TType.STOP:
10251 
        break
10252 
      if fid == 0:
10253 
        if ftype == TType.LIST:
10254 
          self.success = []
11592 amit.gupta 10255 
          (_etype142, _size139) = iprot.readListBegin()
10256 
          for _i143 in xrange(_size139):
10257 
            _elem144 = TrackLog()
10258 
            _elem144.read(iprot)
10259 
            self.success.append(_elem144)
1845 vikas 10260 
          iprot.readListEnd()
10261 
        else:
10262 
          iprot.skip(ftype)
10263 
      elif fid == 1:
10264 
        if ftype == TType.STRUCT:
1996 vikas 10265 
          self.utx = UserAffiliateException()
1845 vikas 10266 
          self.utx.read(iprot)
10267 
        else:
10268 
          iprot.skip(ftype)
10269 
      else:
10270 
        iprot.skip(ftype)
10271 
      iprot.readFieldEnd()
10272 
    iprot.readStructEnd()
10273 
 
10274 
  def write(self, oprot):
10275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10277 
      return
10278 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10279 
    if self.success is not None:
1845 vikas 10280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10282 
      for iter145 in self.success:
10283 
        iter145.write(oprot)
1845 vikas 10284 
      oprot.writeListEnd()
10285 
      oprot.writeFieldEnd()
3431 rajveer 10286 
    if self.utx is not None:
1845 vikas 10287 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10288 
      self.utx.write(oprot)
10289 
      oprot.writeFieldEnd()
10290 
    oprot.writeFieldStop()
10291 
    oprot.writeStructEnd()
10292 
 
3431 rajveer 10293 
  def validate(self):
10294 
    return
10295 
 
10296 
 
1845 vikas 10297 
  def __repr__(self):
10298 
    L = ['%s=%r' % (key, value)
10299 
      for key, value in self.__dict__.iteritems()]
10300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10301 
 
10302 
  def __eq__(self, other):
10303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10304 
 
10305 
  def __ne__(self, other):
10306 
    return not (self == other)
10307 
 
10308 
class getTrackLogs_args:
10309 
  """
10310 
  Attributes:
10311 
   - userId
10312 
   - event
10313 
   - url
10314 
  """
10315 
 
10316 
  thrift_spec = (
10317 
    None, # 0
1996 vikas 10318 
    (1, TType.I64, 'userId', None, None, ), # 1
10319 
    (2, TType.STRING, 'event', None, None, ), # 2
10320 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10321 
  )
10322 
 
1996 vikas 10323 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10324 
    self.userId = userId
10325 
    self.event = event
10326 
    self.url = url
10327 
 
10328 
  def read(self, iprot):
10329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10331 
      return
10332 
    iprot.readStructBegin()
10333 
    while True:
10334 
      (fname, ftype, fid) = iprot.readFieldBegin()
10335 
      if ftype == TType.STOP:
10336 
        break
10337 
      if fid == 1:
10338 
        if ftype == TType.I64:
1996 vikas 10339 
          self.userId = iprot.readI64();
1845 vikas 10340 
        else:
10341 
          iprot.skip(ftype)
10342 
      elif fid == 2:
10343 
        if ftype == TType.STRING:
10344 
          self.event = iprot.readString();
10345 
        else:
10346 
          iprot.skip(ftype)
1996 vikas 10347 
      elif fid == 3:
1845 vikas 10348 
        if ftype == TType.STRING:
10349 
          self.url = iprot.readString();
10350 
        else:
10351 
          iprot.skip(ftype)
10352 
      else:
10353 
        iprot.skip(ftype)
10354 
      iprot.readFieldEnd()
10355 
    iprot.readStructEnd()
10356 
 
10357 
  def write(self, oprot):
10358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10360 
      return
10361 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10362 
    if self.userId is not None:
1996 vikas 10363 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10364 
      oprot.writeI64(self.userId)
10365 
      oprot.writeFieldEnd()
3431 rajveer 10366 
    if self.event is not None:
1996 vikas 10367 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10368 
      oprot.writeString(self.event)
10369 
      oprot.writeFieldEnd()
3431 rajveer 10370 
    if self.url is not None:
1996 vikas 10371 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10372 
      oprot.writeString(self.url)
10373 
      oprot.writeFieldEnd()
10374 
    oprot.writeFieldStop()
10375 
    oprot.writeStructEnd()
10376 
 
3431 rajveer 10377 
  def validate(self):
10378 
    return
10379 
 
10380 
 
1845 vikas 10381 
  def __repr__(self):
10382 
    L = ['%s=%r' % (key, value)
10383 
      for key, value in self.__dict__.iteritems()]
10384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10385 
 
10386 
  def __eq__(self, other):
10387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10388 
 
10389 
  def __ne__(self, other):
10390 
    return not (self == other)
10391 
 
10392 
class getTrackLogs_result:
10393 
  """
10394 
  Attributes:
10395 
   - success
10396 
   - utx
10397 
  """
10398 
 
10399 
  thrift_spec = (
10400 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10401 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10402 
  )
10403 
 
10404 
  def __init__(self, success=None, utx=None,):
10405 
    self.success = success
10406 
    self.utx = utx
10407 
 
10408 
  def read(self, iprot):
10409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10411 
      return
10412 
    iprot.readStructBegin()
10413 
    while True:
10414 
      (fname, ftype, fid) = iprot.readFieldBegin()
10415 
      if ftype == TType.STOP:
10416 
        break
10417 
      if fid == 0:
10418 
        if ftype == TType.LIST:
10419 
          self.success = []
11592 amit.gupta 10420 
          (_etype149, _size146) = iprot.readListBegin()
10421 
          for _i150 in xrange(_size146):
10422 
            _elem151 = TrackLog()
10423 
            _elem151.read(iprot)
10424 
            self.success.append(_elem151)
1845 vikas 10425 
          iprot.readListEnd()
10426 
        else:
10427 
          iprot.skip(ftype)
10428 
      elif fid == 1:
10429 
        if ftype == TType.STRUCT:
1996 vikas 10430 
          self.utx = UserAffiliateException()
1845 vikas 10431 
          self.utx.read(iprot)
10432 
        else:
10433 
          iprot.skip(ftype)
10434 
      else:
10435 
        iprot.skip(ftype)
10436 
      iprot.readFieldEnd()
10437 
    iprot.readStructEnd()
10438 
 
10439 
  def write(self, oprot):
10440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10442 
      return
10443 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10444 
    if self.success is not None:
1845 vikas 10445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10447 
      for iter152 in self.success:
10448 
        iter152.write(oprot)
1845 vikas 10449 
      oprot.writeListEnd()
10450 
      oprot.writeFieldEnd()
3431 rajveer 10451 
    if self.utx is not None:
1845 vikas 10452 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10453 
      self.utx.write(oprot)
10454 
      oprot.writeFieldEnd()
10455 
    oprot.writeFieldStop()
10456 
    oprot.writeStructEnd()
10457 
 
3431 rajveer 10458 
  def validate(self):
10459 
    return
10460 
 
10461 
 
1845 vikas 10462 
  def __repr__(self):
10463 
    L = ['%s=%r' % (key, value)
10464 
      for key, value in self.__dict__.iteritems()]
10465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10466 
 
10467 
  def __eq__(self, other):
10468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10469 
 
10470 
  def __ne__(self, other):
10471 
    return not (self == other)
10472 
 
559 chandransh 10473 
class getCurrentCart_args:
94 ashish 10474 
  """
10475 
  Attributes:
559 chandransh 10476 
   - userId
10477 
  """
10478 
 
10479 
  thrift_spec = (
10480 
    None, # 0
10481 
    (1, TType.I64, 'userId', None, None, ), # 1
10482 
  )
10483 
 
10484 
  def __init__(self, userId=None,):
10485 
    self.userId = userId
10486 
 
10487 
  def read(self, iprot):
10488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10490 
      return
10491 
    iprot.readStructBegin()
10492 
    while True:
10493 
      (fname, ftype, fid) = iprot.readFieldBegin()
10494 
      if ftype == TType.STOP:
10495 
        break
10496 
      if fid == 1:
10497 
        if ftype == TType.I64:
10498 
          self.userId = iprot.readI64();
10499 
        else:
10500 
          iprot.skip(ftype)
10501 
      else:
10502 
        iprot.skip(ftype)
10503 
      iprot.readFieldEnd()
10504 
    iprot.readStructEnd()
10505 
 
10506 
  def write(self, oprot):
10507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10509 
      return
10510 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10511 
    if self.userId is not None:
559 chandransh 10512 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10513 
      oprot.writeI64(self.userId)
10514 
      oprot.writeFieldEnd()
10515 
    oprot.writeFieldStop()
10516 
    oprot.writeStructEnd()
10517 
 
3431 rajveer 10518 
  def validate(self):
10519 
    return
10520 
 
10521 
 
559 chandransh 10522 
  def __repr__(self):
10523 
    L = ['%s=%r' % (key, value)
10524 
      for key, value in self.__dict__.iteritems()]
10525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10526 
 
10527 
  def __eq__(self, other):
10528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10529 
 
10530 
  def __ne__(self, other):
10531 
    return not (self == other)
10532 
 
10533 
class getCurrentCart_result:
10534 
  """
10535 
  Attributes:
94 ashish 10536 
   - success
559 chandransh 10537 
   - scx
94 ashish 10538 
  """
10539 
 
10540 
  thrift_spec = (
559 chandransh 10541 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10542 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10543 
  )
10544 
 
559 chandransh 10545 
  def __init__(self, success=None, scx=None,):
94 ashish 10546 
    self.success = success
559 chandransh 10547 
    self.scx = scx
94 ashish 10548 
 
10549 
  def read(self, iprot):
10550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10552 
      return
10553 
    iprot.readStructBegin()
10554 
    while True:
10555 
      (fname, ftype, fid) = iprot.readFieldBegin()
10556 
      if ftype == TType.STOP:
10557 
        break
10558 
      if fid == 0:
559 chandransh 10559 
        if ftype == TType.STRUCT:
10560 
          self.success = Cart()
10561 
          self.success.read(iprot)
94 ashish 10562 
        else:
10563 
          iprot.skip(ftype)
10564 
      elif fid == 1:
10565 
        if ftype == TType.STRUCT:
559 chandransh 10566 
          self.scx = ShoppingCartException()
10567 
          self.scx.read(iprot)
94 ashish 10568 
        else:
10569 
          iprot.skip(ftype)
10570 
      else:
10571 
        iprot.skip(ftype)
10572 
      iprot.readFieldEnd()
10573 
    iprot.readStructEnd()
10574 
 
10575 
  def write(self, oprot):
10576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10578 
      return
559 chandransh 10579 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10580 
    if self.success is not None:
559 chandransh 10581 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10582 
      self.success.write(oprot)
94 ashish 10583 
      oprot.writeFieldEnd()
3431 rajveer 10584 
    if self.scx is not None:
559 chandransh 10585 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10586 
      self.scx.write(oprot)
94 ashish 10587 
      oprot.writeFieldEnd()
10588 
    oprot.writeFieldStop()
10589 
    oprot.writeStructEnd()
10590 
 
3431 rajveer 10591 
  def validate(self):
10592 
    return
10593 
 
10594 
 
94 ashish 10595 
  def __repr__(self):
10596 
    L = ['%s=%r' % (key, value)
10597 
      for key, value in self.__dict__.iteritems()]
10598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10599 
 
10600 
  def __eq__(self, other):
10601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10602 
 
10603 
  def __ne__(self, other):
10604 
    return not (self == other)
10605 
 
559 chandransh 10606 
class getCart_args:
504 rajveer 10607 
  """
10608 
  Attributes:
559 chandransh 10609 
   - cartId
504 rajveer 10610 
  """
10611 
 
10612 
  thrift_spec = (
10613 
    None, # 0
559 chandransh 10614 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10615 
  )
10616 
 
559 chandransh 10617 
  def __init__(self, cartId=None,):
10618 
    self.cartId = cartId
504 rajveer 10619 
 
10620 
  def read(self, iprot):
10621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10623 
      return
10624 
    iprot.readStructBegin()
10625 
    while True:
10626 
      (fname, ftype, fid) = iprot.readFieldBegin()
10627 
      if ftype == TType.STOP:
10628 
        break
10629 
      if fid == 1:
10630 
        if ftype == TType.I64:
559 chandransh 10631 
          self.cartId = iprot.readI64();
504 rajveer 10632 
        else:
10633 
          iprot.skip(ftype)
10634 
      else:
10635 
        iprot.skip(ftype)
10636 
      iprot.readFieldEnd()
10637 
    iprot.readStructEnd()
10638 
 
10639 
  def write(self, oprot):
10640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10642 
      return
559 chandransh 10643 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10644 
    if self.cartId is not None:
559 chandransh 10645 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10646 
      oprot.writeI64(self.cartId)
504 rajveer 10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
3431 rajveer 10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
504 rajveer 10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
559 chandransh 10666 
class getCart_result:
504 rajveer 10667 
  """
10668 
  Attributes:
10669 
   - success
559 chandransh 10670 
   - scx
504 rajveer 10671 
  """
10672 
 
10673 
  thrift_spec = (
559 chandransh 10674 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10675 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10676 
  )
10677 
 
559 chandransh 10678 
  def __init__(self, success=None, scx=None,):
504 rajveer 10679 
    self.success = success
559 chandransh 10680 
    self.scx = scx
504 rajveer 10681 
 
10682 
  def read(self, iprot):
10683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10685 
      return
10686 
    iprot.readStructBegin()
10687 
    while True:
10688 
      (fname, ftype, fid) = iprot.readFieldBegin()
10689 
      if ftype == TType.STOP:
10690 
        break
10691 
      if fid == 0:
559 chandransh 10692 
        if ftype == TType.STRUCT:
10693 
          self.success = Cart()
10694 
          self.success.read(iprot)
504 rajveer 10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      elif fid == 1:
10698 
        if ftype == TType.STRUCT:
559 chandransh 10699 
          self.scx = ShoppingCartException()
10700 
          self.scx.read(iprot)
504 rajveer 10701 
        else:
10702 
          iprot.skip(ftype)
10703 
      else:
10704 
        iprot.skip(ftype)
10705 
      iprot.readFieldEnd()
10706 
    iprot.readStructEnd()
10707 
 
10708 
  def write(self, oprot):
10709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10711 
      return
559 chandransh 10712 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10713 
    if self.success is not None:
559 chandransh 10714 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10715 
      self.success.write(oprot)
504 rajveer 10716 
      oprot.writeFieldEnd()
3431 rajveer 10717 
    if self.scx is not None:
559 chandransh 10718 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10719 
      self.scx.write(oprot)
504 rajveer 10720 
      oprot.writeFieldEnd()
10721 
    oprot.writeFieldStop()
10722 
    oprot.writeStructEnd()
10723 
 
3431 rajveer 10724 
  def validate(self):
10725 
    return
10726 
 
10727 
 
504 rajveer 10728 
  def __repr__(self):
10729 
    L = ['%s=%r' % (key, value)
10730 
      for key, value in self.__dict__.iteritems()]
10731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10732 
 
10733 
  def __eq__(self, other):
10734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10735 
 
10736 
  def __ne__(self, other):
10737 
    return not (self == other)
10738 
 
559 chandransh 10739 
class getCartsByTime_args:
10740 
  """
10741 
  Attributes:
10742 
   - from_time
10743 
   - to_time
10744 
   - status
10745 
  """
10746 
 
10747 
  thrift_spec = (
10748 
    None, # 0
10749 
    (1, TType.I64, 'from_time', None, None, ), # 1
10750 
    (2, TType.I64, 'to_time', None, None, ), # 2
10751 
    (3, TType.I32, 'status', None, None, ), # 3
10752 
  )
10753 
 
10754 
  def __init__(self, from_time=None, to_time=None, status=None,):
10755 
    self.from_time = from_time
10756 
    self.to_time = to_time
10757 
    self.status = status
10758 
 
10759 
  def read(self, iprot):
10760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10762 
      return
10763 
    iprot.readStructBegin()
10764 
    while True:
10765 
      (fname, ftype, fid) = iprot.readFieldBegin()
10766 
      if ftype == TType.STOP:
10767 
        break
10768 
      if fid == 1:
94 ashish 10769 
        if ftype == TType.I64:
559 chandransh 10770 
          self.from_time = iprot.readI64();
94 ashish 10771 
        else:
10772 
          iprot.skip(ftype)
122 ashish 10773 
      elif fid == 2:
559 chandransh 10774 
        if ftype == TType.I64:
10775 
          self.to_time = iprot.readI64();
122 ashish 10776 
        else:
10777 
          iprot.skip(ftype)
559 chandransh 10778 
      elif fid == 3:
10779 
        if ftype == TType.I32:
10780 
          self.status = iprot.readI32();
10781 
        else:
10782 
          iprot.skip(ftype)
94 ashish 10783 
      else:
10784 
        iprot.skip(ftype)
10785 
      iprot.readFieldEnd()
10786 
    iprot.readStructEnd()
10787 
 
10788 
  def write(self, oprot):
10789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10791 
      return
559 chandransh 10792 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10793 
    if self.from_time is not None:
559 chandransh 10794 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10795 
      oprot.writeI64(self.from_time)
94 ashish 10796 
      oprot.writeFieldEnd()
3431 rajveer 10797 
    if self.to_time is not None:
559 chandransh 10798 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10799 
      oprot.writeI64(self.to_time)
122 ashish 10800 
      oprot.writeFieldEnd()
3431 rajveer 10801 
    if self.status is not None:
559 chandransh 10802 
      oprot.writeFieldBegin('status', TType.I32, 3)
10803 
      oprot.writeI32(self.status)
10804 
      oprot.writeFieldEnd()
94 ashish 10805 
    oprot.writeFieldStop()
10806 
    oprot.writeStructEnd()
10807 
 
3431 rajveer 10808 
  def validate(self):
10809 
    return
10810 
 
10811 
 
94 ashish 10812 
  def __repr__(self):
10813 
    L = ['%s=%r' % (key, value)
10814 
      for key, value in self.__dict__.iteritems()]
10815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10816 
 
10817 
  def __eq__(self, other):
10818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10819 
 
10820 
  def __ne__(self, other):
10821 
    return not (self == other)
10822 
 
559 chandransh 10823 
class getCartsByTime_result:
94 ashish 10824 
  """
10825 
  Attributes:
10826 
   - success
559 chandransh 10827 
   - scx
94 ashish 10828 
  """
10829 
 
10830 
  thrift_spec = (
559 chandransh 10831 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10832 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10833 
  )
10834 
 
559 chandransh 10835 
  def __init__(self, success=None, scx=None,):
94 ashish 10836 
    self.success = success
559 chandransh 10837 
    self.scx = scx
94 ashish 10838 
 
10839 
  def read(self, iprot):
10840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10842 
      return
10843 
    iprot.readStructBegin()
10844 
    while True:
10845 
      (fname, ftype, fid) = iprot.readFieldBegin()
10846 
      if ftype == TType.STOP:
10847 
        break
10848 
      if fid == 0:
559 chandransh 10849 
        if ftype == TType.LIST:
10850 
          self.success = []
11592 amit.gupta 10851 
          (_etype156, _size153) = iprot.readListBegin()
10852 
          for _i157 in xrange(_size153):
10853 
            _elem158 = Cart()
10854 
            _elem158.read(iprot)
10855 
            self.success.append(_elem158)
559 chandransh 10856 
          iprot.readListEnd()
94 ashish 10857 
        else:
10858 
          iprot.skip(ftype)
10859 
      elif fid == 1:
10860 
        if ftype == TType.STRUCT:
559 chandransh 10861 
          self.scx = ShoppingCartException()
10862 
          self.scx.read(iprot)
94 ashish 10863 
        else:
10864 
          iprot.skip(ftype)
10865 
      else:
10866 
        iprot.skip(ftype)
10867 
      iprot.readFieldEnd()
10868 
    iprot.readStructEnd()
10869 
 
10870 
  def write(self, oprot):
10871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10873 
      return
559 chandransh 10874 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10875 
    if self.success is not None:
559 chandransh 10876 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10877 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10878 
      for iter159 in self.success:
10879 
        iter159.write(oprot)
559 chandransh 10880 
      oprot.writeListEnd()
94 ashish 10881 
      oprot.writeFieldEnd()
3431 rajveer 10882 
    if self.scx is not None:
559 chandransh 10883 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10884 
      self.scx.write(oprot)
94 ashish 10885 
      oprot.writeFieldEnd()
10886 
    oprot.writeFieldStop()
10887 
    oprot.writeStructEnd()
10888 
 
3431 rajveer 10889 
  def validate(self):
10890 
    return
10891 
 
10892 
 
94 ashish 10893 
  def __repr__(self):
10894 
    L = ['%s=%r' % (key, value)
10895 
      for key, value in self.__dict__.iteritems()]
10896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10897 
 
10898 
  def __eq__(self, other):
10899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10900 
 
10901 
  def __ne__(self, other):
10902 
    return not (self == other)
10903 
 
559 chandransh 10904 
class addItemToCart_args:
10905 
  """
10906 
  Attributes:
10907 
   - cartId
10908 
   - itemId
10909 
   - quantity
3557 rajveer 10910 
   - sourceId
559 chandransh 10911 
  """
10912 
 
10913 
  thrift_spec = (
10914 
    None, # 0
10915 
    (1, TType.I64, 'cartId', None, None, ), # 1
10916 
    (2, TType.I64, 'itemId', None, None, ), # 2
10917 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10918 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10919 
  )
10920 
 
3557 rajveer 10921 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10922 
    self.cartId = cartId
10923 
    self.itemId = itemId
10924 
    self.quantity = quantity
3557 rajveer 10925 
    self.sourceId = sourceId
559 chandransh 10926 
 
10927 
  def read(self, iprot):
10928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10930 
      return
10931 
    iprot.readStructBegin()
10932 
    while True:
10933 
      (fname, ftype, fid) = iprot.readFieldBegin()
10934 
      if ftype == TType.STOP:
10935 
        break
10936 
      if fid == 1:
10937 
        if ftype == TType.I64:
10938 
          self.cartId = iprot.readI64();
10939 
        else:
10940 
          iprot.skip(ftype)
10941 
      elif fid == 2:
10942 
        if ftype == TType.I64:
10943 
          self.itemId = iprot.readI64();
10944 
        else:
10945 
          iprot.skip(ftype)
10946 
      elif fid == 3:
10947 
        if ftype == TType.I64:
10948 
          self.quantity = iprot.readI64();
10949 
        else:
10950 
          iprot.skip(ftype)
3557 rajveer 10951 
      elif fid == 4:
10952 
        if ftype == TType.I64:
10953 
          self.sourceId = iprot.readI64();
10954 
        else:
10955 
          iprot.skip(ftype)
559 chandransh 10956 
      else:
10957 
        iprot.skip(ftype)
10958 
      iprot.readFieldEnd()
10959 
    iprot.readStructEnd()
10960 
 
10961 
  def write(self, oprot):
10962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10964 
      return
10965 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10966 
    if self.cartId is not None:
559 chandransh 10967 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10968 
      oprot.writeI64(self.cartId)
10969 
      oprot.writeFieldEnd()
3431 rajveer 10970 
    if self.itemId is not None:
559 chandransh 10971 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10972 
      oprot.writeI64(self.itemId)
10973 
      oprot.writeFieldEnd()
3431 rajveer 10974 
    if self.quantity is not None:
559 chandransh 10975 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10976 
      oprot.writeI64(self.quantity)
10977 
      oprot.writeFieldEnd()
3557 rajveer 10978 
    if self.sourceId is not None:
10979 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10980 
      oprot.writeI64(self.sourceId)
10981 
      oprot.writeFieldEnd()
559 chandransh 10982 
    oprot.writeFieldStop()
10983 
    oprot.writeStructEnd()
10984 
 
3431 rajveer 10985 
  def validate(self):
10986 
    return
10987 
 
10988 
 
559 chandransh 10989 
  def __repr__(self):
10990 
    L = ['%s=%r' % (key, value)
10991 
      for key, value in self.__dict__.iteritems()]
10992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10993 
 
10994 
  def __eq__(self, other):
10995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10996 
 
10997 
  def __ne__(self, other):
10998 
    return not (self == other)
10999 
 
11000 
class addItemToCart_result:
11001 
  """
11002 
  Attributes:
2035 rajveer 11003 
   - success
559 chandransh 11004 
   - scx
11005 
  """
11006 
 
11007 
  thrift_spec = (
2035 rajveer 11008 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11009 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11010 
  )
11011 
 
2035 rajveer 11012 
  def __init__(self, success=None, scx=None,):
11013 
    self.success = success
559 chandransh 11014 
    self.scx = scx
11015 
 
11016 
  def read(self, iprot):
11017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11019 
      return
11020 
    iprot.readStructBegin()
11021 
    while True:
11022 
      (fname, ftype, fid) = iprot.readFieldBegin()
11023 
      if ftype == TType.STOP:
11024 
        break
2035 rajveer 11025 
      if fid == 0:
11026 
        if ftype == TType.STRING:
11027 
          self.success = iprot.readString();
11028 
        else:
11029 
          iprot.skip(ftype)
11030 
      elif fid == 1:
559 chandransh 11031 
        if ftype == TType.STRUCT:
11032 
          self.scx = ShoppingCartException()
11033 
          self.scx.read(iprot)
11034 
        else:
11035 
          iprot.skip(ftype)
11036 
      else:
11037 
        iprot.skip(ftype)
11038 
      iprot.readFieldEnd()
11039 
    iprot.readStructEnd()
11040 
 
11041 
  def write(self, oprot):
11042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11044 
      return
11045 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11046 
    if self.success is not None:
2035 rajveer 11047 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11048 
      oprot.writeString(self.success)
11049 
      oprot.writeFieldEnd()
3431 rajveer 11050 
    if self.scx is not None:
559 chandransh 11051 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11052 
      self.scx.write(oprot)
11053 
      oprot.writeFieldEnd()
11054 
    oprot.writeFieldStop()
11055 
    oprot.writeStructEnd()
11056 
 
3431 rajveer 11057 
  def validate(self):
11058 
    return
11059 
 
11060 
 
559 chandransh 11061 
  def __repr__(self):
11062 
    L = ['%s=%r' % (key, value)
11063 
      for key, value in self.__dict__.iteritems()]
11064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11065 
 
11066 
  def __eq__(self, other):
11067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11068 
 
11069 
  def __ne__(self, other):
11070 
    return not (self == other)
11071 
 
11072 
class deleteItemFromCart_args:
11073 
  """
11074 
  Attributes:
11075 
   - cartId
11076 
   - itemId
11077 
  """
11078 
 
11079 
  thrift_spec = (
11080 
    None, # 0
11081 
    (1, TType.I64, 'cartId', None, None, ), # 1
11082 
    (2, TType.I64, 'itemId', None, None, ), # 2
11083 
  )
11084 
 
11085 
  def __init__(self, cartId=None, itemId=None,):
11086 
    self.cartId = cartId
11087 
    self.itemId = itemId
11088 
 
11089 
  def read(self, iprot):
11090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11092 
      return
11093 
    iprot.readStructBegin()
11094 
    while True:
11095 
      (fname, ftype, fid) = iprot.readFieldBegin()
11096 
      if ftype == TType.STOP:
11097 
        break
11098 
      if fid == 1:
11099 
        if ftype == TType.I64:
11100 
          self.cartId = iprot.readI64();
11101 
        else:
11102 
          iprot.skip(ftype)
11103 
      elif fid == 2:
11104 
        if ftype == TType.I64:
11105 
          self.itemId = iprot.readI64();
11106 
        else:
11107 
          iprot.skip(ftype)
11108 
      else:
11109 
        iprot.skip(ftype)
11110 
      iprot.readFieldEnd()
11111 
    iprot.readStructEnd()
11112 
 
11113 
  def write(self, oprot):
11114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11116 
      return
11117 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11118 
    if self.cartId is not None:
559 chandransh 11119 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11120 
      oprot.writeI64(self.cartId)
11121 
      oprot.writeFieldEnd()
3431 rajveer 11122 
    if self.itemId is not None:
559 chandransh 11123 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11124 
      oprot.writeI64(self.itemId)
11125 
      oprot.writeFieldEnd()
11126 
    oprot.writeFieldStop()
11127 
    oprot.writeStructEnd()
11128 
 
3431 rajveer 11129 
  def validate(self):
11130 
    return
11131 
 
11132 
 
559 chandransh 11133 
  def __repr__(self):
11134 
    L = ['%s=%r' % (key, value)
11135 
      for key, value in self.__dict__.iteritems()]
11136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11137 
 
11138 
  def __eq__(self, other):
11139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11140 
 
11141 
  def __ne__(self, other):
11142 
    return not (self == other)
11143 
 
11144 
class deleteItemFromCart_result:
11145 
  """
11146 
  Attributes:
11147 
   - scx
11148 
  """
11149 
 
11150 
  thrift_spec = (
11151 
    None, # 0
11152 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11153 
  )
11154 
 
11155 
  def __init__(self, scx=None,):
11156 
    self.scx = scx
11157 
 
11158 
  def read(self, iprot):
11159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11161 
      return
11162 
    iprot.readStructBegin()
11163 
    while True:
11164 
      (fname, ftype, fid) = iprot.readFieldBegin()
11165 
      if ftype == TType.STOP:
11166 
        break
11167 
      if fid == 1:
11168 
        if ftype == TType.STRUCT:
11169 
          self.scx = ShoppingCartException()
11170 
          self.scx.read(iprot)
11171 
        else:
11172 
          iprot.skip(ftype)
11173 
      else:
11174 
        iprot.skip(ftype)
11175 
      iprot.readFieldEnd()
11176 
    iprot.readStructEnd()
11177 
 
11178 
  def write(self, oprot):
11179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11181 
      return
11182 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11183 
    if self.scx is not None:
559 chandransh 11184 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11185 
      self.scx.write(oprot)
11186 
      oprot.writeFieldEnd()
11187 
    oprot.writeFieldStop()
11188 
    oprot.writeStructEnd()
11189 
 
3431 rajveer 11190 
  def validate(self):
11191 
    return
11192 
 
11193 
 
559 chandransh 11194 
  def __repr__(self):
11195 
    L = ['%s=%r' % (key, value)
11196 
      for key, value in self.__dict__.iteritems()]
11197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11198 
 
11199 
  def __eq__(self, other):
11200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11201 
 
11202 
  def __ne__(self, other):
11203 
    return not (self == other)
11204 
 
11205 
class addAddressToCart_args:
11206 
  """
11207 
  Attributes:
11208 
   - cartId
11209 
   - addressId
11210 
  """
11211 
 
11212 
  thrift_spec = (
11213 
    None, # 0
11214 
    (1, TType.I64, 'cartId', None, None, ), # 1
11215 
    (2, TType.I64, 'addressId', None, None, ), # 2
11216 
  )
11217 
 
11218 
  def __init__(self, cartId=None, addressId=None,):
11219 
    self.cartId = cartId
11220 
    self.addressId = addressId
11221 
 
11222 
  def read(self, iprot):
11223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11225 
      return
11226 
    iprot.readStructBegin()
11227 
    while True:
11228 
      (fname, ftype, fid) = iprot.readFieldBegin()
11229 
      if ftype == TType.STOP:
11230 
        break
11231 
      if fid == 1:
11232 
        if ftype == TType.I64:
11233 
          self.cartId = iprot.readI64();
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      elif fid == 2:
11237 
        if ftype == TType.I64:
11238 
          self.addressId = iprot.readI64();
11239 
        else:
11240 
          iprot.skip(ftype)
11241 
      else:
11242 
        iprot.skip(ftype)
11243 
      iprot.readFieldEnd()
11244 
    iprot.readStructEnd()
11245 
 
11246 
  def write(self, oprot):
11247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11249 
      return
11250 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11251 
    if self.cartId is not None:
559 chandransh 11252 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11253 
      oprot.writeI64(self.cartId)
11254 
      oprot.writeFieldEnd()
3431 rajveer 11255 
    if self.addressId is not None:
559 chandransh 11256 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11257 
      oprot.writeI64(self.addressId)
11258 
      oprot.writeFieldEnd()
11259 
    oprot.writeFieldStop()
11260 
    oprot.writeStructEnd()
11261 
 
3431 rajveer 11262 
  def validate(self):
11263 
    return
11264 
 
11265 
 
559 chandransh 11266 
  def __repr__(self):
11267 
    L = ['%s=%r' % (key, value)
11268 
      for key, value in self.__dict__.iteritems()]
11269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11270 
 
11271 
  def __eq__(self, other):
11272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11273 
 
11274 
  def __ne__(self, other):
11275 
    return not (self == other)
11276 
 
11277 
class addAddressToCart_result:
575 chandransh 11278 
  """
11279 
  Attributes:
11280 
   - scx
11281 
  """
559 chandransh 11282 
 
11283 
  thrift_spec = (
575 chandransh 11284 
    None, # 0
11285 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11286 
  )
11287 
 
575 chandransh 11288 
  def __init__(self, scx=None,):
11289 
    self.scx = scx
11290 
 
559 chandransh 11291 
  def read(self, iprot):
11292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11294 
      return
11295 
    iprot.readStructBegin()
11296 
    while True:
11297 
      (fname, ftype, fid) = iprot.readFieldBegin()
11298 
      if ftype == TType.STOP:
11299 
        break
575 chandransh 11300 
      if fid == 1:
11301 
        if ftype == TType.STRUCT:
11302 
          self.scx = ShoppingCartException()
11303 
          self.scx.read(iprot)
11304 
        else:
11305 
          iprot.skip(ftype)
559 chandransh 11306 
      else:
11307 
        iprot.skip(ftype)
11308 
      iprot.readFieldEnd()
11309 
    iprot.readStructEnd()
11310 
 
11311 
  def write(self, oprot):
11312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11314 
      return
11315 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11316 
    if self.scx is not None:
575 chandransh 11317 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11318 
      self.scx.write(oprot)
11319 
      oprot.writeFieldEnd()
559 chandransh 11320 
    oprot.writeFieldStop()
11321 
    oprot.writeStructEnd()
11322 
 
3431 rajveer 11323 
  def validate(self):
11324 
    return
11325 
 
11326 
 
559 chandransh 11327 
  def __repr__(self):
11328 
    L = ['%s=%r' % (key, value)
11329 
      for key, value in self.__dict__.iteritems()]
11330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11331 
 
11332 
  def __eq__(self, other):
11333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11334 
 
11335 
  def __ne__(self, other):
11336 
    return not (self == other)
11337 
 
5553 rajveer 11338 
class addStoreToCart_args:
11339 
  """
11340 
  Attributes:
11341 
   - cartId
11342 
   - storeId
11343 
  """
11344 
 
11345 
  thrift_spec = (
11346 
    None, # 0
11347 
    (1, TType.I64, 'cartId', None, None, ), # 1
11348 
    (2, TType.I64, 'storeId', None, None, ), # 2
11349 
  )
11350 
 
11351 
  def __init__(self, cartId=None, storeId=None,):
11352 
    self.cartId = cartId
11353 
    self.storeId = storeId
11354 
 
11355 
  def read(self, iprot):
11356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11358 
      return
11359 
    iprot.readStructBegin()
11360 
    while True:
11361 
      (fname, ftype, fid) = iprot.readFieldBegin()
11362 
      if ftype == TType.STOP:
11363 
        break
11364 
      if fid == 1:
11365 
        if ftype == TType.I64:
11366 
          self.cartId = iprot.readI64();
11367 
        else:
11368 
          iprot.skip(ftype)
11369 
      elif fid == 2:
11370 
        if ftype == TType.I64:
11371 
          self.storeId = iprot.readI64();
11372 
        else:
11373 
          iprot.skip(ftype)
11374 
      else:
11375 
        iprot.skip(ftype)
11376 
      iprot.readFieldEnd()
11377 
    iprot.readStructEnd()
11378 
 
11379 
  def write(self, oprot):
11380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11382 
      return
11383 
    oprot.writeStructBegin('addStoreToCart_args')
11384 
    if self.cartId is not None:
11385 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11386 
      oprot.writeI64(self.cartId)
11387 
      oprot.writeFieldEnd()
11388 
    if self.storeId is not None:
11389 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11390 
      oprot.writeI64(self.storeId)
11391 
      oprot.writeFieldEnd()
11392 
    oprot.writeFieldStop()
11393 
    oprot.writeStructEnd()
11394 
 
11395 
  def validate(self):
11396 
    return
11397 
 
11398 
 
11399 
  def __repr__(self):
11400 
    L = ['%s=%r' % (key, value)
11401 
      for key, value in self.__dict__.iteritems()]
11402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11403 
 
11404 
  def __eq__(self, other):
11405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11406 
 
11407 
  def __ne__(self, other):
11408 
    return not (self == other)
11409 
 
11410 
class addStoreToCart_result:
11411 
  """
11412 
  Attributes:
11413 
   - scx
11414 
  """
11415 
 
11416 
  thrift_spec = (
11417 
    None, # 0
11418 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11419 
  )
11420 
 
11421 
  def __init__(self, scx=None,):
11422 
    self.scx = scx
11423 
 
11424 
  def read(self, iprot):
11425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11427 
      return
11428 
    iprot.readStructBegin()
11429 
    while True:
11430 
      (fname, ftype, fid) = iprot.readFieldBegin()
11431 
      if ftype == TType.STOP:
11432 
        break
11433 
      if fid == 1:
11434 
        if ftype == TType.STRUCT:
11435 
          self.scx = ShoppingCartException()
11436 
          self.scx.read(iprot)
11437 
        else:
11438 
          iprot.skip(ftype)
11439 
      else:
11440 
        iprot.skip(ftype)
11441 
      iprot.readFieldEnd()
11442 
    iprot.readStructEnd()
11443 
 
11444 
  def write(self, oprot):
11445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11447 
      return
11448 
    oprot.writeStructBegin('addStoreToCart_result')
11449 
    if self.scx is not None:
11450 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11451 
      self.scx.write(oprot)
11452 
      oprot.writeFieldEnd()
11453 
    oprot.writeFieldStop()
11454 
    oprot.writeStructEnd()
11455 
 
11456 
  def validate(self):
11457 
    return
11458 
 
11459 
 
11460 
  def __repr__(self):
11461 
    L = ['%s=%r' % (key, value)
11462 
      for key, value in self.__dict__.iteritems()]
11463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11464 
 
11465 
  def __eq__(self, other):
11466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11467 
 
11468 
  def __ne__(self, other):
11469 
    return not (self == other)
11470 
 
1976 varun.gupt 11471 
class applyCouponToCart_args:
11472 
  """
11473 
  Attributes:
6922 anupam.sin 11474 
   - cart
1976 varun.gupt 11475 
   - couponCode
11476 
  """
11477 
 
11478 
  thrift_spec = (
11479 
    None, # 0
6922 anupam.sin 11480 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11481 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11482 
  )
11483 
 
6922 anupam.sin 11484 
  def __init__(self, cart=None, couponCode=None,):
11485 
    self.cart = cart
1976 varun.gupt 11486 
    self.couponCode = couponCode
11487 
 
11488 
  def read(self, iprot):
11489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11491 
      return
11492 
    iprot.readStructBegin()
11493 
    while True:
11494 
      (fname, ftype, fid) = iprot.readFieldBegin()
11495 
      if ftype == TType.STOP:
11496 
        break
11497 
      if fid == 1:
6922 anupam.sin 11498 
        if ftype == TType.STRUCT:
11499 
          self.cart = Cart()
11500 
          self.cart.read(iprot)
1976 varun.gupt 11501 
        else:
11502 
          iprot.skip(ftype)
11503 
      elif fid == 2:
11504 
        if ftype == TType.STRING:
11505 
          self.couponCode = iprot.readString();
11506 
        else:
11507 
          iprot.skip(ftype)
11508 
      else:
11509 
        iprot.skip(ftype)
11510 
      iprot.readFieldEnd()
11511 
    iprot.readStructEnd()
11512 
 
11513 
  def write(self, oprot):
11514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11516 
      return
11517 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11518 
    if self.cart is not None:
11519 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11520 
      self.cart.write(oprot)
1976 varun.gupt 11521 
      oprot.writeFieldEnd()
3431 rajveer 11522 
    if self.couponCode is not None:
1976 varun.gupt 11523 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11524 
      oprot.writeString(self.couponCode)
11525 
      oprot.writeFieldEnd()
11526 
    oprot.writeFieldStop()
11527 
    oprot.writeStructEnd()
11528 
 
3431 rajveer 11529 
  def validate(self):
11530 
    return
11531 
 
11532 
 
1976 varun.gupt 11533 
  def __repr__(self):
11534 
    L = ['%s=%r' % (key, value)
11535 
      for key, value in self.__dict__.iteritems()]
11536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11537 
 
11538 
  def __eq__(self, other):
11539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11540 
 
11541 
  def __ne__(self, other):
11542 
    return not (self == other)
11543 
 
11544 
class applyCouponToCart_result:
11545 
  """
11546 
  Attributes:
11547 
   - scx
11548 
  """
11549 
 
11550 
  thrift_spec = (
11551 
    None, # 0
11552 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11553 
  )
11554 
 
11555 
  def __init__(self, scx=None,):
11556 
    self.scx = scx
11557 
 
11558 
  def read(self, iprot):
11559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11561 
      return
11562 
    iprot.readStructBegin()
11563 
    while True:
11564 
      (fname, ftype, fid) = iprot.readFieldBegin()
11565 
      if ftype == TType.STOP:
11566 
        break
11567 
      if fid == 1:
11568 
        if ftype == TType.STRUCT:
11569 
          self.scx = ShoppingCartException()
11570 
          self.scx.read(iprot)
11571 
        else:
11572 
          iprot.skip(ftype)
11573 
      else:
11574 
        iprot.skip(ftype)
11575 
      iprot.readFieldEnd()
11576 
    iprot.readStructEnd()
11577 
 
11578 
  def write(self, oprot):
11579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11581 
      return
11582 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11583 
    if self.scx is not None:
1976 varun.gupt 11584 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11585 
      self.scx.write(oprot)
11586 
      oprot.writeFieldEnd()
11587 
    oprot.writeFieldStop()
11588 
    oprot.writeStructEnd()
11589 
 
3431 rajveer 11590 
  def validate(self):
11591 
    return
11592 
 
11593 
 
1976 varun.gupt 11594 
  def __repr__(self):
11595 
    L = ['%s=%r' % (key, value)
11596 
      for key, value in self.__dict__.iteritems()]
11597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11598 
 
11599 
  def __eq__(self, other):
11600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11601 
 
11602 
  def __ne__(self, other):
11603 
    return not (self == other)
11604 
 
11605 
class removeCoupon_args:
11606 
  """
11607 
  Attributes:
11608 
   - cartId
11609 
  """
11610 
 
11611 
  thrift_spec = (
11612 
    None, # 0
11613 
    (1, TType.I64, 'cartId', None, None, ), # 1
11614 
  )
11615 
 
11616 
  def __init__(self, cartId=None,):
11617 
    self.cartId = cartId
11618 
 
11619 
  def read(self, iprot):
11620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11622 
      return
11623 
    iprot.readStructBegin()
11624 
    while True:
11625 
      (fname, ftype, fid) = iprot.readFieldBegin()
11626 
      if ftype == TType.STOP:
11627 
        break
11628 
      if fid == 1:
11629 
        if ftype == TType.I64:
11630 
          self.cartId = iprot.readI64();
11631 
        else:
11632 
          iprot.skip(ftype)
11633 
      else:
11634 
        iprot.skip(ftype)
11635 
      iprot.readFieldEnd()
11636 
    iprot.readStructEnd()
11637 
 
11638 
  def write(self, oprot):
11639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11641 
      return
11642 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11643 
    if self.cartId is not None:
1976 varun.gupt 11644 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11645 
      oprot.writeI64(self.cartId)
11646 
      oprot.writeFieldEnd()
11647 
    oprot.writeFieldStop()
11648 
    oprot.writeStructEnd()
11649 
 
3431 rajveer 11650 
  def validate(self):
11651 
    return
11652 
 
11653 
 
1976 varun.gupt 11654 
  def __repr__(self):
11655 
    L = ['%s=%r' % (key, value)
11656 
      for key, value in self.__dict__.iteritems()]
11657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11658 
 
11659 
  def __eq__(self, other):
11660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11661 
 
11662 
  def __ne__(self, other):
11663 
    return not (self == other)
11664 
 
11665 
class removeCoupon_result:
11666 
  """
11667 
  Attributes:
11668 
   - scx
11669 
  """
11670 
 
11671 
  thrift_spec = (
11672 
    None, # 0
11673 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11674 
  )
11675 
 
11676 
  def __init__(self, scx=None,):
11677 
    self.scx = scx
11678 
 
11679 
  def read(self, iprot):
11680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11682 
      return
11683 
    iprot.readStructBegin()
11684 
    while True:
11685 
      (fname, ftype, fid) = iprot.readFieldBegin()
11686 
      if ftype == TType.STOP:
11687 
        break
11688 
      if fid == 1:
11689 
        if ftype == TType.STRUCT:
11690 
          self.scx = ShoppingCartException()
11691 
          self.scx.read(iprot)
11692 
        else:
11693 
          iprot.skip(ftype)
11694 
      else:
11695 
        iprot.skip(ftype)
11696 
      iprot.readFieldEnd()
11697 
    iprot.readStructEnd()
11698 
 
11699 
  def write(self, oprot):
11700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11702 
      return
11703 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11704 
    if self.scx is not None:
1976 varun.gupt 11705 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11706 
      self.scx.write(oprot)
11707 
      oprot.writeFieldEnd()
11708 
    oprot.writeFieldStop()
11709 
    oprot.writeStructEnd()
11710 
 
3431 rajveer 11711 
  def validate(self):
11712 
    return
11713 
 
11714 
 
1976 varun.gupt 11715 
  def __repr__(self):
11716 
    L = ['%s=%r' % (key, value)
11717 
      for key, value in self.__dict__.iteritems()]
11718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11719 
 
11720 
  def __eq__(self, other):
11721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11722 
 
11723 
  def __ne__(self, other):
11724 
    return not (self == other)
11725 
 
3554 varun.gupt 11726 
class deleteDiscountsFromCart_args:
11727 
  """
11728 
  Attributes:
11729 
   - cartId
11730 
  """
11731 
 
11732 
  thrift_spec = (
11733 
    None, # 0
11734 
    (1, TType.I64, 'cartId', None, None, ), # 1
11735 
  )
11736 
 
11737 
  def __init__(self, cartId=None,):
11738 
    self.cartId = cartId
11739 
 
11740 
  def read(self, iprot):
11741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11743 
      return
11744 
    iprot.readStructBegin()
11745 
    while True:
11746 
      (fname, ftype, fid) = iprot.readFieldBegin()
11747 
      if ftype == TType.STOP:
11748 
        break
11749 
      if fid == 1:
11750 
        if ftype == TType.I64:
11751 
          self.cartId = iprot.readI64();
11752 
        else:
11753 
          iprot.skip(ftype)
11754 
      else:
11755 
        iprot.skip(ftype)
11756 
      iprot.readFieldEnd()
11757 
    iprot.readStructEnd()
11758 
 
11759 
  def write(self, oprot):
11760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11762 
      return
11763 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11764 
    if self.cartId is not None:
11765 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11766 
      oprot.writeI64(self.cartId)
11767 
      oprot.writeFieldEnd()
11768 
    oprot.writeFieldStop()
11769 
    oprot.writeStructEnd()
11770 
 
11771 
  def validate(self):
11772 
    return
11773 
 
11774 
 
11775 
  def __repr__(self):
11776 
    L = ['%s=%r' % (key, value)
11777 
      for key, value in self.__dict__.iteritems()]
11778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11779 
 
11780 
  def __eq__(self, other):
11781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11782 
 
11783 
  def __ne__(self, other):
11784 
    return not (self == other)
11785 
 
11786 
class deleteDiscountsFromCart_result:
11787 
  """
11788 
  Attributes:
11789 
   - scx
11790 
  """
11791 
 
11792 
  thrift_spec = (
11793 
    None, # 0
11794 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11795 
  )
11796 
 
11797 
  def __init__(self, scx=None,):
11798 
    self.scx = scx
11799 
 
11800 
  def read(self, iprot):
11801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11803 
      return
11804 
    iprot.readStructBegin()
11805 
    while True:
11806 
      (fname, ftype, fid) = iprot.readFieldBegin()
11807 
      if ftype == TType.STOP:
11808 
        break
11809 
      if fid == 1:
11810 
        if ftype == TType.STRUCT:
11811 
          self.scx = ShoppingCartException()
11812 
          self.scx.read(iprot)
11813 
        else:
11814 
          iprot.skip(ftype)
11815 
      else:
11816 
        iprot.skip(ftype)
11817 
      iprot.readFieldEnd()
11818 
    iprot.readStructEnd()
11819 
 
11820 
  def write(self, oprot):
11821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11823 
      return
11824 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11825 
    if self.scx is not None:
11826 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11827 
      self.scx.write(oprot)
11828 
      oprot.writeFieldEnd()
11829 
    oprot.writeFieldStop()
11830 
    oprot.writeStructEnd()
11831 
 
11832 
  def validate(self):
11833 
    return
11834 
 
11835 
 
11836 
  def __repr__(self):
11837 
    L = ['%s=%r' % (key, value)
11838 
      for key, value in self.__dict__.iteritems()]
11839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11840 
 
11841 
  def __eq__(self, other):
11842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11843 
 
11844 
  def __ne__(self, other):
11845 
    return not (self == other)
11846 
 
11847 
class saveDiscounts_args:
11848 
  """
11849 
  Attributes:
11850 
   - discounts
11851 
  """
11852 
 
11853 
  thrift_spec = (
11854 
    None, # 0
11855 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11856 
  )
11857 
 
11858 
  def __init__(self, discounts=None,):
11859 
    self.discounts = discounts
11860 
 
11861 
  def read(self, iprot):
11862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11864 
      return
11865 
    iprot.readStructBegin()
11866 
    while True:
11867 
      (fname, ftype, fid) = iprot.readFieldBegin()
11868 
      if ftype == TType.STOP:
11869 
        break
11870 
      if fid == 1:
11871 
        if ftype == TType.LIST:
11872 
          self.discounts = []
11592 amit.gupta 11873 
          (_etype163, _size160) = iprot.readListBegin()
11874 
          for _i164 in xrange(_size160):
11875 
            _elem165 = Discount()
11876 
            _elem165.read(iprot)
11877 
            self.discounts.append(_elem165)
3554 varun.gupt 11878 
          iprot.readListEnd()
11879 
        else:
11880 
          iprot.skip(ftype)
11881 
      else:
11882 
        iprot.skip(ftype)
11883 
      iprot.readFieldEnd()
11884 
    iprot.readStructEnd()
11885 
 
11886 
  def write(self, oprot):
11887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11889 
      return
11890 
    oprot.writeStructBegin('saveDiscounts_args')
11891 
    if self.discounts is not None:
11892 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11893 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11894 
      for iter166 in self.discounts:
11895 
        iter166.write(oprot)
3554 varun.gupt 11896 
      oprot.writeListEnd()
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
11915 
 
11916 
class saveDiscounts_result:
11917 
  """
11918 
  Attributes:
11919 
   - scx
11920 
  """
11921 
 
11922 
  thrift_spec = (
11923 
    None, # 0
11924 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11925 
  )
11926 
 
11927 
  def __init__(self, scx=None,):
11928 
    self.scx = scx
11929 
 
11930 
  def read(self, iprot):
11931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11933 
      return
11934 
    iprot.readStructBegin()
11935 
    while True:
11936 
      (fname, ftype, fid) = iprot.readFieldBegin()
11937 
      if ftype == TType.STOP:
11938 
        break
11939 
      if fid == 1:
11940 
        if ftype == TType.STRUCT:
11941 
          self.scx = ShoppingCartException()
11942 
          self.scx.read(iprot)
11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      else:
11946 
        iprot.skip(ftype)
11947 
      iprot.readFieldEnd()
11948 
    iprot.readStructEnd()
11949 
 
11950 
  def write(self, oprot):
11951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11953 
      return
11954 
    oprot.writeStructBegin('saveDiscounts_result')
11955 
    if self.scx is not None:
11956 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11957 
      self.scx.write(oprot)
11958 
      oprot.writeFieldEnd()
11959 
    oprot.writeFieldStop()
11960 
    oprot.writeStructEnd()
11961 
 
11962 
  def validate(self):
11963 
    return
11964 
 
11965 
 
11966 
  def __repr__(self):
11967 
    L = ['%s=%r' % (key, value)
11968 
      for key, value in self.__dict__.iteritems()]
11969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11970 
 
11971 
  def __eq__(self, other):
11972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11973 
 
11974 
  def __ne__(self, other):
11975 
    return not (self == other)
11976 
 
690 chandransh 11977 
class createOrders_args:
559 chandransh 11978 
  """
11979 
  Attributes:
11980 
   - cartId
2815 vikas 11981 
   - sessionSource
11982 
   - sessionStartTime
3858 vikas 11983 
   - firstSource
11984 
   - firstSourceTime
5326 rajveer 11985 
   - userId
6389 rajveer 11986 
   - schemeId
11526 amit.gupta 11987 
   - orderSource
559 chandransh 11988 
  """
11989 
 
11990 
  thrift_spec = (
11991 
    None, # 0
11992 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11993 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11994 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11995 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11996 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11997 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11998 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11999 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12000 
  )
12001 
 
11526 amit.gupta 12002 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12003 
    self.cartId = cartId
2815 vikas 12004 
    self.sessionSource = sessionSource
12005 
    self.sessionStartTime = sessionStartTime
3858 vikas 12006 
    self.firstSource = firstSource
12007 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12008 
    self.userId = userId
6389 rajveer 12009 
    self.schemeId = schemeId
11526 amit.gupta 12010 
    self.orderSource = orderSource
559 chandransh 12011 
 
12012 
  def read(self, iprot):
12013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12015 
      return
12016 
    iprot.readStructBegin()
12017 
    while True:
12018 
      (fname, ftype, fid) = iprot.readFieldBegin()
12019 
      if ftype == TType.STOP:
12020 
        break
12021 
      if fid == 1:
12022 
        if ftype == TType.I64:
12023 
          self.cartId = iprot.readI64();
12024 
        else:
12025 
          iprot.skip(ftype)
2815 vikas 12026 
      elif fid == 2:
12027 
        if ftype == TType.STRING:
12028 
          self.sessionSource = iprot.readString();
12029 
        else:
12030 
          iprot.skip(ftype)
12031 
      elif fid == 3:
12032 
        if ftype == TType.I64:
12033 
          self.sessionStartTime = iprot.readI64();
12034 
        else:
12035 
          iprot.skip(ftype)
3858 vikas 12036 
      elif fid == 4:
12037 
        if ftype == TType.STRING:
12038 
          self.firstSource = iprot.readString();
12039 
        else:
12040 
          iprot.skip(ftype)
12041 
      elif fid == 5:
12042 
        if ftype == TType.I64:
12043 
          self.firstSourceTime = iprot.readI64();
12044 
        else:
12045 
          iprot.skip(ftype)
5326 rajveer 12046 
      elif fid == 6:
12047 
        if ftype == TType.I64:
12048 
          self.userId = iprot.readI64();
12049 
        else:
12050 
          iprot.skip(ftype)
6389 rajveer 12051 
      elif fid == 7:
12052 
        if ftype == TType.I64:
12053 
          self.schemeId = iprot.readI64();
12054 
        else:
12055 
          iprot.skip(ftype)
11526 amit.gupta 12056 
      elif fid == 8:
12057 
        if ftype == TType.I64:
12058 
          self.orderSource = iprot.readI64();
12059 
        else:
12060 
          iprot.skip(ftype)
559 chandransh 12061 
      else:
12062 
        iprot.skip(ftype)
12063 
      iprot.readFieldEnd()
12064 
    iprot.readStructEnd()
12065 
 
12066 
  def write(self, oprot):
12067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12069 
      return
690 chandransh 12070 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12071 
    if self.cartId is not None:
559 chandransh 12072 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12073 
      oprot.writeI64(self.cartId)
12074 
      oprot.writeFieldEnd()
3431 rajveer 12075 
    if self.sessionSource is not None:
2815 vikas 12076 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12077 
      oprot.writeString(self.sessionSource)
12078 
      oprot.writeFieldEnd()
3431 rajveer 12079 
    if self.sessionStartTime is not None:
2815 vikas 12080 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12081 
      oprot.writeI64(self.sessionStartTime)
12082 
      oprot.writeFieldEnd()
3858 vikas 12083 
    if self.firstSource is not None:
12084 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12085 
      oprot.writeString(self.firstSource)
12086 
      oprot.writeFieldEnd()
12087 
    if self.firstSourceTime is not None:
12088 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12089 
      oprot.writeI64(self.firstSourceTime)
12090 
      oprot.writeFieldEnd()
5326 rajveer 12091 
    if self.userId is not None:
12092 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12093 
      oprot.writeI64(self.userId)
12094 
      oprot.writeFieldEnd()
6389 rajveer 12095 
    if self.schemeId is not None:
12096 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12097 
      oprot.writeI64(self.schemeId)
12098 
      oprot.writeFieldEnd()
11526 amit.gupta 12099 
    if self.orderSource is not None:
12100 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12101 
      oprot.writeI64(self.orderSource)
12102 
      oprot.writeFieldEnd()
559 chandransh 12103 
    oprot.writeFieldStop()
12104 
    oprot.writeStructEnd()
12105 
 
3431 rajveer 12106 
  def validate(self):
12107 
    return
12108 
 
12109 
 
559 chandransh 12110 
  def __repr__(self):
12111 
    L = ['%s=%r' % (key, value)
12112 
      for key, value in self.__dict__.iteritems()]
12113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12114 
 
12115 
  def __eq__(self, other):
12116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12117 
 
12118 
  def __ne__(self, other):
12119 
    return not (self == other)
12120 
 
690 chandransh 12121 
class createOrders_result:
559 chandransh 12122 
  """
12123 
  Attributes:
94 ashish 12124 
   - success
559 chandransh 12125 
   - scx
94 ashish 12126 
  """
12127 
 
12128 
  thrift_spec = (
575 chandransh 12129 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12130 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12131 
  )
12132 
 
559 chandransh 12133 
  def __init__(self, success=None, scx=None,):
94 ashish 12134 
    self.success = success
559 chandransh 12135 
    self.scx = scx
94 ashish 12136 
 
12137 
  def read(self, iprot):
12138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12140 
      return
12141 
    iprot.readStructBegin()
12142 
    while True:
12143 
      (fname, ftype, fid) = iprot.readFieldBegin()
12144 
      if ftype == TType.STOP:
12145 
        break
12146 
      if fid == 0:
575 chandransh 12147 
        if ftype == TType.I64:
12148 
          self.success = iprot.readI64();
94 ashish 12149 
        else:
12150 
          iprot.skip(ftype)
12151 
      elif fid == 1:
12152 
        if ftype == TType.STRUCT:
559 chandransh 12153 
          self.scx = ShoppingCartException()
12154 
          self.scx.read(iprot)
94 ashish 12155 
        else:
12156 
          iprot.skip(ftype)
12157 
      else:
12158 
        iprot.skip(ftype)
12159 
      iprot.readFieldEnd()
12160 
    iprot.readStructEnd()
12161 
 
12162 
  def write(self, oprot):
12163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12165 
      return
690 chandransh 12166 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12167 
    if self.success is not None:
575 chandransh 12168 
      oprot.writeFieldBegin('success', TType.I64, 0)
12169 
      oprot.writeI64(self.success)
94 ashish 12170 
      oprot.writeFieldEnd()
3431 rajveer 12171 
    if self.scx is not None:
559 chandransh 12172 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12173 
      self.scx.write(oprot)
94 ashish 12174 
      oprot.writeFieldEnd()
12175 
    oprot.writeFieldStop()
12176 
    oprot.writeStructEnd()
12177 
 
3431 rajveer 12178 
  def validate(self):
12179 
    return
12180 
 
12181 
 
94 ashish 12182 
  def __repr__(self):
12183 
    L = ['%s=%r' % (key, value)
12184 
      for key, value in self.__dict__.iteritems()]
12185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12186 
 
12187 
  def __eq__(self, other):
12188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12189 
 
12190 
  def __ne__(self, other):
12191 
    return not (self == other)
12192 
 
559 chandransh 12193 
class validateCart_args:
94 ashish 12194 
  """
12195 
  Attributes:
559 chandransh 12196 
   - cartId
3557 rajveer 12197 
   - sourceId
94 ashish 12198 
  """
12199 
 
12200 
  thrift_spec = (
12201 
    None, # 0
559 chandransh 12202 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12203 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12204 
  )
12205 
 
3557 rajveer 12206 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12207 
    self.cartId = cartId
3557 rajveer 12208 
    self.sourceId = sourceId
94 ashish 12209 
 
12210 
  def read(self, iprot):
12211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12213 
      return
12214 
    iprot.readStructBegin()
12215 
    while True:
12216 
      (fname, ftype, fid) = iprot.readFieldBegin()
12217 
      if ftype == TType.STOP:
12218 
        break
12219 
      if fid == 1:
12220 
        if ftype == TType.I64:
559 chandransh 12221 
          self.cartId = iprot.readI64();
94 ashish 12222 
        else:
12223 
          iprot.skip(ftype)
3557 rajveer 12224 
      elif fid == 2:
12225 
        if ftype == TType.I64:
12226 
          self.sourceId = iprot.readI64();
12227 
        else:
12228 
          iprot.skip(ftype)
94 ashish 12229 
      else:
12230 
        iprot.skip(ftype)
12231 
      iprot.readFieldEnd()
12232 
    iprot.readStructEnd()
12233 
 
12234 
  def write(self, oprot):
12235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12237 
      return
559 chandransh 12238 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12239 
    if self.cartId is not None:
559 chandransh 12240 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12241 
      oprot.writeI64(self.cartId)
94 ashish 12242 
      oprot.writeFieldEnd()
3557 rajveer 12243 
    if self.sourceId is not None:
12244 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12245 
      oprot.writeI64(self.sourceId)
12246 
      oprot.writeFieldEnd()
94 ashish 12247 
    oprot.writeFieldStop()
12248 
    oprot.writeStructEnd()
12249 
 
3431 rajveer 12250 
  def validate(self):
12251 
    return
12252 
 
12253 
 
94 ashish 12254 
  def __repr__(self):
12255 
    L = ['%s=%r' % (key, value)
12256 
      for key, value in self.__dict__.iteritems()]
12257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12258 
 
12259 
  def __eq__(self, other):
12260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12261 
 
12262 
  def __ne__(self, other):
12263 
    return not (self == other)
12264 
 
559 chandransh 12265 
class validateCart_result:
94 ashish 12266 
  """
12267 
  Attributes:
12268 
   - success
575 chandransh 12269 
   - scex
94 ashish 12270 
  """
12271 
 
12272 
  thrift_spec = (
6736 amit.gupta 12273 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12274 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12275 
  )
12276 
 
575 chandransh 12277 
  def __init__(self, success=None, scex=None,):
94 ashish 12278 
    self.success = success
575 chandransh 12279 
    self.scex = scex
94 ashish 12280 
 
12281 
  def read(self, iprot):
12282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12284 
      return
12285 
    iprot.readStructBegin()
12286 
    while True:
12287 
      (fname, ftype, fid) = iprot.readFieldBegin()
12288 
      if ftype == TType.STOP:
12289 
        break
12290 
      if fid == 0:
6736 amit.gupta 12291 
        if ftype == TType.LIST:
12292 
          self.success = []
11592 amit.gupta 12293 
          (_etype170, _size167) = iprot.readListBegin()
12294 
          for _i171 in xrange(_size167):
12295 
            _elem172 = iprot.readString();
12296 
            self.success.append(_elem172)
6736 amit.gupta 12297 
          iprot.readListEnd()
94 ashish 12298 
        else:
12299 
          iprot.skip(ftype)
575 chandransh 12300 
      elif fid == 1:
12301 
        if ftype == TType.STRUCT:
12302 
          self.scex = ShoppingCartException()
12303 
          self.scex.read(iprot)
12304 
        else:
12305 
          iprot.skip(ftype)
94 ashish 12306 
      else:
12307 
        iprot.skip(ftype)
12308 
      iprot.readFieldEnd()
12309 
    iprot.readStructEnd()
12310 
 
12311 
  def write(self, oprot):
12312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12314 
      return
559 chandransh 12315 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12316 
    if self.success is not None:
6736 amit.gupta 12317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12318 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12319 
      for iter173 in self.success:
12320 
        oprot.writeString(iter173)
6736 amit.gupta 12321 
      oprot.writeListEnd()
94 ashish 12322 
      oprot.writeFieldEnd()
3431 rajveer 12323 
    if self.scex is not None:
575 chandransh 12324 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12325 
      self.scex.write(oprot)
12326 
      oprot.writeFieldEnd()
559 chandransh 12327 
    oprot.writeFieldStop()
12328 
    oprot.writeStructEnd()
12329 
 
3431 rajveer 12330 
  def validate(self):
12331 
    return
12332 
 
12333 
 
559 chandransh 12334 
  def __repr__(self):
12335 
    L = ['%s=%r' % (key, value)
12336 
      for key, value in self.__dict__.iteritems()]
12337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12338 
 
12339 
  def __eq__(self, other):
12340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12341 
 
12342 
  def __ne__(self, other):
12343 
    return not (self == other)
12344 
 
11980 amit.gupta 12345 
class validateCartWithDealerCoupon_args:
12346 
  """
12347 
  Attributes:
12348 
   - cartId
12349 
   - sourceId
12350 
   - dealCoupon
12351 
  """
12352 
 
12353 
  thrift_spec = (
12354 
    None, # 0
12355 
    (1, TType.I64, 'cartId', None, None, ), # 1
12356 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12357 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12358 
  )
12359 
 
12360 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12361 
    self.cartId = cartId
12362 
    self.sourceId = sourceId
12363 
    self.dealCoupon = dealCoupon
12364 
 
12365 
  def read(self, iprot):
12366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12368 
      return
12369 
    iprot.readStructBegin()
12370 
    while True:
12371 
      (fname, ftype, fid) = iprot.readFieldBegin()
12372 
      if ftype == TType.STOP:
12373 
        break
12374 
      if fid == 1:
12375 
        if ftype == TType.I64:
12376 
          self.cartId = iprot.readI64();
12377 
        else:
12378 
          iprot.skip(ftype)
12379 
      elif fid == 2:
12380 
        if ftype == TType.I64:
12381 
          self.sourceId = iprot.readI64();
12382 
        else:
12383 
          iprot.skip(ftype)
12384 
      elif fid == 3:
12385 
        if ftype == TType.STRING:
12386 
          self.dealCoupon = iprot.readString();
12387 
        else:
12388 
          iprot.skip(ftype)
12389 
      else:
12390 
        iprot.skip(ftype)
12391 
      iprot.readFieldEnd()
12392 
    iprot.readStructEnd()
12393 
 
12394 
  def write(self, oprot):
12395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12397 
      return
12398 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12399 
    if self.cartId is not None:
12400 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12401 
      oprot.writeI64(self.cartId)
12402 
      oprot.writeFieldEnd()
12403 
    if self.sourceId is not None:
12404 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12405 
      oprot.writeI64(self.sourceId)
12406 
      oprot.writeFieldEnd()
12407 
    if self.dealCoupon is not None:
12408 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12409 
      oprot.writeString(self.dealCoupon)
12410 
      oprot.writeFieldEnd()
12411 
    oprot.writeFieldStop()
12412 
    oprot.writeStructEnd()
12413 
 
12414 
  def validate(self):
12415 
    return
12416 
 
12417 
 
12418 
  def __repr__(self):
12419 
    L = ['%s=%r' % (key, value)
12420 
      for key, value in self.__dict__.iteritems()]
12421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12422 
 
12423 
  def __eq__(self, other):
12424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12425 
 
12426 
  def __ne__(self, other):
12427 
    return not (self == other)
12428 
 
12429 
class validateCartWithDealerCoupon_result:
12430 
  """
12431 
  Attributes:
12432 
   - success
12433 
   - scex
12434 
  """
12435 
 
12436 
  thrift_spec = (
12437 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12438 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12439 
  )
12440 
 
12441 
  def __init__(self, success=None, scex=None,):
12442 
    self.success = success
12443 
    self.scex = scex
12444 
 
12445 
  def read(self, iprot):
12446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12448 
      return
12449 
    iprot.readStructBegin()
12450 
    while True:
12451 
      (fname, ftype, fid) = iprot.readFieldBegin()
12452 
      if ftype == TType.STOP:
12453 
        break
12454 
      if fid == 0:
12455 
        if ftype == TType.LIST:
12456 
          self.success = []
12457 
          (_etype177, _size174) = iprot.readListBegin()
12458 
          for _i178 in xrange(_size174):
12459 
            _elem179 = iprot.readString();
12460 
            self.success.append(_elem179)
12461 
          iprot.readListEnd()
12462 
        else:
12463 
          iprot.skip(ftype)
12464 
      elif fid == 1:
12465 
        if ftype == TType.STRUCT:
12466 
          self.scex = ShoppingCartException()
12467 
          self.scex.read(iprot)
12468 
        else:
12469 
          iprot.skip(ftype)
12470 
      else:
12471 
        iprot.skip(ftype)
12472 
      iprot.readFieldEnd()
12473 
    iprot.readStructEnd()
12474 
 
12475 
  def write(self, oprot):
12476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12478 
      return
12479 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12480 
    if self.success is not None:
12481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12482 
      oprot.writeListBegin(TType.STRING, len(self.success))
12483 
      for iter180 in self.success:
12484 
        oprot.writeString(iter180)
12485 
      oprot.writeListEnd()
12486 
      oprot.writeFieldEnd()
12487 
    if self.scex is not None:
12488 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12489 
      self.scex.write(oprot)
12490 
      oprot.writeFieldEnd()
12491 
    oprot.writeFieldStop()
12492 
    oprot.writeStructEnd()
12493 
 
12494 
  def validate(self):
12495 
    return
12496 
 
12497 
 
12498 
  def __repr__(self):
12499 
    L = ['%s=%r' % (key, value)
12500 
      for key, value in self.__dict__.iteritems()]
12501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12502 
 
12503 
  def __eq__(self, other):
12504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12505 
 
12506 
  def __ne__(self, other):
12507 
    return not (self == other)
12508 
 
690 chandransh 12509 
class mergeCart_args:
575 chandransh 12510 
  """
12511 
  Attributes:
690 chandransh 12512 
   - fromCartId
12513 
   - toCartId
12514 
  """
12515 
 
12516 
  thrift_spec = (
12517 
    None, # 0
12518 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12519 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12520 
  )
12521 
 
12522 
  def __init__(self, fromCartId=None, toCartId=None,):
12523 
    self.fromCartId = fromCartId
12524 
    self.toCartId = toCartId
12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      if fid == 1:
12536 
        if ftype == TType.I64:
12537 
          self.fromCartId = iprot.readI64();
12538 
        else:
12539 
          iprot.skip(ftype)
12540 
      elif fid == 2:
12541 
        if ftype == TType.I64:
12542 
          self.toCartId = iprot.readI64();
12543 
        else:
12544 
          iprot.skip(ftype)
12545 
      else:
12546 
        iprot.skip(ftype)
12547 
      iprot.readFieldEnd()
12548 
    iprot.readStructEnd()
12549 
 
12550 
  def write(self, oprot):
12551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12553 
      return
12554 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12555 
    if self.fromCartId is not None:
690 chandransh 12556 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12557 
      oprot.writeI64(self.fromCartId)
12558 
      oprot.writeFieldEnd()
3431 rajveer 12559 
    if self.toCartId is not None:
690 chandransh 12560 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12561 
      oprot.writeI64(self.toCartId)
12562 
      oprot.writeFieldEnd()
12563 
    oprot.writeFieldStop()
12564 
    oprot.writeStructEnd()
12565 
 
3431 rajveer 12566 
  def validate(self):
12567 
    return
12568 
 
12569 
 
690 chandransh 12570 
  def __repr__(self):
12571 
    L = ['%s=%r' % (key, value)
12572 
      for key, value in self.__dict__.iteritems()]
12573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12574 
 
12575 
  def __eq__(self, other):
12576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12577 
 
12578 
  def __ne__(self, other):
12579 
    return not (self == other)
12580 
 
12581 
class mergeCart_result:
12582 
 
12583 
  thrift_spec = (
12584 
  )
12585 
 
12586 
  def read(self, iprot):
12587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12589 
      return
12590 
    iprot.readStructBegin()
12591 
    while True:
12592 
      (fname, ftype, fid) = iprot.readFieldBegin()
12593 
      if ftype == TType.STOP:
12594 
        break
12595 
      else:
12596 
        iprot.skip(ftype)
12597 
      iprot.readFieldEnd()
12598 
    iprot.readStructEnd()
12599 
 
12600 
  def write(self, oprot):
12601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12603 
      return
12604 
    oprot.writeStructBegin('mergeCart_result')
12605 
    oprot.writeFieldStop()
12606 
    oprot.writeStructEnd()
12607 
 
3431 rajveer 12608 
  def validate(self):
12609 
    return
12610 
 
12611 
 
690 chandransh 12612 
  def __repr__(self):
12613 
    L = ['%s=%r' % (key, value)
12614 
      for key, value in self.__dict__.iteritems()]
12615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12616 
 
12617 
  def __eq__(self, other):
12618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12619 
 
12620 
  def __ne__(self, other):
12621 
    return not (self == other)
12622 
 
12623 
class checkOut_args:
12624 
  """
12625 
  Attributes:
575 chandransh 12626 
   - cartId
12627 
  """
12628 
 
12629 
  thrift_spec = (
12630 
    None, # 0
12631 
    (1, TType.I64, 'cartId', None, None, ), # 1
12632 
  )
12633 
 
12634 
  def __init__(self, cartId=None,):
12635 
    self.cartId = cartId
12636 
 
12637 
  def read(self, iprot):
12638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12640 
      return
12641 
    iprot.readStructBegin()
12642 
    while True:
12643 
      (fname, ftype, fid) = iprot.readFieldBegin()
12644 
      if ftype == TType.STOP:
12645 
        break
12646 
      if fid == 1:
12647 
        if ftype == TType.I64:
12648 
          self.cartId = iprot.readI64();
12649 
        else:
12650 
          iprot.skip(ftype)
12651 
      else:
12652 
        iprot.skip(ftype)
12653 
      iprot.readFieldEnd()
12654 
    iprot.readStructEnd()
12655 
 
12656 
  def write(self, oprot):
12657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12659 
      return
690 chandransh 12660 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12661 
    if self.cartId is not None:
575 chandransh 12662 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12663 
      oprot.writeI64(self.cartId)
12664 
      oprot.writeFieldEnd()
12665 
    oprot.writeFieldStop()
12666 
    oprot.writeStructEnd()
12667 
 
3431 rajveer 12668 
  def validate(self):
12669 
    return
12670 
 
12671 
 
575 chandransh 12672 
  def __repr__(self):
12673 
    L = ['%s=%r' % (key, value)
12674 
      for key, value in self.__dict__.iteritems()]
12675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12676 
 
12677 
  def __eq__(self, other):
12678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12679 
 
12680 
  def __ne__(self, other):
12681 
    return not (self == other)
12682 
 
690 chandransh 12683 
class checkOut_result:
575 chandransh 12684 
  """
12685 
  Attributes:
12686 
   - success
12687 
   - scex
12688 
  """
12689 
 
12690 
  thrift_spec = (
12691 
    (0, TType.BOOL, 'success', None, None, ), # 0
12692 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12693 
  )
12694 
 
12695 
  def __init__(self, success=None, scex=None,):
12696 
    self.success = success
12697 
    self.scex = scex
12698 
 
12699 
  def read(self, iprot):
12700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12702 
      return
12703 
    iprot.readStructBegin()
12704 
    while True:
12705 
      (fname, ftype, fid) = iprot.readFieldBegin()
12706 
      if ftype == TType.STOP:
12707 
        break
12708 
      if fid == 0:
12709 
        if ftype == TType.BOOL:
12710 
          self.success = iprot.readBool();
12711 
        else:
12712 
          iprot.skip(ftype)
12713 
      elif fid == 1:
12714 
        if ftype == TType.STRUCT:
12715 
          self.scex = ShoppingCartException()
12716 
          self.scex.read(iprot)
12717 
        else:
12718 
          iprot.skip(ftype)
12719 
      else:
12720 
        iprot.skip(ftype)
12721 
      iprot.readFieldEnd()
12722 
    iprot.readStructEnd()
12723 
 
12724 
  def write(self, oprot):
12725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12727 
      return
690 chandransh 12728 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12729 
    if self.success is not None:
575 chandransh 12730 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12731 
      oprot.writeBool(self.success)
12732 
      oprot.writeFieldEnd()
3431 rajveer 12733 
    if self.scex is not None:
575 chandransh 12734 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12735 
      self.scex.write(oprot)
12736 
      oprot.writeFieldEnd()
12737 
    oprot.writeFieldStop()
12738 
    oprot.writeStructEnd()
12739 
 
3431 rajveer 12740 
  def validate(self):
12741 
    return
12742 
 
12743 
 
575 chandransh 12744 
  def __repr__(self):
12745 
    L = ['%s=%r' % (key, value)
12746 
      for key, value in self.__dict__.iteritems()]
12747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12748 
 
12749 
  def __eq__(self, other):
12750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12751 
 
12752 
  def __ne__(self, other):
12753 
    return not (self == other)
12754 
 
690 chandransh 12755 
class resetCart_args:
559 chandransh 12756 
  """
12757 
  Attributes:
690 chandransh 12758 
   - cartId
12759 
   - items
559 chandransh 12760 
  """
12761 
 
12762 
  thrift_spec = (
12763 
    None, # 0
690 chandransh 12764 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12765 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12766 
  )
12767 
 
690 chandransh 12768 
  def __init__(self, cartId=None, items=None,):
12769 
    self.cartId = cartId
12770 
    self.items = items
559 chandransh 12771 
 
12772 
  def read(self, iprot):
12773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12775 
      return
12776 
    iprot.readStructBegin()
12777 
    while True:
12778 
      (fname, ftype, fid) = iprot.readFieldBegin()
12779 
      if ftype == TType.STOP:
12780 
        break
12781 
      if fid == 1:
12782 
        if ftype == TType.I64:
690 chandransh 12783 
          self.cartId = iprot.readI64();
559 chandransh 12784 
        else:
12785 
          iprot.skip(ftype)
12786 
      elif fid == 2:
690 chandransh 12787 
        if ftype == TType.MAP:
12788 
          self.items = {}
11980 amit.gupta 12789 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12790 
          for _i185 in xrange(_size181):
12791 
            _key186 = iprot.readI64();
12792 
            _val187 = iprot.readDouble();
12793 
            self.items[_key186] = _val187
690 chandransh 12794 
          iprot.readMapEnd()
559 chandransh 12795 
        else:
12796 
          iprot.skip(ftype)
12797 
      else:
12798 
        iprot.skip(ftype)
12799 
      iprot.readFieldEnd()
12800 
    iprot.readStructEnd()
12801 
 
12802 
  def write(self, oprot):
12803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12805 
      return
690 chandransh 12806 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12807 
    if self.cartId is not None:
690 chandransh 12808 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12809 
      oprot.writeI64(self.cartId)
94 ashish 12810 
      oprot.writeFieldEnd()
3431 rajveer 12811 
    if self.items is not None:
690 chandransh 12812 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12813 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12814 
      for kiter188,viter189 in self.items.items():
12815 
        oprot.writeI64(kiter188)
12816 
        oprot.writeDouble(viter189)
690 chandransh 12817 
      oprot.writeMapEnd()
559 chandransh 12818 
      oprot.writeFieldEnd()
94 ashish 12819 
    oprot.writeFieldStop()
12820 
    oprot.writeStructEnd()
12821 
 
3431 rajveer 12822 
  def validate(self):
12823 
    return
12824 
 
12825 
 
94 ashish 12826 
  def __repr__(self):
12827 
    L = ['%s=%r' % (key, value)
12828 
      for key, value in self.__dict__.iteritems()]
12829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12830 
 
12831 
  def __eq__(self, other):
12832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12833 
 
12834 
  def __ne__(self, other):
12835 
    return not (self == other)
12836 
 
690 chandransh 12837 
class resetCart_result:
12838 
  """
12839 
  Attributes:
12840 
   - success
12841 
   - scex
12842 
  """
559 chandransh 12843 
 
12844 
  thrift_spec = (
690 chandransh 12845 
    (0, TType.BOOL, 'success', None, None, ), # 0
12846 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12847 
  )
12848 
 
690 chandransh 12849 
  def __init__(self, success=None, scex=None,):
12850 
    self.success = success
12851 
    self.scex = scex
12852 
 
559 chandransh 12853 
  def read(self, iprot):
12854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12856 
      return
12857 
    iprot.readStructBegin()
12858 
    while True:
12859 
      (fname, ftype, fid) = iprot.readFieldBegin()
12860 
      if ftype == TType.STOP:
12861 
        break
690 chandransh 12862 
      if fid == 0:
12863 
        if ftype == TType.BOOL:
12864 
          self.success = iprot.readBool();
12865 
        else:
12866 
          iprot.skip(ftype)
12867 
      elif fid == 1:
12868 
        if ftype == TType.STRUCT:
12869 
          self.scex = ShoppingCartException()
12870 
          self.scex.read(iprot)
12871 
        else:
12872 
          iprot.skip(ftype)
559 chandransh 12873 
      else:
12874 
        iprot.skip(ftype)
12875 
      iprot.readFieldEnd()
12876 
    iprot.readStructEnd()
12877 
 
12878 
  def write(self, oprot):
12879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12881 
      return
690 chandransh 12882 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12883 
    if self.success is not None:
690 chandransh 12884 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12885 
      oprot.writeBool(self.success)
12886 
      oprot.writeFieldEnd()
3431 rajveer 12887 
    if self.scex is not None:
690 chandransh 12888 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12889 
      self.scex.write(oprot)
12890 
      oprot.writeFieldEnd()
559 chandransh 12891 
    oprot.writeFieldStop()
12892 
    oprot.writeStructEnd()
12893 
 
3431 rajveer 12894 
  def validate(self):
12895 
    return
12896 
 
12897 
 
559 chandransh 12898 
  def __repr__(self):
12899 
    L = ['%s=%r' % (key, value)
12900 
      for key, value in self.__dict__.iteritems()]
12901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12902 
 
12903 
  def __eq__(self, other):
12904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12905 
 
12906 
  def __ne__(self, other):
12907 
    return not (self == other)
12908 
 
2981 rajveer 12909 
class getUserCount_args:
94 ashish 12910 
  """
12911 
  Attributes:
2981 rajveer 12912 
   - userType
559 chandransh 12913 
  """
12914 
 
12915 
  thrift_spec = (
12916 
    None, # 0
2981 rajveer 12917 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12918 
  )
12919 
 
2981 rajveer 12920 
  def __init__(self, userType=None,):
12921 
    self.userType = userType
559 chandransh 12922 
 
12923 
  def read(self, iprot):
12924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12926 
      return
12927 
    iprot.readStructBegin()
12928 
    while True:
12929 
      (fname, ftype, fid) = iprot.readFieldBegin()
12930 
      if ftype == TType.STOP:
12931 
        break
12932 
      if fid == 1:
2981 rajveer 12933 
        if ftype == TType.I32:
12934 
          self.userType = iprot.readI32();
559 chandransh 12935 
        else:
12936 
          iprot.skip(ftype)
12937 
      else:
12938 
        iprot.skip(ftype)
12939 
      iprot.readFieldEnd()
12940 
    iprot.readStructEnd()
12941 
 
12942 
  def write(self, oprot):
12943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12945 
      return
2981 rajveer 12946 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12947 
    if self.userType is not None:
2981 rajveer 12948 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12949 
      oprot.writeI32(self.userType)
559 chandransh 12950 
      oprot.writeFieldEnd()
12951 
    oprot.writeFieldStop()
12952 
    oprot.writeStructEnd()
12953 
 
3431 rajveer 12954 
  def validate(self):
12955 
    return
12956 
 
12957 
 
559 chandransh 12958 
  def __repr__(self):
12959 
    L = ['%s=%r' % (key, value)
12960 
      for key, value in self.__dict__.iteritems()]
12961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12962 
 
12963 
  def __eq__(self, other):
12964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12965 
 
12966 
  def __ne__(self, other):
12967 
    return not (self == other)
12968 
 
2981 rajveer 12969 
class getUserCount_result:
94 ashish 12970 
  """
12971 
  Attributes:
12972 
   - success
12973 
  """
12974 
 
12975 
  thrift_spec = (
2981 rajveer 12976 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12977 
  )
12978 
 
2981 rajveer 12979 
  def __init__(self, success=None,):
94 ashish 12980 
    self.success = success
12981 
 
12982 
  def read(self, iprot):
12983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12985 
      return
12986 
    iprot.readStructBegin()
12987 
    while True:
12988 
      (fname, ftype, fid) = iprot.readFieldBegin()
12989 
      if ftype == TType.STOP:
12990 
        break
12991 
      if fid == 0:
2981 rajveer 12992 
        if ftype == TType.I64:
12993 
          self.success = iprot.readI64();
94 ashish 12994 
        else:
12995 
          iprot.skip(ftype)
12996 
      else:
12997 
        iprot.skip(ftype)
12998 
      iprot.readFieldEnd()
12999 
    iprot.readStructEnd()
13000 
 
13001 
  def write(self, oprot):
13002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13004 
      return
2981 rajveer 13005 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13006 
    if self.success is not None:
2981 rajveer 13007 
      oprot.writeFieldBegin('success', TType.I64, 0)
13008 
      oprot.writeI64(self.success)
94 ashish 13009 
      oprot.writeFieldEnd()
13010 
    oprot.writeFieldStop()
13011 
    oprot.writeStructEnd()
13012 
 
3431 rajveer 13013 
  def validate(self):
13014 
    return
13015 
 
13016 
 
94 ashish 13017 
  def __repr__(self):
13018 
    L = ['%s=%r' % (key, value)
13019 
      for key, value in self.__dict__.iteritems()]
13020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13021 
 
13022 
  def __eq__(self, other):
13023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13024 
 
13025 
  def __ne__(self, other):
13026 
    return not (self == other)
13027 
 
2981 rajveer 13028 
class getAllUsers_args:
94 ashish 13029 
  """
13030 
  Attributes:
2981 rajveer 13031 
   - userType
13032 
   - startDate
13033 
   - endDate
94 ashish 13034 
  """
13035 
 
13036 
  thrift_spec = (
13037 
    None, # 0
2981 rajveer 13038 
    (1, TType.I32, 'userType', None, None, ), # 1
13039 
    (2, TType.I64, 'startDate', None, None, ), # 2
13040 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13041 
  )
13042 
 
2981 rajveer 13043 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13044 
    self.userType = userType
13045 
    self.startDate = startDate
13046 
    self.endDate = endDate
94 ashish 13047 
 
13048 
  def read(self, iprot):
13049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13051 
      return
13052 
    iprot.readStructBegin()
13053 
    while True:
13054 
      (fname, ftype, fid) = iprot.readFieldBegin()
13055 
      if ftype == TType.STOP:
13056 
        break
13057 
      if fid == 1:
2981 rajveer 13058 
        if ftype == TType.I32:
13059 
          self.userType = iprot.readI32();
94 ashish 13060 
        else:
13061 
          iprot.skip(ftype)
13062 
      elif fid == 2:
559 chandransh 13063 
        if ftype == TType.I64:
2981 rajveer 13064 
          self.startDate = iprot.readI64();
94 ashish 13065 
        else:
13066 
          iprot.skip(ftype)
2981 rajveer 13067 
      elif fid == 3:
13068 
        if ftype == TType.I64:
13069 
          self.endDate = iprot.readI64();
13070 
        else:
13071 
          iprot.skip(ftype)
94 ashish 13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
2981 rajveer 13081 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13082 
    if self.userType is not None:
2981 rajveer 13083 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13084 
      oprot.writeI32(self.userType)
94 ashish 13085 
      oprot.writeFieldEnd()
3431 rajveer 13086 
    if self.startDate is not None:
2981 rajveer 13087 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13088 
      oprot.writeI64(self.startDate)
94 ashish 13089 
      oprot.writeFieldEnd()
3431 rajveer 13090 
    if self.endDate is not None:
2981 rajveer 13091 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13092 
      oprot.writeI64(self.endDate)
13093 
      oprot.writeFieldEnd()
94 ashish 13094 
    oprot.writeFieldStop()
13095 
    oprot.writeStructEnd()
13096 
 
3431 rajveer 13097 
  def validate(self):
13098 
    return
13099 
 
13100 
 
94 ashish 13101 
  def __repr__(self):
13102 
    L = ['%s=%r' % (key, value)
13103 
      for key, value in self.__dict__.iteritems()]
13104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13105 
 
13106 
  def __eq__(self, other):
13107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13108 
 
13109 
  def __ne__(self, other):
13110 
    return not (self == other)
13111 
 
2981 rajveer 13112 
class getAllUsers_result:
94 ashish 13113 
  """
13114 
  Attributes:
13115 
   - success
13116 
  """
13117 
 
13118 
  thrift_spec = (
2981 rajveer 13119 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13120 
  )
13121 
 
2981 rajveer 13122 
  def __init__(self, success=None,):
94 ashish 13123 
    self.success = success
13124 
 
13125 
  def read(self, iprot):
13126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13128 
      return
13129 
    iprot.readStructBegin()
13130 
    while True:
13131 
      (fname, ftype, fid) = iprot.readFieldBegin()
13132 
      if ftype == TType.STOP:
13133 
        break
13134 
      if fid == 0:
2981 rajveer 13135 
        if ftype == TType.LIST:
13136 
          self.success = []
11980 amit.gupta 13137 
          (_etype193, _size190) = iprot.readListBegin()
13138 
          for _i194 in xrange(_size190):
13139 
            _elem195 = User()
13140 
            _elem195.read(iprot)
13141 
            self.success.append(_elem195)
2981 rajveer 13142 
          iprot.readListEnd()
94 ashish 13143 
        else:
13144 
          iprot.skip(ftype)
13145 
      else:
13146 
        iprot.skip(ftype)
13147 
      iprot.readFieldEnd()
13148 
    iprot.readStructEnd()
13149 
 
13150 
  def write(self, oprot):
13151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13153 
      return
2981 rajveer 13154 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13155 
    if self.success is not None:
2981 rajveer 13156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13158 
      for iter196 in self.success:
13159 
        iter196.write(oprot)
2981 rajveer 13160 
      oprot.writeListEnd()
94 ashish 13161 
      oprot.writeFieldEnd()
13162 
    oprot.writeFieldStop()
13163 
    oprot.writeStructEnd()
13164 
 
3431 rajveer 13165 
  def validate(self):
13166 
    return
13167 
 
13168 
 
94 ashish 13169 
  def __repr__(self):
13170 
    L = ['%s=%r' % (key, value)
13171 
      for key, value in self.__dict__.iteritems()]
13172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13173 
 
13174 
  def __eq__(self, other):
13175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13176 
 
13177 
  def __ne__(self, other):
13178 
    return not (self == other)
13179 
 
2981 rajveer 13180 
class getMyResearchItems_args:
559 chandransh 13181 
  """
13182 
  Attributes:
772 rajveer 13183 
   - userId
559 chandransh 13184 
  """
13185 
 
13186 
  thrift_spec = (
13187 
    None, # 0
772 rajveer 13188 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13189 
  )
13190 
 
772 rajveer 13191 
  def __init__(self, userId=None,):
13192 
    self.userId = userId
559 chandransh 13193 
 
13194 
  def read(self, iprot):
13195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13197 
      return
13198 
    iprot.readStructBegin()
13199 
    while True:
13200 
      (fname, ftype, fid) = iprot.readFieldBegin()
13201 
      if ftype == TType.STOP:
13202 
        break
13203 
      if fid == 1:
13204 
        if ftype == TType.I64:
772 rajveer 13205 
          self.userId = iprot.readI64();
559 chandransh 13206 
        else:
13207 
          iprot.skip(ftype)
13208 
      else:
13209 
        iprot.skip(ftype)
13210 
      iprot.readFieldEnd()
13211 
    iprot.readStructEnd()
13212 
 
13213 
  def write(self, oprot):
13214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13216 
      return
2981 rajveer 13217 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13218 
    if self.userId is not None:
772 rajveer 13219 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13220 
      oprot.writeI64(self.userId)
559 chandransh 13221 
      oprot.writeFieldEnd()
13222 
    oprot.writeFieldStop()
13223 
    oprot.writeStructEnd()
13224 
 
3431 rajveer 13225 
  def validate(self):
13226 
    return
13227 
 
13228 
 
559 chandransh 13229 
  def __repr__(self):
13230 
    L = ['%s=%r' % (key, value)
13231 
      for key, value in self.__dict__.iteritems()]
13232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13233 
 
13234 
  def __eq__(self, other):
13235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13236 
 
13237 
  def __ne__(self, other):
13238 
    return not (self == other)
13239 
 
2981 rajveer 13240 
class getMyResearchItems_result:
559 chandransh 13241 
  """
13242 
  Attributes:
130 ashish 13243 
   - success
559 chandransh 13244 
   - scx
130 ashish 13245 
  """
13246 
 
13247 
  thrift_spec = (
2981 rajveer 13248 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13249 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13250 
  )
13251 
 
559 chandransh 13252 
  def __init__(self, success=None, scx=None,):
130 ashish 13253 
    self.success = success
559 chandransh 13254 
    self.scx = scx
130 ashish 13255 
 
13256 
  def read(self, iprot):
13257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13259 
      return
13260 
    iprot.readStructBegin()
13261 
    while True:
13262 
      (fname, ftype, fid) = iprot.readFieldBegin()
13263 
      if ftype == TType.STOP:
13264 
        break
13265 
      if fid == 0:
2981 rajveer 13266 
        if ftype == TType.LIST:
13267 
          self.success = []
11980 amit.gupta 13268 
          (_etype200, _size197) = iprot.readListBegin()
13269 
          for _i201 in xrange(_size197):
13270 
            _elem202 = iprot.readI64();
13271 
            self.success.append(_elem202)
2981 rajveer 13272 
          iprot.readListEnd()
130 ashish 13273 
        else:
13274 
          iprot.skip(ftype)
13275 
      elif fid == 1:
13276 
        if ftype == TType.STRUCT:
559 chandransh 13277 
          self.scx = WidgetException()
13278 
          self.scx.read(iprot)
130 ashish 13279 
        else:
13280 
          iprot.skip(ftype)
13281 
      else:
13282 
        iprot.skip(ftype)
13283 
      iprot.readFieldEnd()
13284 
    iprot.readStructEnd()
13285 
 
13286 
  def write(self, oprot):
13287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13289 
      return
2981 rajveer 13290 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13291 
    if self.success is not None:
2981 rajveer 13292 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13293 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13294 
      for iter203 in self.success:
13295 
        oprot.writeI64(iter203)
2981 rajveer 13296 
      oprot.writeListEnd()
130 ashish 13297 
      oprot.writeFieldEnd()
3431 rajveer 13298 
    if self.scx is not None:
559 chandransh 13299 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13300 
      self.scx.write(oprot)
130 ashish 13301 
      oprot.writeFieldEnd()
13302 
    oprot.writeFieldStop()
13303 
    oprot.writeStructEnd()
13304 
 
3431 rajveer 13305 
  def validate(self):
13306 
    return
13307 
 
13308 
 
130 ashish 13309 
  def __repr__(self):
13310 
    L = ['%s=%r' % (key, value)
13311 
      for key, value in self.__dict__.iteritems()]
13312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13313 
 
13314 
  def __eq__(self, other):
13315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13316 
 
13317 
  def __ne__(self, other):
13318 
    return not (self == other)
13319 
 
2981 rajveer 13320 
class updateMyResearch_args:
130 ashish 13321 
  """
13322 
  Attributes:
2981 rajveer 13323 
   - userId
13324 
   - itemId
130 ashish 13325 
  """
13326 
 
13327 
  thrift_spec = (
13328 
    None, # 0
2981 rajveer 13329 
    (1, TType.I64, 'userId', None, None, ), # 1
13330 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13331 
  )
13332 
 
2981 rajveer 13333 
  def __init__(self, userId=None, itemId=None,):
13334 
    self.userId = userId
13335 
    self.itemId = itemId
130 ashish 13336 
 
13337 
  def read(self, iprot):
13338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13340 
      return
13341 
    iprot.readStructBegin()
13342 
    while True:
13343 
      (fname, ftype, fid) = iprot.readFieldBegin()
13344 
      if ftype == TType.STOP:
13345 
        break
13346 
      if fid == 1:
559 chandransh 13347 
        if ftype == TType.I64:
2981 rajveer 13348 
          self.userId = iprot.readI64();
130 ashish 13349 
        else:
13350 
          iprot.skip(ftype)
13351 
      elif fid == 2:
559 chandransh 13352 
        if ftype == TType.I64:
2981 rajveer 13353 
          self.itemId = iprot.readI64();
559 chandransh 13354 
        else:
13355 
          iprot.skip(ftype)
130 ashish 13356 
      else:
13357 
        iprot.skip(ftype)
13358 
      iprot.readFieldEnd()
13359 
    iprot.readStructEnd()
13360 
 
13361 
  def write(self, oprot):
13362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13364 
      return
2981 rajveer 13365 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13366 
    if self.userId is not None:
2981 rajveer 13367 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13368 
      oprot.writeI64(self.userId)
130 ashish 13369 
      oprot.writeFieldEnd()
3431 rajveer 13370 
    if self.itemId is not None:
2981 rajveer 13371 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13372 
      oprot.writeI64(self.itemId)
130 ashish 13373 
      oprot.writeFieldEnd()
13374 
    oprot.writeFieldStop()
13375 
    oprot.writeStructEnd()
13376 
 
3431 rajveer 13377 
  def validate(self):
13378 
    return
13379 
 
13380 
 
130 ashish 13381 
  def __repr__(self):
13382 
    L = ['%s=%r' % (key, value)
13383 
      for key, value in self.__dict__.iteritems()]
13384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13385 
 
13386 
  def __eq__(self, other):
13387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13388 
 
13389 
  def __ne__(self, other):
13390 
    return not (self == other)
13391 
 
2981 rajveer 13392 
class updateMyResearch_result:
13393 
  """
13394 
  Attributes:
13395 
   - success
13396 
   - scx
13397 
  """
559 chandransh 13398 
 
13399 
  thrift_spec = (
2981 rajveer 13400 
    (0, TType.BOOL, 'success', None, None, ), # 0
13401 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13402 
  )
13403 
 
2981 rajveer 13404 
  def __init__(self, success=None, scx=None,):
13405 
    self.success = success
13406 
    self.scx = scx
13407 
 
559 chandransh 13408 
  def read(self, iprot):
13409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13411 
      return
13412 
    iprot.readStructBegin()
13413 
    while True:
13414 
      (fname, ftype, fid) = iprot.readFieldBegin()
13415 
      if ftype == TType.STOP:
13416 
        break
2981 rajveer 13417 
      if fid == 0:
13418 
        if ftype == TType.BOOL:
13419 
          self.success = iprot.readBool();
13420 
        else:
13421 
          iprot.skip(ftype)
13422 
      elif fid == 1:
13423 
        if ftype == TType.STRUCT:
13424 
          self.scx = WidgetException()
13425 
          self.scx.read(iprot)
13426 
        else:
13427 
          iprot.skip(ftype)
559 chandransh 13428 
      else:
13429 
        iprot.skip(ftype)
13430 
      iprot.readFieldEnd()
13431 
    iprot.readStructEnd()
13432 
 
13433 
  def write(self, oprot):
13434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13436 
      return
2981 rajveer 13437 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13438 
    if self.success is not None:
2981 rajveer 13439 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13440 
      oprot.writeBool(self.success)
13441 
      oprot.writeFieldEnd()
3431 rajveer 13442 
    if self.scx is not None:
2981 rajveer 13443 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13444 
      self.scx.write(oprot)
13445 
      oprot.writeFieldEnd()
559 chandransh 13446 
    oprot.writeFieldStop()
13447 
    oprot.writeStructEnd()
13448 
 
3431 rajveer 13449 
  def validate(self):
13450 
    return
13451 
 
13452 
 
559 chandransh 13453 
  def __repr__(self):
13454 
    L = ['%s=%r' % (key, value)
13455 
      for key, value in self.__dict__.iteritems()]
13456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13457 
 
13458 
  def __eq__(self, other):
13459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13460 
 
13461 
  def __ne__(self, other):
13462 
    return not (self == other)
13463 
 
2981 rajveer 13464 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13465 
  """
13466 
  Attributes:
2981 rajveer 13467 
   - userId
13468 
   - itemId
1596 ankur.sing 13469 
  """
559 chandransh 13470 
 
1596 ankur.sing 13471 
  thrift_spec = (
13472 
    None, # 0
2981 rajveer 13473 
    (1, TType.I64, 'userId', None, None, ), # 1
13474 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13475 
  )
13476 
 
2981 rajveer 13477 
  def __init__(self, userId=None, itemId=None,):
13478 
    self.userId = userId
13479 
    self.itemId = itemId
1596 ankur.sing 13480 
 
13481 
  def read(self, iprot):
13482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13484 
      return
13485 
    iprot.readStructBegin()
13486 
    while True:
13487 
      (fname, ftype, fid) = iprot.readFieldBegin()
13488 
      if ftype == TType.STOP:
13489 
        break
13490 
      if fid == 1:
2981 rajveer 13491 
        if ftype == TType.I64:
13492 
          self.userId = iprot.readI64();
1596 ankur.sing 13493 
        else:
13494 
          iprot.skip(ftype)
2981 rajveer 13495 
      elif fid == 2:
13496 
        if ftype == TType.I64:
13497 
          self.itemId = iprot.readI64();
13498 
        else:
13499 
          iprot.skip(ftype)
1596 ankur.sing 13500 
      else:
13501 
        iprot.skip(ftype)
13502 
      iprot.readFieldEnd()
13503 
    iprot.readStructEnd()
13504 
 
13505 
  def write(self, oprot):
13506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13508 
      return
2981 rajveer 13509 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13510 
    if self.userId is not None:
2981 rajveer 13511 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13512 
      oprot.writeI64(self.userId)
1596 ankur.sing 13513 
      oprot.writeFieldEnd()
3431 rajveer 13514 
    if self.itemId is not None:
2981 rajveer 13515 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13516 
      oprot.writeI64(self.itemId)
13517 
      oprot.writeFieldEnd()
1596 ankur.sing 13518 
    oprot.writeFieldStop()
13519 
    oprot.writeStructEnd()
13520 
 
3431 rajveer 13521 
  def validate(self):
13522 
    return
13523 
 
13524 
 
1596 ankur.sing 13525 
  def __repr__(self):
13526 
    L = ['%s=%r' % (key, value)
13527 
      for key, value in self.__dict__.iteritems()]
13528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13529 
 
13530 
  def __eq__(self, other):
13531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13532 
 
13533 
  def __ne__(self, other):
13534 
    return not (self == other)
13535 
 
2981 rajveer 13536 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13537 
  """
13538 
  Attributes:
2981 rajveer 13539 
   - scx
1596 ankur.sing 13540 
  """
13541 
 
13542 
  thrift_spec = (
2981 rajveer 13543 
    None, # 0
13544 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13545 
  )
13546 
 
2981 rajveer 13547 
  def __init__(self, scx=None,):
13548 
    self.scx = scx
1596 ankur.sing 13549 
 
13550 
  def read(self, iprot):
13551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13553 
      return
13554 
    iprot.readStructBegin()
13555 
    while True:
13556 
      (fname, ftype, fid) = iprot.readFieldBegin()
13557 
      if ftype == TType.STOP:
13558 
        break
2981 rajveer 13559 
      if fid == 1:
13560 
        if ftype == TType.STRUCT:
13561 
          self.scx = WidgetException()
13562 
          self.scx.read(iprot)
1596 ankur.sing 13563 
        else:
13564 
          iprot.skip(ftype)
13565 
      else:
13566 
        iprot.skip(ftype)
13567 
      iprot.readFieldEnd()
13568 
    iprot.readStructEnd()
13569 
 
13570 
  def write(self, oprot):
13571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13573 
      return
2981 rajveer 13574 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13575 
    if self.scx is not None:
2981 rajveer 13576 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13577 
      self.scx.write(oprot)
1596 ankur.sing 13578 
      oprot.writeFieldEnd()
13579 
    oprot.writeFieldStop()
13580 
    oprot.writeStructEnd()
13581 
 
3431 rajveer 13582 
  def validate(self):
13583 
    return
13584 
 
13585 
 
1596 ankur.sing 13586 
  def __repr__(self):
13587 
    L = ['%s=%r' % (key, value)
13588 
      for key, value in self.__dict__.iteritems()]
13589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13590 
 
13591 
  def __eq__(self, other):
13592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13593 
 
13594 
  def __ne__(self, other):
13595 
    return not (self == other)
13596 
 
2981 rajveer 13597 
class getBrowseHistoryItems_args:
1673 ankur.sing 13598 
  """
13599 
  Attributes:
2981 rajveer 13600 
   - userId
1673 ankur.sing 13601 
  """
1596 ankur.sing 13602 
 
1673 ankur.sing 13603 
  thrift_spec = (
13604 
    None, # 0
2981 rajveer 13605 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13606 
  )
13607 
 
2981 rajveer 13608 
  def __init__(self, userId=None,):
13609 
    self.userId = userId
1673 ankur.sing 13610 
 
13611 
  def read(self, iprot):
13612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13614 
      return
13615 
    iprot.readStructBegin()
13616 
    while True:
13617 
      (fname, ftype, fid) = iprot.readFieldBegin()
13618 
      if ftype == TType.STOP:
13619 
        break
13620 
      if fid == 1:
1891 ankur.sing 13621 
        if ftype == TType.I64:
2981 rajveer 13622 
          self.userId = iprot.readI64();
1891 ankur.sing 13623 
        else:
13624 
          iprot.skip(ftype)
1673 ankur.sing 13625 
      else:
13626 
        iprot.skip(ftype)
13627 
      iprot.readFieldEnd()
13628 
    iprot.readStructEnd()
13629 
 
13630 
  def write(self, oprot):
13631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13633 
      return
2981 rajveer 13634 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13635 
    if self.userId is not None:
2981 rajveer 13636 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13637 
      oprot.writeI64(self.userId)
1673 ankur.sing 13638 
      oprot.writeFieldEnd()
13639 
    oprot.writeFieldStop()
13640 
    oprot.writeStructEnd()
13641 
 
3431 rajveer 13642 
  def validate(self):
13643 
    return
13644 
 
13645 
 
1673 ankur.sing 13646 
  def __repr__(self):
13647 
    L = ['%s=%r' % (key, value)
13648 
      for key, value in self.__dict__.iteritems()]
13649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13650 
 
13651 
  def __eq__(self, other):
13652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13653 
 
13654 
  def __ne__(self, other):
13655 
    return not (self == other)
13656 
 
2981 rajveer 13657 
class getBrowseHistoryItems_result:
1673 ankur.sing 13658 
  """
13659 
  Attributes:
13660 
   - success
2981 rajveer 13661 
   - scx
1673 ankur.sing 13662 
  """
13663 
 
13664 
  thrift_spec = (
2981 rajveer 13665 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13666 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13667 
  )
13668 
 
2981 rajveer 13669 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13670 
    self.success = success
2981 rajveer 13671 
    self.scx = scx
1673 ankur.sing 13672 
 
13673 
  def read(self, iprot):
13674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13676 
      return
13677 
    iprot.readStructBegin()
13678 
    while True:
13679 
      (fname, ftype, fid) = iprot.readFieldBegin()
13680 
      if ftype == TType.STOP:
13681 
        break
13682 
      if fid == 0:
13683 
        if ftype == TType.LIST:
13684 
          self.success = []
11980 amit.gupta 13685 
          (_etype207, _size204) = iprot.readListBegin()
13686 
          for _i208 in xrange(_size204):
13687 
            _elem209 = iprot.readI64();
13688 
            self.success.append(_elem209)
1673 ankur.sing 13689 
          iprot.readListEnd()
13690 
        else:
13691 
          iprot.skip(ftype)
2981 rajveer 13692 
      elif fid == 1:
13693 
        if ftype == TType.STRUCT:
13694 
          self.scx = WidgetException()
13695 
          self.scx.read(iprot)
13696 
        else:
13697 
          iprot.skip(ftype)
1673 ankur.sing 13698 
      else:
13699 
        iprot.skip(ftype)
13700 
      iprot.readFieldEnd()
13701 
    iprot.readStructEnd()
13702 
 
13703 
  def write(self, oprot):
13704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13706 
      return
2981 rajveer 13707 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13708 
    if self.success is not None:
1673 ankur.sing 13709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13710 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13711 
      for iter210 in self.success:
13712 
        oprot.writeI64(iter210)
1673 ankur.sing 13713 
      oprot.writeListEnd()
13714 
      oprot.writeFieldEnd()
3431 rajveer 13715 
    if self.scx is not None:
2981 rajveer 13716 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13717 
      self.scx.write(oprot)
2642 varun.gupt 13718 
      oprot.writeFieldEnd()
13719 
    oprot.writeFieldStop()
13720 
    oprot.writeStructEnd()
13721 
 
3431 rajveer 13722 
  def validate(self):
13723 
    return
13724 
 
13725 
 
2642 varun.gupt 13726 
  def __repr__(self):
13727 
    L = ['%s=%r' % (key, value)
13728 
      for key, value in self.__dict__.iteritems()]
13729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13730 
 
13731 
  def __eq__(self, other):
13732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13733 
 
13734 
  def __ne__(self, other):
13735 
    return not (self == other)
13736 
 
2981 rajveer 13737 
class updateBrowseHistory_args:
2642 varun.gupt 13738 
  """
13739 
  Attributes:
2981 rajveer 13740 
   - userId
13741 
   - itemId
2642 varun.gupt 13742 
  """
13743 
 
13744 
  thrift_spec = (
13745 
    None, # 0
2981 rajveer 13746 
    (1, TType.I64, 'userId', None, None, ), # 1
13747 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13748 
  )
13749 
 
2981 rajveer 13750 
  def __init__(self, userId=None, itemId=None,):
13751 
    self.userId = userId
13752 
    self.itemId = itemId
2642 varun.gupt 13753 
 
13754 
  def read(self, iprot):
13755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13757 
      return
13758 
    iprot.readStructBegin()
13759 
    while True:
13760 
      (fname, ftype, fid) = iprot.readFieldBegin()
13761 
      if ftype == TType.STOP:
13762 
        break
13763 
      if fid == 1:
13764 
        if ftype == TType.I64:
2981 rajveer 13765 
          self.userId = iprot.readI64();
2642 varun.gupt 13766 
        else:
13767 
          iprot.skip(ftype)
13768 
      elif fid == 2:
13769 
        if ftype == TType.I64:
2981 rajveer 13770 
          self.itemId = iprot.readI64();
2642 varun.gupt 13771 
        else:
13772 
          iprot.skip(ftype)
13773 
      else:
13774 
        iprot.skip(ftype)
13775 
      iprot.readFieldEnd()
13776 
    iprot.readStructEnd()
13777 
 
13778 
  def write(self, oprot):
13779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13781 
      return
2981 rajveer 13782 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13783 
    if self.userId is not None:
2981 rajveer 13784 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13785 
      oprot.writeI64(self.userId)
2642 varun.gupt 13786 
      oprot.writeFieldEnd()
3431 rajveer 13787 
    if self.itemId is not None:
2981 rajveer 13788 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13789 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13790 
      oprot.writeFieldEnd()
13791 
    oprot.writeFieldStop()
13792 
    oprot.writeStructEnd()
13793 
 
3431 rajveer 13794 
  def validate(self):
13795 
    return
13796 
 
13797 
 
2642 varun.gupt 13798 
  def __repr__(self):
13799 
    L = ['%s=%r' % (key, value)
13800 
      for key, value in self.__dict__.iteritems()]
13801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13802 
 
13803 
  def __eq__(self, other):
13804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13805 
 
13806 
  def __ne__(self, other):
13807 
    return not (self == other)
13808 
 
2981 rajveer 13809 
class updateBrowseHistory_result:
2642 varun.gupt 13810 
 
13811 
  thrift_spec = (
13812 
  )
13813 
 
13814 
  def read(self, iprot):
13815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13817 
      return
13818 
    iprot.readStructBegin()
13819 
    while True:
13820 
      (fname, ftype, fid) = iprot.readFieldBegin()
13821 
      if ftype == TType.STOP:
13822 
        break
13823 
      else:
13824 
        iprot.skip(ftype)
13825 
      iprot.readFieldEnd()
13826 
    iprot.readStructEnd()
13827 
 
13828 
  def write(self, oprot):
13829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13831 
      return
2981 rajveer 13832 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13833 
    oprot.writeFieldStop()
13834 
    oprot.writeStructEnd()
13835 
 
3431 rajveer 13836 
  def validate(self):
13837 
    return
13838 
 
13839 
 
2642 varun.gupt 13840 
  def __repr__(self):
13841 
    L = ['%s=%r' % (key, value)
13842 
      for key, value in self.__dict__.iteritems()]
13843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13844 
 
13845 
  def __eq__(self, other):
13846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13847 
 
13848 
  def __ne__(self, other):
13849 
    return not (self == other)
13850 
 
3385 varun.gupt 13851 
class getCartsWithCouponCount_args:
13852 
  """
13853 
  Attributes:
13854 
   - couponCode
13855 
  """
2642 varun.gupt 13856 
 
3385 varun.gupt 13857 
  thrift_spec = (
13858 
    None, # 0
13859 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13860 
  )
13861 
 
13862 
  def __init__(self, couponCode=None,):
13863 
    self.couponCode = couponCode
13864 
 
13865 
  def read(self, iprot):
13866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13868 
      return
13869 
    iprot.readStructBegin()
13870 
    while True:
13871 
      (fname, ftype, fid) = iprot.readFieldBegin()
13872 
      if ftype == TType.STOP:
13873 
        break
13874 
      if fid == 1:
13875 
        if ftype == TType.STRING:
13876 
          self.couponCode = iprot.readString();
13877 
        else:
13878 
          iprot.skip(ftype)
13879 
      else:
13880 
        iprot.skip(ftype)
13881 
      iprot.readFieldEnd()
13882 
    iprot.readStructEnd()
13883 
 
13884 
  def write(self, oprot):
13885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13887 
      return
13888 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13889 
    if self.couponCode is not None:
3385 varun.gupt 13890 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13891 
      oprot.writeString(self.couponCode)
13892 
      oprot.writeFieldEnd()
13893 
    oprot.writeFieldStop()
13894 
    oprot.writeStructEnd()
13895 
 
3431 rajveer 13896 
  def validate(self):
13897 
    return
13898 
 
13899 
 
3385 varun.gupt 13900 
  def __repr__(self):
13901 
    L = ['%s=%r' % (key, value)
13902 
      for key, value in self.__dict__.iteritems()]
13903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13904 
 
13905 
  def __eq__(self, other):
13906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13907 
 
13908 
  def __ne__(self, other):
13909 
    return not (self == other)
13910 
 
13911 
class getCartsWithCouponCount_result:
13912 
  """
13913 
  Attributes:
13914 
   - success
13915 
  """
13916 
 
13917 
  thrift_spec = (
13918 
    (0, TType.I64, 'success', None, None, ), # 0
13919 
  )
13920 
 
13921 
  def __init__(self, success=None,):
13922 
    self.success = success
13923 
 
13924 
  def read(self, iprot):
13925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13927 
      return
13928 
    iprot.readStructBegin()
13929 
    while True:
13930 
      (fname, ftype, fid) = iprot.readFieldBegin()
13931 
      if ftype == TType.STOP:
13932 
        break
13933 
      if fid == 0:
13934 
        if ftype == TType.I64:
13935 
          self.success = iprot.readI64();
13936 
        else:
13937 
          iprot.skip(ftype)
13938 
      else:
13939 
        iprot.skip(ftype)
13940 
      iprot.readFieldEnd()
13941 
    iprot.readStructEnd()
13942 
 
13943 
  def write(self, oprot):
13944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13946 
      return
13947 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13948 
    if self.success is not None:
3385 varun.gupt 13949 
      oprot.writeFieldBegin('success', TType.I64, 0)
13950 
      oprot.writeI64(self.success)
13951 
      oprot.writeFieldEnd()
13952 
    oprot.writeFieldStop()
13953 
    oprot.writeStructEnd()
13954 
 
3431 rajveer 13955 
  def validate(self):
13956 
    return
13957 
 
13958 
 
3385 varun.gupt 13959 
  def __repr__(self):
13960 
    L = ['%s=%r' % (key, value)
13961 
      for key, value in self.__dict__.iteritems()]
13962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13963 
 
13964 
  def __eq__(self, other):
13965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13966 
 
13967 
  def __ne__(self, other):
13968 
    return not (self == other)
3499 mandeep.dh 13969 
 
13970 
class increaseTrustLevel_args:
13971 
  """
13972 
  Attributes:
13973 
   - userId
13974 
   - trustLevelDelta
13975 
  """
13976 
 
13977 
  thrift_spec = (
13978 
    None, # 0
13979 
    (1, TType.I64, 'userId', None, None, ), # 1
13980 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13981 
  )
13982 
 
13983 
  def __init__(self, userId=None, trustLevelDelta=None,):
13984 
    self.userId = userId
13985 
    self.trustLevelDelta = trustLevelDelta
13986 
 
13987 
  def read(self, iprot):
13988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13990 
      return
13991 
    iprot.readStructBegin()
13992 
    while True:
13993 
      (fname, ftype, fid) = iprot.readFieldBegin()
13994 
      if ftype == TType.STOP:
13995 
        break
13996 
      if fid == 1:
13997 
        if ftype == TType.I64:
13998 
          self.userId = iprot.readI64();
13999 
        else:
14000 
          iprot.skip(ftype)
14001 
      elif fid == 2:
14002 
        if ftype == TType.DOUBLE:
14003 
          self.trustLevelDelta = iprot.readDouble();
14004 
        else:
14005 
          iprot.skip(ftype)
14006 
      else:
14007 
        iprot.skip(ftype)
14008 
      iprot.readFieldEnd()
14009 
    iprot.readStructEnd()
14010 
 
14011 
  def write(self, oprot):
14012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14014 
      return
14015 
    oprot.writeStructBegin('increaseTrustLevel_args')
14016 
    if self.userId is not None:
14017 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14018 
      oprot.writeI64(self.userId)
14019 
      oprot.writeFieldEnd()
14020 
    if self.trustLevelDelta is not None:
14021 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14022 
      oprot.writeDouble(self.trustLevelDelta)
14023 
      oprot.writeFieldEnd()
14024 
    oprot.writeFieldStop()
14025 
    oprot.writeStructEnd()
14026 
 
14027 
  def validate(self):
14028 
    return
14029 
 
14030 
 
14031 
  def __repr__(self):
14032 
    L = ['%s=%r' % (key, value)
14033 
      for key, value in self.__dict__.iteritems()]
14034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14035 
 
14036 
  def __eq__(self, other):
14037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14038 
 
14039 
  def __ne__(self, other):
14040 
    return not (self == other)
4668 varun.gupt 14041 
 
5407 amar.kumar 14042 
class getTrustLevel_args:
14043 
  """
14044 
  Attributes:
14045 
   - userId
14046 
  """
14047 
 
14048 
  thrift_spec = (
14049 
    None, # 0
14050 
    (1, TType.I64, 'userId', None, None, ), # 1
14051 
  )
14052 
 
14053 
  def __init__(self, userId=None,):
14054 
    self.userId = userId
14055 
 
14056 
  def read(self, iprot):
14057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14059 
      return
14060 
    iprot.readStructBegin()
14061 
    while True:
14062 
      (fname, ftype, fid) = iprot.readFieldBegin()
14063 
      if ftype == TType.STOP:
14064 
        break
14065 
      if fid == 1:
14066 
        if ftype == TType.I64:
14067 
          self.userId = iprot.readI64();
14068 
        else:
14069 
          iprot.skip(ftype)
14070 
      else:
14071 
        iprot.skip(ftype)
14072 
      iprot.readFieldEnd()
14073 
    iprot.readStructEnd()
14074 
 
14075 
  def write(self, oprot):
14076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14078 
      return
14079 
    oprot.writeStructBegin('getTrustLevel_args')
14080 
    if self.userId is not None:
14081 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14082 
      oprot.writeI64(self.userId)
14083 
      oprot.writeFieldEnd()
14084 
    oprot.writeFieldStop()
14085 
    oprot.writeStructEnd()
14086 
 
14087 
  def validate(self):
14088 
    return
14089 
 
14090 
 
14091 
  def __repr__(self):
14092 
    L = ['%s=%r' % (key, value)
14093 
      for key, value in self.__dict__.iteritems()]
14094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14095 
 
14096 
  def __eq__(self, other):
14097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14098 
 
14099 
  def __ne__(self, other):
14100 
    return not (self == other)
14101 
 
14102 
class getTrustLevel_result:
14103 
  """
14104 
  Attributes:
14105 
   - success
14106 
  """
14107 
 
14108 
  thrift_spec = (
14109 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14110 
  )
14111 
 
14112 
  def __init__(self, success=None,):
14113 
    self.success = success
14114 
 
14115 
  def read(self, iprot):
14116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14118 
      return
14119 
    iprot.readStructBegin()
14120 
    while True:
14121 
      (fname, ftype, fid) = iprot.readFieldBegin()
14122 
      if ftype == TType.STOP:
14123 
        break
14124 
      if fid == 0:
14125 
        if ftype == TType.DOUBLE:
14126 
          self.success = iprot.readDouble();
14127 
        else:
14128 
          iprot.skip(ftype)
14129 
      else:
14130 
        iprot.skip(ftype)
14131 
      iprot.readFieldEnd()
14132 
    iprot.readStructEnd()
14133 
 
14134 
  def write(self, oprot):
14135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14137 
      return
14138 
    oprot.writeStructBegin('getTrustLevel_result')
14139 
    if self.success is not None:
14140 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14141 
      oprot.writeDouble(self.success)
14142 
      oprot.writeFieldEnd()
14143 
    oprot.writeFieldStop()
14144 
    oprot.writeStructEnd()
14145 
 
14146 
  def validate(self):
14147 
    return
14148 
 
14149 
 
14150 
  def __repr__(self):
14151 
    L = ['%s=%r' % (key, value)
14152 
      for key, value in self.__dict__.iteritems()]
14153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14154 
 
14155 
  def __eq__(self, other):
14156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14157 
 
14158 
  def __ne__(self, other):
14159 
    return not (self == other)
14160 
 
4668 varun.gupt 14161 
class showCODOption_args:
14162 
  """
14163 
  Attributes:
14164 
   - cartId
14165 
   - sourceId
14166 
   - pincode
14167 
  """
14168 
 
14169 
  thrift_spec = (
14170 
    None, # 0
14171 
    (1, TType.I64, 'cartId', None, None, ), # 1
14172 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14173 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14174 
  )
14175 
 
14176 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14177 
    self.cartId = cartId
14178 
    self.sourceId = sourceId
14179 
    self.pincode = pincode
14180 
 
14181 
  def read(self, iprot):
14182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14184 
      return
14185 
    iprot.readStructBegin()
14186 
    while True:
14187 
      (fname, ftype, fid) = iprot.readFieldBegin()
14188 
      if ftype == TType.STOP:
14189 
        break
14190 
      if fid == 1:
14191 
        if ftype == TType.I64:
14192 
          self.cartId = iprot.readI64();
14193 
        else:
14194 
          iprot.skip(ftype)
14195 
      elif fid == 2:
14196 
        if ftype == TType.I64:
14197 
          self.sourceId = iprot.readI64();
14198 
        else:
14199 
          iprot.skip(ftype)
14200 
      elif fid == 3:
14201 
        if ftype == TType.STRING:
14202 
          self.pincode = iprot.readString();
14203 
        else:
14204 
          iprot.skip(ftype)
14205 
      else:
14206 
        iprot.skip(ftype)
14207 
      iprot.readFieldEnd()
14208 
    iprot.readStructEnd()
14209 
 
14210 
  def write(self, oprot):
14211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14213 
      return
14214 
    oprot.writeStructBegin('showCODOption_args')
14215 
    if self.cartId is not None:
14216 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14217 
      oprot.writeI64(self.cartId)
14218 
      oprot.writeFieldEnd()
14219 
    if self.sourceId is not None:
14220 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14221 
      oprot.writeI64(self.sourceId)
14222 
      oprot.writeFieldEnd()
14223 
    if self.pincode is not None:
14224 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14225 
      oprot.writeString(self.pincode)
14226 
      oprot.writeFieldEnd()
14227 
    oprot.writeFieldStop()
14228 
    oprot.writeStructEnd()
14229 
 
14230 
  def validate(self):
14231 
    return
14232 
 
14233 
 
14234 
  def __repr__(self):
14235 
    L = ['%s=%r' % (key, value)
14236 
      for key, value in self.__dict__.iteritems()]
14237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14238 
 
14239 
  def __eq__(self, other):
14240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14241 
 
14242 
  def __ne__(self, other):
14243 
    return not (self == other)
14244 
 
14245 
class showCODOption_result:
14246 
  """
14247 
  Attributes:
14248 
   - success
14249 
  """
14250 
 
14251 
  thrift_spec = (
14252 
    (0, TType.BOOL, 'success', None, None, ), # 0
14253 
  )
14254 
 
14255 
  def __init__(self, success=None,):
14256 
    self.success = success
14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      if fid == 0:
14268 
        if ftype == TType.BOOL:
14269 
          self.success = iprot.readBool();
14270 
        else:
14271 
          iprot.skip(ftype)
14272 
      else:
14273 
        iprot.skip(ftype)
14274 
      iprot.readFieldEnd()
14275 
    iprot.readStructEnd()
14276 
 
14277 
  def write(self, oprot):
14278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14280 
      return
14281 
    oprot.writeStructBegin('showCODOption_result')
14282 
    if self.success is not None:
14283 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14284 
      oprot.writeBool(self.success)
14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
5623 anupam.sin 14303 
 
14304 
class getUserEmails_args:
14305 
  """
14306 
  Attributes:
14307 
   - startDate
14308 
   - endDate
14309 
  """
14310 
 
14311 
  thrift_spec = (
14312 
    None, # 0
14313 
    (1, TType.I64, 'startDate', None, None, ), # 1
14314 
    (2, TType.I64, 'endDate', None, None, ), # 2
14315 
  )
14316 
 
14317 
  def __init__(self, startDate=None, endDate=None,):
14318 
    self.startDate = startDate
14319 
    self.endDate = endDate
14320 
 
14321 
  def read(self, iprot):
14322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14324 
      return
14325 
    iprot.readStructBegin()
14326 
    while True:
14327 
      (fname, ftype, fid) = iprot.readFieldBegin()
14328 
      if ftype == TType.STOP:
14329 
        break
14330 
      if fid == 1:
14331 
        if ftype == TType.I64:
14332 
          self.startDate = iprot.readI64();
14333 
        else:
14334 
          iprot.skip(ftype)
14335 
      elif fid == 2:
14336 
        if ftype == TType.I64:
14337 
          self.endDate = iprot.readI64();
14338 
        else:
14339 
          iprot.skip(ftype)
14340 
      else:
14341 
        iprot.skip(ftype)
14342 
      iprot.readFieldEnd()
14343 
    iprot.readStructEnd()
14344 
 
14345 
  def write(self, oprot):
14346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14348 
      return
14349 
    oprot.writeStructBegin('getUserEmails_args')
14350 
    if self.startDate is not None:
14351 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14352 
      oprot.writeI64(self.startDate)
14353 
      oprot.writeFieldEnd()
14354 
    if self.endDate is not None:
14355 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14356 
      oprot.writeI64(self.endDate)
14357 
      oprot.writeFieldEnd()
14358 
    oprot.writeFieldStop()
14359 
    oprot.writeStructEnd()
14360 
 
14361 
  def validate(self):
14362 
    return
14363 
 
14364 
 
14365 
  def __repr__(self):
14366 
    L = ['%s=%r' % (key, value)
14367 
      for key, value in self.__dict__.iteritems()]
14368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14369 
 
14370 
  def __eq__(self, other):
14371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14372 
 
14373 
  def __ne__(self, other):
14374 
    return not (self == other)
14375 
 
14376 
class getUserEmails_result:
14377 
  """
14378 
  Attributes:
14379 
   - success
14380 
  """
14381 
 
14382 
  thrift_spec = (
14383 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14384 
  )
14385 
 
14386 
  def __init__(self, success=None,):
14387 
    self.success = success
14388 
 
14389 
  def read(self, iprot):
14390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14392 
      return
14393 
    iprot.readStructBegin()
14394 
    while True:
14395 
      (fname, ftype, fid) = iprot.readFieldBegin()
14396 
      if ftype == TType.STOP:
14397 
        break
14398 
      if fid == 0:
14399 
        if ftype == TType.LIST:
14400 
          self.success = []
11980 amit.gupta 14401 
          (_etype214, _size211) = iprot.readListBegin()
14402 
          for _i215 in xrange(_size211):
14403 
            _elem216 = iprot.readString();
14404 
            self.success.append(_elem216)
5623 anupam.sin 14405 
          iprot.readListEnd()
14406 
        else:
14407 
          iprot.skip(ftype)
14408 
      else:
14409 
        iprot.skip(ftype)
14410 
      iprot.readFieldEnd()
14411 
    iprot.readStructEnd()
14412 
 
14413 
  def write(self, oprot):
14414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14416 
      return
14417 
    oprot.writeStructBegin('getUserEmails_result')
14418 
    if self.success is not None:
14419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14420 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14421 
      for iter217 in self.success:
14422 
        oprot.writeString(iter217)
5623 anupam.sin 14423 
      oprot.writeListEnd()
14424 
      oprot.writeFieldEnd()
14425 
    oprot.writeFieldStop()
14426 
    oprot.writeStructEnd()
14427 
 
14428 
  def validate(self):
14429 
    return
14430 
 
14431 
 
14432 
  def __repr__(self):
14433 
    L = ['%s=%r' % (key, value)
14434 
      for key, value in self.__dict__.iteritems()]
14435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14436 
 
14437 
  def __eq__(self, other):
14438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14439 
 
14440 
  def __ne__(self, other):
14441 
    return not (self == other)
6821 amar.kumar 14442 
 
6903 anupam.sin 14443 
class insureItem_args:
14444 
  """
14445 
  Attributes:
14446 
   - itemId
14447 
   - cartId
14448 
   - toInsure
9299 kshitij.so 14449 
   - insurerType
6903 anupam.sin 14450 
  """
14451 
 
14452 
  thrift_spec = (
14453 
    None, # 0
14454 
    (1, TType.I64, 'itemId', None, None, ), # 1
14455 
    (2, TType.I64, 'cartId', None, None, ), # 2
14456 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14457 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14458 
  )
14459 
 
9299 kshitij.so 14460 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14461 
    self.itemId = itemId
14462 
    self.cartId = cartId
14463 
    self.toInsure = toInsure
9299 kshitij.so 14464 
    self.insurerType = insurerType
6903 anupam.sin 14465 
 
14466 
  def read(self, iprot):
14467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14469 
      return
14470 
    iprot.readStructBegin()
14471 
    while True:
14472 
      (fname, ftype, fid) = iprot.readFieldBegin()
14473 
      if ftype == TType.STOP:
14474 
        break
14475 
      if fid == 1:
14476 
        if ftype == TType.I64:
14477 
          self.itemId = iprot.readI64();
14478 
        else:
14479 
          iprot.skip(ftype)
14480 
      elif fid == 2:
14481 
        if ftype == TType.I64:
14482 
          self.cartId = iprot.readI64();
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      elif fid == 3:
14486 
        if ftype == TType.BOOL:
14487 
          self.toInsure = iprot.readBool();
14488 
        else:
14489 
          iprot.skip(ftype)
9299 kshitij.so 14490 
      elif fid == 4:
14491 
        if ftype == TType.I32:
14492 
          self.insurerType = iprot.readI32();
14493 
        else:
14494 
          iprot.skip(ftype)
6903 anupam.sin 14495 
      else:
14496 
        iprot.skip(ftype)
14497 
      iprot.readFieldEnd()
14498 
    iprot.readStructEnd()
14499 
 
14500 
  def write(self, oprot):
14501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14503 
      return
14504 
    oprot.writeStructBegin('insureItem_args')
14505 
    if self.itemId is not None:
14506 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14507 
      oprot.writeI64(self.itemId)
14508 
      oprot.writeFieldEnd()
14509 
    if self.cartId is not None:
14510 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14511 
      oprot.writeI64(self.cartId)
14512 
      oprot.writeFieldEnd()
14513 
    if self.toInsure is not None:
14514 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14515 
      oprot.writeBool(self.toInsure)
14516 
      oprot.writeFieldEnd()
9299 kshitij.so 14517 
    if self.insurerType is not None:
14518 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14519 
      oprot.writeI32(self.insurerType)
14520 
      oprot.writeFieldEnd()
6903 anupam.sin 14521 
    oprot.writeFieldStop()
14522 
    oprot.writeStructEnd()
14523 
 
14524 
  def validate(self):
14525 
    return
14526 
 
14527 
 
14528 
  def __repr__(self):
14529 
    L = ['%s=%r' % (key, value)
14530 
      for key, value in self.__dict__.iteritems()]
14531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14532 
 
14533 
  def __eq__(self, other):
14534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14535 
 
14536 
  def __ne__(self, other):
14537 
    return not (self == other)
14538 
 
14539 
class insureItem_result:
14540 
  """
14541 
  Attributes:
14542 
   - success
14543 
  """
14544 
 
14545 
  thrift_spec = (
14546 
    (0, TType.BOOL, 'success', None, None, ), # 0
14547 
  )
14548 
 
14549 
  def __init__(self, success=None,):
14550 
    self.success = success
14551 
 
14552 
  def read(self, iprot):
14553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14555 
      return
14556 
    iprot.readStructBegin()
14557 
    while True:
14558 
      (fname, ftype, fid) = iprot.readFieldBegin()
14559 
      if ftype == TType.STOP:
14560 
        break
14561 
      if fid == 0:
14562 
        if ftype == TType.BOOL:
14563 
          self.success = iprot.readBool();
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('insureItem_result')
14576 
    if self.success is not None:
14577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14578 
      oprot.writeBool(self.success)
14579 
      oprot.writeFieldEnd()
14580 
    oprot.writeFieldStop()
14581 
    oprot.writeStructEnd()
14582 
 
14583 
  def validate(self):
14584 
    return
14585 
 
14586 
 
14587 
  def __repr__(self):
14588 
    L = ['%s=%r' % (key, value)
14589 
      for key, value in self.__dict__.iteritems()]
14590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14591 
 
14592 
  def __eq__(self, other):
14593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14594 
 
14595 
  def __ne__(self, other):
14596 
    return not (self == other)
14597 
 
14598 
class cancelInsurance_args:
14599 
  """
14600 
  Attributes:
14601 
   - cartId
14602 
  """
14603 
 
14604 
  thrift_spec = (
14605 
    None, # 0
14606 
    (1, TType.I64, 'cartId', None, None, ), # 1
14607 
  )
14608 
 
14609 
  def __init__(self, cartId=None,):
14610 
    self.cartId = cartId
14611 
 
14612 
  def read(self, iprot):
14613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14615 
      return
14616 
    iprot.readStructBegin()
14617 
    while True:
14618 
      (fname, ftype, fid) = iprot.readFieldBegin()
14619 
      if ftype == TType.STOP:
14620 
        break
14621 
      if fid == 1:
14622 
        if ftype == TType.I64:
14623 
          self.cartId = iprot.readI64();
14624 
        else:
14625 
          iprot.skip(ftype)
14626 
      else:
14627 
        iprot.skip(ftype)
14628 
      iprot.readFieldEnd()
14629 
    iprot.readStructEnd()
14630 
 
14631 
  def write(self, oprot):
14632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14634 
      return
14635 
    oprot.writeStructBegin('cancelInsurance_args')
14636 
    if self.cartId is not None:
14637 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14638 
      oprot.writeI64(self.cartId)
14639 
      oprot.writeFieldEnd()
14640 
    oprot.writeFieldStop()
14641 
    oprot.writeStructEnd()
14642 
 
14643 
  def validate(self):
14644 
    return
14645 
 
14646 
 
14647 
  def __repr__(self):
14648 
    L = ['%s=%r' % (key, value)
14649 
      for key, value in self.__dict__.iteritems()]
14650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14651 
 
14652 
  def __eq__(self, other):
14653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14654 
 
14655 
  def __ne__(self, other):
14656 
    return not (self == other)
14657 
 
14658 
class cancelInsurance_result:
14659 
  """
14660 
  Attributes:
14661 
   - success
14662 
  """
14663 
 
14664 
  thrift_spec = (
14665 
    (0, TType.BOOL, 'success', None, None, ), # 0
14666 
  )
14667 
 
14668 
  def __init__(self, success=None,):
14669 
    self.success = success
14670 
 
14671 
  def read(self, iprot):
14672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14674 
      return
14675 
    iprot.readStructBegin()
14676 
    while True:
14677 
      (fname, ftype, fid) = iprot.readFieldBegin()
14678 
      if ftype == TType.STOP:
14679 
        break
14680 
      if fid == 0:
14681 
        if ftype == TType.BOOL:
14682 
          self.success = iprot.readBool();
14683 
        else:
14684 
          iprot.skip(ftype)
14685 
      else:
14686 
        iprot.skip(ftype)
14687 
      iprot.readFieldEnd()
14688 
    iprot.readStructEnd()
14689 
 
14690 
  def write(self, oprot):
14691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14693 
      return
14694 
    oprot.writeStructBegin('cancelInsurance_result')
14695 
    if self.success is not None:
14696 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14697 
      oprot.writeBool(self.success)
14698 
      oprot.writeFieldEnd()
14699 
    oprot.writeFieldStop()
14700 
    oprot.writeStructEnd()
14701 
 
14702 
  def validate(self):
14703 
    return
14704 
 
14705 
 
14706 
  def __repr__(self):
14707 
    L = ['%s=%r' % (key, value)
14708 
      for key, value in self.__dict__.iteritems()]
14709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14710 
 
14711 
  def __eq__(self, other):
14712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14713 
 
14714 
  def __ne__(self, other):
14715 
    return not (self == other)
14716 
 
14717 
class storeInsuranceSpecificDetails_args:
14718 
  """
14719 
  Attributes:
14720 
   - addressId
14721 
   - dob
14722 
   - guardianName
14723 
  """
14724 
 
14725 
  thrift_spec = (
14726 
    None, # 0
14727 
    (1, TType.I64, 'addressId', None, None, ), # 1
14728 
    (2, TType.STRING, 'dob', None, None, ), # 2
14729 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14730 
  )
14731 
 
14732 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14733 
    self.addressId = addressId
14734 
    self.dob = dob
14735 
    self.guardianName = guardianName
14736 
 
14737 
  def read(self, iprot):
14738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14740 
      return
14741 
    iprot.readStructBegin()
14742 
    while True:
14743 
      (fname, ftype, fid) = iprot.readFieldBegin()
14744 
      if ftype == TType.STOP:
14745 
        break
14746 
      if fid == 1:
14747 
        if ftype == TType.I64:
14748 
          self.addressId = iprot.readI64();
14749 
        else:
14750 
          iprot.skip(ftype)
14751 
      elif fid == 2:
14752 
        if ftype == TType.STRING:
14753 
          self.dob = iprot.readString();
14754 
        else:
14755 
          iprot.skip(ftype)
14756 
      elif fid == 3:
14757 
        if ftype == TType.STRING:
14758 
          self.guardianName = iprot.readString();
14759 
        else:
14760 
          iprot.skip(ftype)
14761 
      else:
14762 
        iprot.skip(ftype)
14763 
      iprot.readFieldEnd()
14764 
    iprot.readStructEnd()
14765 
 
14766 
  def write(self, oprot):
14767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14769 
      return
14770 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14771 
    if self.addressId is not None:
14772 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14773 
      oprot.writeI64(self.addressId)
14774 
      oprot.writeFieldEnd()
14775 
    if self.dob is not None:
14776 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14777 
      oprot.writeString(self.dob)
14778 
      oprot.writeFieldEnd()
14779 
    if self.guardianName is not None:
14780 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14781 
      oprot.writeString(self.guardianName)
14782 
      oprot.writeFieldEnd()
14783 
    oprot.writeFieldStop()
14784 
    oprot.writeStructEnd()
14785 
 
14786 
  def validate(self):
14787 
    return
14788 
 
14789 
 
14790 
  def __repr__(self):
14791 
    L = ['%s=%r' % (key, value)
14792 
      for key, value in self.__dict__.iteritems()]
14793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14794 
 
14795 
  def __eq__(self, other):
14796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14797 
 
14798 
  def __ne__(self, other):
14799 
    return not (self == other)
14800 
 
14801 
class storeInsuranceSpecificDetails_result:
14802 
  """
14803 
  Attributes:
14804 
   - success
14805 
  """
14806 
 
14807 
  thrift_spec = (
14808 
    (0, TType.BOOL, 'success', None, None, ), # 0
14809 
  )
14810 
 
14811 
  def __init__(self, success=None,):
14812 
    self.success = success
14813 
 
14814 
  def read(self, iprot):
14815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14817 
      return
14818 
    iprot.readStructBegin()
14819 
    while True:
14820 
      (fname, ftype, fid) = iprot.readFieldBegin()
14821 
      if ftype == TType.STOP:
14822 
        break
14823 
      if fid == 0:
14824 
        if ftype == TType.BOOL:
14825 
          self.success = iprot.readBool();
14826 
        else:
14827 
          iprot.skip(ftype)
14828 
      else:
14829 
        iprot.skip(ftype)
14830 
      iprot.readFieldEnd()
14831 
    iprot.readStructEnd()
14832 
 
14833 
  def write(self, oprot):
14834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14836 
      return
14837 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14838 
    if self.success is not None:
14839 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14840 
      oprot.writeBool(self.success)
14841 
      oprot.writeFieldEnd()
14842 
    oprot.writeFieldStop()
14843 
    oprot.writeStructEnd()
14844 
 
14845 
  def validate(self):
14846 
    return
14847 
 
14848 
 
14849 
  def __repr__(self):
14850 
    L = ['%s=%r' % (key, value)
14851 
      for key, value in self.__dict__.iteritems()]
14852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14853 
 
14854 
  def __eq__(self, other):
14855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14856 
 
14857 
  def __ne__(self, other):
14858 
    return not (self == other)
14859 
 
14860 
class isInsuranceDetailPresent_args:
14861 
  """
14862 
  Attributes:
14863 
   - addressId
14864 
  """
14865 
 
14866 
  thrift_spec = (
14867 
    None, # 0
14868 
    (1, TType.I64, 'addressId', None, None, ), # 1
14869 
  )
14870 
 
14871 
  def __init__(self, addressId=None,):
14872 
    self.addressId = addressId
14873 
 
14874 
  def read(self, iprot):
14875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14877 
      return
14878 
    iprot.readStructBegin()
14879 
    while True:
14880 
      (fname, ftype, fid) = iprot.readFieldBegin()
14881 
      if ftype == TType.STOP:
14882 
        break
14883 
      if fid == 1:
14884 
        if ftype == TType.I64:
14885 
          self.addressId = iprot.readI64();
14886 
        else:
14887 
          iprot.skip(ftype)
14888 
      else:
14889 
        iprot.skip(ftype)
14890 
      iprot.readFieldEnd()
14891 
    iprot.readStructEnd()
14892 
 
14893 
  def write(self, oprot):
14894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14896 
      return
14897 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14898 
    if self.addressId is not None:
14899 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14900 
      oprot.writeI64(self.addressId)
14901 
      oprot.writeFieldEnd()
14902 
    oprot.writeFieldStop()
14903 
    oprot.writeStructEnd()
14904 
 
14905 
  def validate(self):
14906 
    return
14907 
 
14908 
 
14909 
  def __repr__(self):
14910 
    L = ['%s=%r' % (key, value)
14911 
      for key, value in self.__dict__.iteritems()]
14912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14913 
 
14914 
  def __eq__(self, other):
14915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14916 
 
14917 
  def __ne__(self, other):
14918 
    return not (self == other)
14919 
 
14920 
class isInsuranceDetailPresent_result:
14921 
  """
14922 
  Attributes:
14923 
   - success
14924 
  """
14925 
 
14926 
  thrift_spec = (
14927 
    (0, TType.BOOL, 'success', None, None, ), # 0
14928 
  )
14929 
 
14930 
  def __init__(self, success=None,):
14931 
    self.success = success
14932 
 
14933 
  def read(self, iprot):
14934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14936 
      return
14937 
    iprot.readStructBegin()
14938 
    while True:
14939 
      (fname, ftype, fid) = iprot.readFieldBegin()
14940 
      if ftype == TType.STOP:
14941 
        break
14942 
      if fid == 0:
14943 
        if ftype == TType.BOOL:
14944 
          self.success = iprot.readBool();
14945 
        else:
14946 
          iprot.skip(ftype)
14947 
      else:
14948 
        iprot.skip(ftype)
14949 
      iprot.readFieldEnd()
14950 
    iprot.readStructEnd()
14951 
 
14952 
  def write(self, oprot):
14953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14955 
      return
14956 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14957 
    if self.success is not None:
14958 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14959 
      oprot.writeBool(self.success)
14960 
      oprot.writeFieldEnd()
14961 
    oprot.writeFieldStop()
14962 
    oprot.writeStructEnd()
14963 
 
14964 
  def validate(self):
14965 
    return
14966 
 
14967 
 
14968 
  def __repr__(self):
14969 
    L = ['%s=%r' % (key, value)
14970 
      for key, value in self.__dict__.iteritems()]
14971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14972 
 
14973 
  def __eq__(self, other):
14974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14975 
 
14976 
  def __ne__(self, other):
14977 
    return not (self == other)
14978 
 
9791 rajveer 14979 
class getProductsAddedToCart_args:
6821 amar.kumar 14980 
  """
14981 
  Attributes:
14982 
   - startDate
14983 
   - endDate
14984 
  """
14985 
 
14986 
  thrift_spec = (
14987 
    None, # 0
9791 rajveer 14988 
    (1, TType.I64, 'startDate', None, None, ), # 1
14989 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14990 
  )
14991 
 
9791 rajveer 14992 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14993 
    self.startDate = startDate
14994 
    self.endDate = endDate
14995 
 
14996 
  def read(self, iprot):
14997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14999 
      return
15000 
    iprot.readStructBegin()
15001 
    while True:
15002 
      (fname, ftype, fid) = iprot.readFieldBegin()
15003 
      if ftype == TType.STOP:
15004 
        break
15005 
      if fid == 1:
15006 
        if ftype == TType.I64:
9791 rajveer 15007 
          self.startDate = iprot.readI64();
6821 amar.kumar 15008 
        else:
15009 
          iprot.skip(ftype)
15010 
      elif fid == 2:
15011 
        if ftype == TType.I64:
15012 
          self.endDate = iprot.readI64();
15013 
        else:
15014 
          iprot.skip(ftype)
15015 
      else:
15016 
        iprot.skip(ftype)
15017 
      iprot.readFieldEnd()
15018 
    iprot.readStructEnd()
15019 
 
15020 
  def write(self, oprot):
15021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15023 
      return
9791 rajveer 15024 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15025 
    if self.startDate is not None:
9791 rajveer 15026 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15027 
      oprot.writeI64(self.startDate)
15028 
      oprot.writeFieldEnd()
15029 
    if self.endDate is not None:
9791 rajveer 15030 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15031 
      oprot.writeI64(self.endDate)
15032 
      oprot.writeFieldEnd()
15033 
    oprot.writeFieldStop()
15034 
    oprot.writeStructEnd()
15035 
 
15036 
  def validate(self):
15037 
    return
15038 
 
15039 
 
15040 
  def __repr__(self):
15041 
    L = ['%s=%r' % (key, value)
15042 
      for key, value in self.__dict__.iteritems()]
15043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15044 
 
15045 
  def __eq__(self, other):
15046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15047 
 
15048 
  def __ne__(self, other):
15049 
    return not (self == other)
15050 
 
9791 rajveer 15051 
class getProductsAddedToCart_result:
6821 amar.kumar 15052 
  """
15053 
  Attributes:
15054 
   - success
15055 
  """
15056 
 
15057 
  thrift_spec = (
9791 rajveer 15058 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15059 
  )
15060 
 
15061 
  def __init__(self, success=None,):
15062 
    self.success = success
15063 
 
15064 
  def read(self, iprot):
15065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15067 
      return
15068 
    iprot.readStructBegin()
15069 
    while True:
15070 
      (fname, ftype, fid) = iprot.readFieldBegin()
15071 
      if ftype == TType.STOP:
15072 
        break
15073 
      if fid == 0:
9791 rajveer 15074 
        if ftype == TType.LIST:
15075 
          self.success = []
11980 amit.gupta 15076 
          (_etype221, _size218) = iprot.readListBegin()
15077 
          for _i222 in xrange(_size218):
15078 
            _elem223 = iprot.readI64();
15079 
            self.success.append(_elem223)
9791 rajveer 15080 
          iprot.readListEnd()
6821 amar.kumar 15081 
        else:
15082 
          iprot.skip(ftype)
15083 
      else:
15084 
        iprot.skip(ftype)
15085 
      iprot.readFieldEnd()
15086 
    iprot.readStructEnd()
15087 
 
15088 
  def write(self, oprot):
15089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15091 
      return
9791 rajveer 15092 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15093 
    if self.success is not None:
9791 rajveer 15094 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15095 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15096 
      for iter224 in self.success:
15097 
        oprot.writeI64(iter224)
9791 rajveer 15098 
      oprot.writeListEnd()
6821 amar.kumar 15099 
      oprot.writeFieldEnd()
15100 
    oprot.writeFieldStop()
15101 
    oprot.writeStructEnd()
15102 
 
15103 
  def validate(self):
15104 
    return
15105 
 
15106 
 
15107 
  def __repr__(self):
15108 
    L = ['%s=%r' % (key, value)
15109 
      for key, value in self.__dict__.iteritems()]
15110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15111 
 
15112 
  def __eq__(self, other):
15113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15114 
 
15115 
  def __ne__(self, other):
15116 
    return not (self == other)
11592 amit.gupta 15117 
 
15118 
class validateCartPlus_args:
15119 
  """
15120 
  Attributes:
15121 
   - cartId
15122 
   - sourceId
11980 amit.gupta 15123 
   - dealerCoupon
11592 amit.gupta 15124 
  """
15125 
 
15126 
  thrift_spec = (
15127 
    None, # 0
15128 
    (1, TType.I64, 'cartId', None, None, ), # 1
15129 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15130 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15131 
  )
15132 
 
11980 amit.gupta 15133 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15134 
    self.cartId = cartId
15135 
    self.sourceId = sourceId
11980 amit.gupta 15136 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15137 
 
15138 
  def read(self, iprot):
15139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15141 
      return
15142 
    iprot.readStructBegin()
15143 
    while True:
15144 
      (fname, ftype, fid) = iprot.readFieldBegin()
15145 
      if ftype == TType.STOP:
15146 
        break
15147 
      if fid == 1:
15148 
        if ftype == TType.I64:
15149 
          self.cartId = iprot.readI64();
15150 
        else:
15151 
          iprot.skip(ftype)
15152 
      elif fid == 2:
15153 
        if ftype == TType.I64:
15154 
          self.sourceId = iprot.readI64();
15155 
        else:
15156 
          iprot.skip(ftype)
11980 amit.gupta 15157 
      elif fid == 3:
15158 
        if ftype == TType.STRING:
15159 
          self.dealerCoupon = iprot.readString();
15160 
        else:
15161 
          iprot.skip(ftype)
11592 amit.gupta 15162 
      else:
15163 
        iprot.skip(ftype)
15164 
      iprot.readFieldEnd()
15165 
    iprot.readStructEnd()
15166 
 
15167 
  def write(self, oprot):
15168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15170 
      return
15171 
    oprot.writeStructBegin('validateCartPlus_args')
15172 
    if self.cartId is not None:
15173 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15174 
      oprot.writeI64(self.cartId)
15175 
      oprot.writeFieldEnd()
15176 
    if self.sourceId is not None:
15177 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15178 
      oprot.writeI64(self.sourceId)
15179 
      oprot.writeFieldEnd()
11980 amit.gupta 15180 
    if self.dealerCoupon is not None:
15181 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15182 
      oprot.writeString(self.dealerCoupon)
15183 
      oprot.writeFieldEnd()
11592 amit.gupta 15184 
    oprot.writeFieldStop()
15185 
    oprot.writeStructEnd()
15186 
 
15187 
  def validate(self):
15188 
    return
15189 
 
15190 
 
15191 
  def __repr__(self):
15192 
    L = ['%s=%r' % (key, value)
15193 
      for key, value in self.__dict__.iteritems()]
15194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15195 
 
15196 
  def __eq__(self, other):
15197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15198 
 
15199 
  def __ne__(self, other):
15200 
    return not (self == other)
15201 
 
15202 
class validateCartPlus_result:
15203 
  """
15204 
  Attributes:
15205 
   - success
15206 
   - scex
15207 
  """
15208 
 
15209 
  thrift_spec = (
15210 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15211 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15212 
  )
15213 
 
15214 
  def __init__(self, success=None, scex=None,):
15215 
    self.success = success
15216 
    self.scex = scex
15217 
 
15218 
  def read(self, iprot):
15219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15221 
      return
15222 
    iprot.readStructBegin()
15223 
    while True:
15224 
      (fname, ftype, fid) = iprot.readFieldBegin()
15225 
      if ftype == TType.STOP:
15226 
        break
15227 
      if fid == 0:
15228 
        if ftype == TType.STRUCT:
15229 
          self.success = CartPlus()
15230 
          self.success.read(iprot)
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      elif fid == 1:
15234 
        if ftype == TType.STRUCT:
15235 
          self.scex = ShoppingCartException()
15236 
          self.scex.read(iprot)
15237 
        else:
15238 
          iprot.skip(ftype)
15239 
      else:
15240 
        iprot.skip(ftype)
15241 
      iprot.readFieldEnd()
15242 
    iprot.readStructEnd()
15243 
 
15244 
  def write(self, oprot):
15245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15247 
      return
15248 
    oprot.writeStructBegin('validateCartPlus_result')
15249 
    if self.success is not None:
15250 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15251 
      self.success.write(oprot)
15252 
      oprot.writeFieldEnd()
15253 
    if self.scex is not None:
15254 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15255 
      self.scex.write(oprot)
15256 
      oprot.writeFieldEnd()
15257 
    oprot.writeFieldStop()
15258 
    oprot.writeStructEnd()
15259 
 
15260 
  def validate(self):
15261 
    return
15262 
 
15263 
 
15264 
  def __repr__(self):
15265 
    L = ['%s=%r' % (key, value)
15266 
      for key, value in self.__dict__.iteritems()]
15267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15268 
 
15269 
  def __eq__(self, other):
15270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15271 
 
15272 
  def __ne__(self, other):
15273 
    return not (self == other)
11679 vikram.rag 15274 
 
15275 
class isPrivateDealUser_args:
15276 
  """
15277 
  Attributes:
15278 
   - userId
15279 
  """
15280 
 
15281 
  thrift_spec = (
15282 
    None, # 0
15283 
    (1, TType.I64, 'userId', None, None, ), # 1
15284 
  )
15285 
 
15286 
  def __init__(self, userId=None,):
15287 
    self.userId = userId
15288 
 
15289 
  def read(self, iprot):
15290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15292 
      return
15293 
    iprot.readStructBegin()
15294 
    while True:
15295 
      (fname, ftype, fid) = iprot.readFieldBegin()
15296 
      if ftype == TType.STOP:
15297 
        break
15298 
      if fid == 1:
15299 
        if ftype == TType.I64:
15300 
          self.userId = iprot.readI64();
15301 
        else:
15302 
          iprot.skip(ftype)
15303 
      else:
15304 
        iprot.skip(ftype)
15305 
      iprot.readFieldEnd()
15306 
    iprot.readStructEnd()
15307 
 
15308 
  def write(self, oprot):
15309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15311 
      return
15312 
    oprot.writeStructBegin('isPrivateDealUser_args')
15313 
    if self.userId is not None:
15314 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15315 
      oprot.writeI64(self.userId)
15316 
      oprot.writeFieldEnd()
15317 
    oprot.writeFieldStop()
15318 
    oprot.writeStructEnd()
15319 
 
15320 
  def validate(self):
15321 
    return
15322 
 
15323 
 
15324 
  def __repr__(self):
15325 
    L = ['%s=%r' % (key, value)
15326 
      for key, value in self.__dict__.iteritems()]
15327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15328 
 
15329 
  def __eq__(self, other):
15330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15331 
 
15332 
  def __ne__(self, other):
15333 
    return not (self == other)
15334 
 
15335 
class isPrivateDealUser_result:
15336 
  """
15337 
  Attributes:
15338 
   - success
15339 
  """
15340 
 
15341 
  thrift_spec = (
15342 
    (0, TType.BOOL, 'success', None, None, ), # 0
15343 
  )
15344 
 
15345 
  def __init__(self, success=None,):
15346 
    self.success = success
15347 
 
15348 
  def read(self, iprot):
15349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15351 
      return
15352 
    iprot.readStructBegin()
15353 
    while True:
15354 
      (fname, ftype, fid) = iprot.readFieldBegin()
15355 
      if ftype == TType.STOP:
15356 
        break
15357 
      if fid == 0:
15358 
        if ftype == TType.BOOL:
15359 
          self.success = iprot.readBool();
15360 
        else:
15361 
          iprot.skip(ftype)
15362 
      else:
15363 
        iprot.skip(ftype)
15364 
      iprot.readFieldEnd()
15365 
    iprot.readStructEnd()
15366 
 
15367 
  def write(self, oprot):
15368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15370 
      return
15371 
    oprot.writeStructBegin('isPrivateDealUser_result')
15372 
    if self.success is not None:
15373 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15374 
      oprot.writeBool(self.success)
15375 
      oprot.writeFieldEnd()
15376 
    oprot.writeFieldStop()
15377 
    oprot.writeStructEnd()
15378 
 
15379 
  def validate(self):
15380 
    return
15381 
 
15382 
 
15383 
  def __repr__(self):
15384 
    L = ['%s=%r' % (key, value)
15385 
      for key, value in self.__dict__.iteritems()]
15386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15387 
 
15388 
  def __eq__(self, other):
15389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15390 
 
15391 
  def __ne__(self, other):
15392 
    return not (self == other)
11890 kshitij.so 15393 
 
15394 
class addPrivateDealUser_args:
15395 
  """
15396 
  Attributes:
15397 
   - userId
15398 
  """
15399 
 
15400 
  thrift_spec = (
15401 
    None, # 0
15402 
    (1, TType.I64, 'userId', None, None, ), # 1
15403 
  )
15404 
 
15405 
  def __init__(self, userId=None,):
15406 
    self.userId = userId
15407 
 
15408 
  def read(self, iprot):
15409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15411 
      return
15412 
    iprot.readStructBegin()
15413 
    while True:
15414 
      (fname, ftype, fid) = iprot.readFieldBegin()
15415 
      if ftype == TType.STOP:
15416 
        break
15417 
      if fid == 1:
15418 
        if ftype == TType.I64:
15419 
          self.userId = iprot.readI64();
15420 
        else:
15421 
          iprot.skip(ftype)
15422 
      else:
15423 
        iprot.skip(ftype)
15424 
      iprot.readFieldEnd()
15425 
    iprot.readStructEnd()
15426 
 
15427 
  def write(self, oprot):
15428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15430 
      return
15431 
    oprot.writeStructBegin('addPrivateDealUser_args')
15432 
    if self.userId is not None:
15433 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15434 
      oprot.writeI64(self.userId)
15435 
      oprot.writeFieldEnd()
15436 
    oprot.writeFieldStop()
15437 
    oprot.writeStructEnd()
15438 
 
15439 
  def validate(self):
15440 
    return
15441 
 
15442 
 
15443 
  def __repr__(self):
15444 
    L = ['%s=%r' % (key, value)
15445 
      for key, value in self.__dict__.iteritems()]
15446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15447 
 
15448 
  def __eq__(self, other):
15449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15450 
 
15451 
  def __ne__(self, other):
15452 
    return not (self == other)
15453 
 
15454 
class addPrivateDealUser_result:
15455 
  """
15456 
  Attributes:
15457 
   - success
15458 
  """
15459 
 
15460 
  thrift_spec = (
15461 
    (0, TType.BOOL, 'success', None, None, ), # 0
15462 
  )
15463 
 
15464 
  def __init__(self, success=None,):
15465 
    self.success = success
15466 
 
15467 
  def read(self, iprot):
15468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15470 
      return
15471 
    iprot.readStructBegin()
15472 
    while True:
15473 
      (fname, ftype, fid) = iprot.readFieldBegin()
15474 
      if ftype == TType.STOP:
15475 
        break
15476 
      if fid == 0:
15477 
        if ftype == TType.BOOL:
15478 
          self.success = iprot.readBool();
15479 
        else:
15480 
          iprot.skip(ftype)
15481 
      else:
15482 
        iprot.skip(ftype)
15483 
      iprot.readFieldEnd()
15484 
    iprot.readStructEnd()
15485 
 
15486 
  def write(self, oprot):
15487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15489 
      return
15490 
    oprot.writeStructBegin('addPrivateDealUser_result')
15491 
    if self.success is not None:
15492 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15493 
      oprot.writeBool(self.success)
15494 
      oprot.writeFieldEnd()
15495 
    oprot.writeFieldStop()
15496 
    oprot.writeStructEnd()
15497 
 
15498 
  def validate(self):
15499 
    return
15500 
 
15501 
 
15502 
  def __repr__(self):
15503 
    L = ['%s=%r' % (key, value)
15504 
      for key, value in self.__dict__.iteritems()]
15505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15506 
 
15507 
  def __eq__(self, other):
15508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15509 
 
15510 
  def __ne__(self, other):
15511 
    return not (self == other)
15512 
 
15513 
class changePrivateDealUserStatus_args:
15514 
  """
15515 
  Attributes:
15516 
   - userId
15517 
   - isActive
15518 
  """
15519 
 
15520 
  thrift_spec = (
15521 
    None, # 0
15522 
    (1, TType.I64, 'userId', None, None, ), # 1
15523 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15524 
  )
15525 
 
15526 
  def __init__(self, userId=None, isActive=None,):
15527 
    self.userId = userId
15528 
    self.isActive = isActive
15529 
 
15530 
  def read(self, iprot):
15531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15533 
      return
15534 
    iprot.readStructBegin()
15535 
    while True:
15536 
      (fname, ftype, fid) = iprot.readFieldBegin()
15537 
      if ftype == TType.STOP:
15538 
        break
15539 
      if fid == 1:
15540 
        if ftype == TType.I64:
15541 
          self.userId = iprot.readI64();
15542 
        else:
15543 
          iprot.skip(ftype)
15544 
      elif fid == 2:
15545 
        if ftype == TType.BOOL:
15546 
          self.isActive = iprot.readBool();
15547 
        else:
15548 
          iprot.skip(ftype)
15549 
      else:
15550 
        iprot.skip(ftype)
15551 
      iprot.readFieldEnd()
15552 
    iprot.readStructEnd()
15553 
 
15554 
  def write(self, oprot):
15555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15557 
      return
15558 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15559 
    if self.userId is not None:
15560 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15561 
      oprot.writeI64(self.userId)
15562 
      oprot.writeFieldEnd()
15563 
    if self.isActive is not None:
15564 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15565 
      oprot.writeBool(self.isActive)
15566 
      oprot.writeFieldEnd()
15567 
    oprot.writeFieldStop()
15568 
    oprot.writeStructEnd()
15569 
 
15570 
  def validate(self):
15571 
    return
15572 
 
15573 
 
15574 
  def __repr__(self):
15575 
    L = ['%s=%r' % (key, value)
15576 
      for key, value in self.__dict__.iteritems()]
15577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15578 
 
15579 
  def __eq__(self, other):
15580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15581 
 
15582 
  def __ne__(self, other):
15583 
    return not (self == other)
15584 
 
15585 
class changePrivateDealUserStatus_result:
15586 
  """
15587 
  Attributes:
15588 
   - success
15589 
  """
15590 
 
15591 
  thrift_spec = (
15592 
    (0, TType.BOOL, 'success', None, None, ), # 0
15593 
  )
15594 
 
15595 
  def __init__(self, success=None,):
15596 
    self.success = success
15597 
 
15598 
  def read(self, iprot):
15599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15601 
      return
15602 
    iprot.readStructBegin()
15603 
    while True:
15604 
      (fname, ftype, fid) = iprot.readFieldBegin()
15605 
      if ftype == TType.STOP:
15606 
        break
15607 
      if fid == 0:
15608 
        if ftype == TType.BOOL:
15609 
          self.success = iprot.readBool();
15610 
        else:
15611 
          iprot.skip(ftype)
15612 
      else:
15613 
        iprot.skip(ftype)
15614 
      iprot.readFieldEnd()
15615 
    iprot.readStructEnd()
15616 
 
15617 
  def write(self, oprot):
15618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15620 
      return
15621 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15622 
    if self.success is not None:
15623 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15624 
      oprot.writeBool(self.success)
15625 
      oprot.writeFieldEnd()
15626 
    oprot.writeFieldStop()
15627 
    oprot.writeStructEnd()
15628 
 
15629 
  def validate(self):
15630 
    return
15631 
 
15632 
 
15633 
  def __repr__(self):
15634 
    L = ['%s=%r' % (key, value)
15635 
      for key, value in self.__dict__.iteritems()]
15636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15637 
 
15638 
  def __eq__(self, other):
15639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15640 
 
15641 
  def __ne__(self, other):
15642 
    return not (self == other)
15643 
 
15644 
class getPrivateDealUser_args:
15645 
  """
15646 
  Attributes:
15647 
   - userId
15648 
  """
15649 
 
15650 
  thrift_spec = (
15651 
    None, # 0
15652 
    (1, TType.I64, 'userId', None, None, ), # 1
15653 
  )
15654 
 
15655 
  def __init__(self, userId=None,):
15656 
    self.userId = userId
15657 
 
15658 
  def read(self, iprot):
15659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15661 
      return
15662 
    iprot.readStructBegin()
15663 
    while True:
15664 
      (fname, ftype, fid) = iprot.readFieldBegin()
15665 
      if ftype == TType.STOP:
15666 
        break
15667 
      if fid == 1:
15668 
        if ftype == TType.I64:
15669 
          self.userId = iprot.readI64();
15670 
        else:
15671 
          iprot.skip(ftype)
15672 
      else:
15673 
        iprot.skip(ftype)
15674 
      iprot.readFieldEnd()
15675 
    iprot.readStructEnd()
15676 
 
15677 
  def write(self, oprot):
15678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15680 
      return
15681 
    oprot.writeStructBegin('getPrivateDealUser_args')
15682 
    if self.userId is not None:
15683 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15684 
      oprot.writeI64(self.userId)
15685 
      oprot.writeFieldEnd()
15686 
    oprot.writeFieldStop()
15687 
    oprot.writeStructEnd()
15688 
 
15689 
  def validate(self):
15690 
    return
15691 
 
15692 
 
15693 
  def __repr__(self):
15694 
    L = ['%s=%r' % (key, value)
15695 
      for key, value in self.__dict__.iteritems()]
15696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15697 
 
15698 
  def __eq__(self, other):
15699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15700 
 
15701 
  def __ne__(self, other):
15702 
    return not (self == other)
15703 
 
15704 
class getPrivateDealUser_result:
15705 
  """
15706 
  Attributes:
15707 
   - success
15708 
  """
15709 
 
15710 
  thrift_spec = (
15711 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15712 
  )
15713 
 
15714 
  def __init__(self, success=None,):
15715 
    self.success = success
15716 
 
15717 
  def read(self, iprot):
15718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15720 
      return
15721 
    iprot.readStructBegin()
15722 
    while True:
15723 
      (fname, ftype, fid) = iprot.readFieldBegin()
15724 
      if ftype == TType.STOP:
15725 
        break
15726 
      if fid == 0:
15727 
        if ftype == TType.STRUCT:
15728 
          self.success = PrivateDealUser()
15729 
          self.success.read(iprot)
15730 
        else:
15731 
          iprot.skip(ftype)
15732 
      else:
15733 
        iprot.skip(ftype)
15734 
      iprot.readFieldEnd()
15735 
    iprot.readStructEnd()
15736 
 
15737 
  def write(self, oprot):
15738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15740 
      return
15741 
    oprot.writeStructBegin('getPrivateDealUser_result')
15742 
    if self.success is not None:
15743 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15744 
      self.success.write(oprot)
15745 
      oprot.writeFieldEnd()
15746 
    oprot.writeFieldStop()
15747 
    oprot.writeStructEnd()
15748 
 
15749 
  def validate(self):
15750 
    return
15751 
 
15752 
 
15753 
  def __repr__(self):
15754 
    L = ['%s=%r' % (key, value)
15755 
      for key, value in self.__dict__.iteritems()]
15756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15757 
 
15758 
  def __eq__(self, other):
15759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15760 
 
15761 
  def __ne__(self, other):
15762 
    return not (self == other)
12696 amit.gupta 15763 
 
15764 
class registerCounter_args:
15765 
  """
15766 
  Attributes:
15767 
   - counter
15768 
   - userId
15769 
  """
15770 
 
15771 
  thrift_spec = (
15772 
    None, # 0
15773 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15774 
    (2, TType.I64, 'userId', None, None, ), # 2
15775 
  )
15776 
 
15777 
  def __init__(self, counter=None, userId=None,):
15778 
    self.counter = counter
15779 
    self.userId = userId
15780 
 
15781 
  def read(self, iprot):
15782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15784 
      return
15785 
    iprot.readStructBegin()
15786 
    while True:
15787 
      (fname, ftype, fid) = iprot.readFieldBegin()
15788 
      if ftype == TType.STOP:
15789 
        break
15790 
      if fid == 1:
15791 
        if ftype == TType.STRUCT:
15792 
          self.counter = Counter()
15793 
          self.counter.read(iprot)
15794 
        else:
15795 
          iprot.skip(ftype)
15796 
      elif fid == 2:
15797 
        if ftype == TType.I64:
15798 
          self.userId = iprot.readI64();
15799 
        else:
15800 
          iprot.skip(ftype)
15801 
      else:
15802 
        iprot.skip(ftype)
15803 
      iprot.readFieldEnd()
15804 
    iprot.readStructEnd()
15805 
 
15806 
  def write(self, oprot):
15807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15809 
      return
15810 
    oprot.writeStructBegin('registerCounter_args')
15811 
    if self.counter is not None:
15812 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15813 
      self.counter.write(oprot)
15814 
      oprot.writeFieldEnd()
15815 
    if self.userId is not None:
15816 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15817 
      oprot.writeI64(self.userId)
15818 
      oprot.writeFieldEnd()
15819 
    oprot.writeFieldStop()
15820 
    oprot.writeStructEnd()
15821 
 
15822 
  def validate(self):
15823 
    return
15824 
 
15825 
 
15826 
  def __repr__(self):
15827 
    L = ['%s=%r' % (key, value)
15828 
      for key, value in self.__dict__.iteritems()]
15829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15830 
 
15831 
  def __eq__(self, other):
15832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15833 
 
15834 
  def __ne__(self, other):
15835 
    return not (self == other)
15836 
 
15837 
class registerCounter_result:
15838 
  """
15839 
  Attributes:
15840 
   - success
15841 
  """
15842 
 
15843 
  thrift_spec = (
15844 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15845 
  )
15846 
 
15847 
  def __init__(self, success=None,):
15848 
    self.success = success
15849 
 
15850 
  def read(self, iprot):
15851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15853 
      return
15854 
    iprot.readStructBegin()
15855 
    while True:
15856 
      (fname, ftype, fid) = iprot.readFieldBegin()
15857 
      if ftype == TType.STOP:
15858 
        break
15859 
      if fid == 0:
15860 
        if ftype == TType.MAP:
15861 
          self.success = {}
15862 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15863 
          for _i229 in xrange(_size225):
15864 
            _key230 = iprot.readString();
15865 
            _val231 = iprot.readString();
15866 
            self.success[_key230] = _val231
15867 
          iprot.readMapEnd()
15868 
        else:
15869 
          iprot.skip(ftype)
15870 
      else:
15871 
        iprot.skip(ftype)
15872 
      iprot.readFieldEnd()
15873 
    iprot.readStructEnd()
15874 
 
15875 
  def write(self, oprot):
15876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15878 
      return
15879 
    oprot.writeStructBegin('registerCounter_result')
15880 
    if self.success is not None:
15881 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15882 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15883 
      for kiter232,viter233 in self.success.items():
15884 
        oprot.writeString(kiter232)
15885 
        oprot.writeString(viter233)
15886 
      oprot.writeMapEnd()
15887 
      oprot.writeFieldEnd()
15888 
    oprot.writeFieldStop()
15889 
    oprot.writeStructEnd()
15890 
 
15891 
  def validate(self):
15892 
    return
15893 
 
15894 
 
15895 
  def __repr__(self):
15896 
    L = ['%s=%r' % (key, value)
15897 
      for key, value in self.__dict__.iteritems()]
15898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15899 
 
15900 
  def __eq__(self, other):
15901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15902 
 
15903 
  def __ne__(self, other):
15904 
    return not (self == other)
12722 amit.gupta 15905 
 
15906 
class searchCounter_args:
15907 
  """
15908 
  Attributes:
15909 
   - type1
15910 
   - searchString
15911 
  """
15912 
 
15913 
  thrift_spec = (
15914 
    None, # 0
15915 
    (1, TType.STRING, 'type1', None, None, ), # 1
15916 
    (2, TType.STRING, 'searchString', None, None, ), # 2
15917 
  )
15918 
 
15919 
  def __init__(self, type1=None, searchString=None,):
15920 
    self.type1 = type1
15921 
    self.searchString = searchString
15922 
 
15923 
  def read(self, iprot):
15924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15926 
      return
15927 
    iprot.readStructBegin()
15928 
    while True:
15929 
      (fname, ftype, fid) = iprot.readFieldBegin()
15930 
      if ftype == TType.STOP:
15931 
        break
15932 
      if fid == 1:
15933 
        if ftype == TType.STRING:
15934 
          self.type1 = iprot.readString();
15935 
        else:
15936 
          iprot.skip(ftype)
15937 
      elif fid == 2:
15938 
        if ftype == TType.STRING:
15939 
          self.searchString = iprot.readString();
15940 
        else:
15941 
          iprot.skip(ftype)
15942 
      else:
15943 
        iprot.skip(ftype)
15944 
      iprot.readFieldEnd()
15945 
    iprot.readStructEnd()
15946 
 
15947 
  def write(self, oprot):
15948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15950 
      return
15951 
    oprot.writeStructBegin('searchCounter_args')
15952 
    if self.type1 is not None:
15953 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
15954 
      oprot.writeString(self.type1)
15955 
      oprot.writeFieldEnd()
15956 
    if self.searchString is not None:
15957 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
15958 
      oprot.writeString(self.searchString)
15959 
      oprot.writeFieldEnd()
15960 
    oprot.writeFieldStop()
15961 
    oprot.writeStructEnd()
15962 
 
15963 
  def validate(self):
15964 
    return
15965 
 
15966 
 
15967 
  def __repr__(self):
15968 
    L = ['%s=%r' % (key, value)
15969 
      for key, value in self.__dict__.iteritems()]
15970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15971 
 
15972 
  def __eq__(self, other):
15973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15974 
 
15975 
  def __ne__(self, other):
15976 
    return not (self == other)
15977 
 
15978 
class searchCounter_result:
15979 
  """
15980 
  Attributes:
15981 
   - success
15982 
  """
15983 
 
15984 
  thrift_spec = (
15985 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
15986 
  )
15987 
 
15988 
  def __init__(self, success=None,):
15989 
    self.success = success
15990 
 
15991 
  def read(self, iprot):
15992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15994 
      return
15995 
    iprot.readStructBegin()
15996 
    while True:
15997 
      (fname, ftype, fid) = iprot.readFieldBegin()
15998 
      if ftype == TType.STOP:
15999 
        break
16000 
      if fid == 0:
16001 
        if ftype == TType.LIST:
16002 
          self.success = []
16003 
          (_etype237, _size234) = iprot.readListBegin()
16004 
          for _i238 in xrange(_size234):
16005 
            _elem239 = Counter()
16006 
            _elem239.read(iprot)
16007 
            self.success.append(_elem239)
16008 
          iprot.readListEnd()
16009 
        else:
16010 
          iprot.skip(ftype)
16011 
      else:
16012 
        iprot.skip(ftype)
16013 
      iprot.readFieldEnd()
16014 
    iprot.readStructEnd()
16015 
 
16016 
  def write(self, oprot):
16017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16019 
      return
16020 
    oprot.writeStructBegin('searchCounter_result')
16021 
    if self.success is not None:
16022 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16023 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16024 
      for iter240 in self.success:
16025 
        iter240.write(oprot)
16026 
      oprot.writeListEnd()
16027 
      oprot.writeFieldEnd()
16028 
    oprot.writeFieldStop()
16029 
    oprot.writeStructEnd()
16030 
 
16031 
  def validate(self):
16032 
    return
16033 
 
16034 
 
16035 
  def __repr__(self):
16036 
    L = ['%s=%r' % (key, value)
16037 
      for key, value in self.__dict__.iteritems()]
16038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16039 
 
16040 
  def __eq__(self, other):
16041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16042 
 
16043 
  def __ne__(self, other):
16044 
    return not (self == other)
16045 
 
16046 
class getAllUsersByCounter_args:
16047 
  """
16048 
  Attributes:
16049 
   - counterId
16050 
  """
16051 
 
16052 
  thrift_spec = (
16053 
    None, # 0
16054 
    (1, TType.I64, 'counterId', None, None, ), # 1
16055 
  )
16056 
 
16057 
  def __init__(self, counterId=None,):
16058 
    self.counterId = counterId
16059 
 
16060 
  def read(self, iprot):
16061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16063 
      return
16064 
    iprot.readStructBegin()
16065 
    while True:
16066 
      (fname, ftype, fid) = iprot.readFieldBegin()
16067 
      if ftype == TType.STOP:
16068 
        break
16069 
      if fid == 1:
16070 
        if ftype == TType.I64:
16071 
          self.counterId = iprot.readI64();
16072 
        else:
16073 
          iprot.skip(ftype)
16074 
      else:
16075 
        iprot.skip(ftype)
16076 
      iprot.readFieldEnd()
16077 
    iprot.readStructEnd()
16078 
 
16079 
  def write(self, oprot):
16080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16082 
      return
16083 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16084 
    if self.counterId is not None:
16085 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16086 
      oprot.writeI64(self.counterId)
16087 
      oprot.writeFieldEnd()
16088 
    oprot.writeFieldStop()
16089 
    oprot.writeStructEnd()
16090 
 
16091 
  def validate(self):
16092 
    return
16093 
 
16094 
 
16095 
  def __repr__(self):
16096 
    L = ['%s=%r' % (key, value)
16097 
      for key, value in self.__dict__.iteritems()]
16098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16099 
 
16100 
  def __eq__(self, other):
16101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16102 
 
16103 
  def __ne__(self, other):
16104 
    return not (self == other)
16105 
 
16106 
class getAllUsersByCounter_result:
16107 
  """
16108 
  Attributes:
16109 
   - success
16110 
  """
16111 
 
16112 
  thrift_spec = (
16113 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16114 
  )
16115 
 
16116 
  def __init__(self, success=None,):
16117 
    self.success = success
16118 
 
16119 
  def read(self, iprot):
16120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16122 
      return
16123 
    iprot.readStructBegin()
16124 
    while True:
16125 
      (fname, ftype, fid) = iprot.readFieldBegin()
16126 
      if ftype == TType.STOP:
16127 
        break
16128 
      if fid == 0:
16129 
        if ftype == TType.LIST:
16130 
          self.success = []
16131 
          (_etype244, _size241) = iprot.readListBegin()
16132 
          for _i245 in xrange(_size241):
16133 
            _elem246 = User()
16134 
            _elem246.read(iprot)
16135 
            self.success.append(_elem246)
16136 
          iprot.readListEnd()
16137 
        else:
16138 
          iprot.skip(ftype)
16139 
      else:
16140 
        iprot.skip(ftype)
16141 
      iprot.readFieldEnd()
16142 
    iprot.readStructEnd()
16143 
 
16144 
  def write(self, oprot):
16145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16147 
      return
16148 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16149 
    if self.success is not None:
16150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16152 
      for iter247 in self.success:
16153 
        iter247.write(oprot)
16154 
      oprot.writeListEnd()
16155 
      oprot.writeFieldEnd()
16156 
    oprot.writeFieldStop()
16157 
    oprot.writeStructEnd()
16158 
 
16159 
  def validate(self):
16160 
    return
16161 
 
16162 
 
16163 
  def __repr__(self):
16164 
    L = ['%s=%r' % (key, value)
16165 
      for key, value in self.__dict__.iteritems()]
16166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16167 
 
16168 
  def __eq__(self, other):
16169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16170 
 
16171 
  def __ne__(self, other):
16172 
    return not (self == other)
15251 manish.sha 16173 
 
16174 
class getActiveAccessTokenForUser_args:
16175 
  """
16176 
  Attributes:
16177 
   - userId
16178 
   - source
16179 
  """
16180 
 
16181 
  thrift_spec = (
16182 
    None, # 0
16183 
    (1, TType.I64, 'userId', None, None, ), # 1
16184 
    (2, TType.STRING, 'source', None, None, ), # 2
16185 
  )
16186 
 
16187 
  def __init__(self, userId=None, source=None,):
16188 
    self.userId = userId
16189 
    self.source = source
16190 
 
16191 
  def read(self, iprot):
16192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16194 
      return
16195 
    iprot.readStructBegin()
16196 
    while True:
16197 
      (fname, ftype, fid) = iprot.readFieldBegin()
16198 
      if ftype == TType.STOP:
16199 
        break
16200 
      if fid == 1:
16201 
        if ftype == TType.I64:
16202 
          self.userId = iprot.readI64();
16203 
        else:
16204 
          iprot.skip(ftype)
16205 
      elif fid == 2:
16206 
        if ftype == TType.STRING:
16207 
          self.source = iprot.readString();
16208 
        else:
16209 
          iprot.skip(ftype)
16210 
      else:
16211 
        iprot.skip(ftype)
16212 
      iprot.readFieldEnd()
16213 
    iprot.readStructEnd()
16214 
 
16215 
  def write(self, oprot):
16216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16218 
      return
16219 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16220 
    if self.userId is not None:
16221 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16222 
      oprot.writeI64(self.userId)
16223 
      oprot.writeFieldEnd()
16224 
    if self.source is not None:
16225 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16226 
      oprot.writeString(self.source)
16227 
      oprot.writeFieldEnd()
16228 
    oprot.writeFieldStop()
16229 
    oprot.writeStructEnd()
16230 
 
16231 
  def validate(self):
16232 
    return
16233 
 
16234 
 
16235 
  def __repr__(self):
16236 
    L = ['%s=%r' % (key, value)
16237 
      for key, value in self.__dict__.iteritems()]
16238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16239 
 
16240 
  def __eq__(self, other):
16241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16242 
 
16243 
  def __ne__(self, other):
16244 
    return not (self == other)
16245 
 
16246 
class getActiveAccessTokenForUser_result:
16247 
  """
16248 
  Attributes:
16249 
   - success
16250 
  """
16251 
 
16252 
  thrift_spec = (
16253 
    (0, TType.STRING, 'success', None, None, ), # 0
16254 
  )
16255 
 
16256 
  def __init__(self, success=None,):
16257 
    self.success = success
16258 
 
16259 
  def read(self, iprot):
16260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16262 
      return
16263 
    iprot.readStructBegin()
16264 
    while True:
16265 
      (fname, ftype, fid) = iprot.readFieldBegin()
16266 
      if ftype == TType.STOP:
16267 
        break
16268 
      if fid == 0:
16269 
        if ftype == TType.STRING:
16270 
          self.success = iprot.readString();
16271 
        else:
16272 
          iprot.skip(ftype)
16273 
      else:
16274 
        iprot.skip(ftype)
16275 
      iprot.readFieldEnd()
16276 
    iprot.readStructEnd()
16277 
 
16278 
  def write(self, oprot):
16279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16281 
      return
16282 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16283 
    if self.success is not None:
16284 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16285 
      oprot.writeString(self.success)
16286 
      oprot.writeFieldEnd()
16287 
    oprot.writeFieldStop()
16288 
    oprot.writeStructEnd()
16289 
 
16290 
  def validate(self):
16291 
    return
16292 
 
16293 
 
16294 
  def __repr__(self):
16295 
    L = ['%s=%r' % (key, value)
16296 
      for key, value in self.__dict__.iteritems()]
16297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16298 
 
16299 
  def __eq__(self, other):
16300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16301 
 
16302 
  def __ne__(self, other):
16303 
    return not (self == other)
16304 
 
16305 
class validateAccessToken_args:
16306 
  """
16307 
  Attributes:
16308 
   - accessToken
16309 
  """
16310 
 
16311 
  thrift_spec = (
16312 
    None, # 0
16313 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16314 
  )
16315 
 
16316 
  def __init__(self, accessToken=None,):
16317 
    self.accessToken = accessToken
16318 
 
16319 
  def read(self, iprot):
16320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16322 
      return
16323 
    iprot.readStructBegin()
16324 
    while True:
16325 
      (fname, ftype, fid) = iprot.readFieldBegin()
16326 
      if ftype == TType.STOP:
16327 
        break
16328 
      if fid == 1:
16329 
        if ftype == TType.STRING:
16330 
          self.accessToken = iprot.readString();
16331 
        else:
16332 
          iprot.skip(ftype)
16333 
      else:
16334 
        iprot.skip(ftype)
16335 
      iprot.readFieldEnd()
16336 
    iprot.readStructEnd()
16337 
 
16338 
  def write(self, oprot):
16339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16341 
      return
16342 
    oprot.writeStructBegin('validateAccessToken_args')
16343 
    if self.accessToken is not None:
16344 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16345 
      oprot.writeString(self.accessToken)
16346 
      oprot.writeFieldEnd()
16347 
    oprot.writeFieldStop()
16348 
    oprot.writeStructEnd()
16349 
 
16350 
  def validate(self):
16351 
    return
16352 
 
16353 
 
16354 
  def __repr__(self):
16355 
    L = ['%s=%r' % (key, value)
16356 
      for key, value in self.__dict__.iteritems()]
16357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16358 
 
16359 
  def __eq__(self, other):
16360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16361 
 
16362 
  def __ne__(self, other):
16363 
    return not (self == other)
16364 
 
16365 
class validateAccessToken_result:
16366 
  """
16367 
  Attributes:
16368 
   - success
16369 
  """
16370 
 
16371 
  thrift_spec = (
16372 
    (0, TType.BOOL, 'success', None, None, ), # 0
16373 
  )
16374 
 
16375 
  def __init__(self, success=None,):
16376 
    self.success = success
16377 
 
16378 
  def read(self, iprot):
16379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16381 
      return
16382 
    iprot.readStructBegin()
16383 
    while True:
16384 
      (fname, ftype, fid) = iprot.readFieldBegin()
16385 
      if ftype == TType.STOP:
16386 
        break
16387 
      if fid == 0:
16388 
        if ftype == TType.BOOL:
16389 
          self.success = iprot.readBool();
16390 
        else:
16391 
          iprot.skip(ftype)
16392 
      else:
16393 
        iprot.skip(ftype)
16394 
      iprot.readFieldEnd()
16395 
    iprot.readStructEnd()
16396 
 
16397 
  def write(self, oprot):
16398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16400 
      return
16401 
    oprot.writeStructBegin('validateAccessToken_result')
16402 
    if self.success is not None:
16403 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16404 
      oprot.writeBool(self.success)
16405 
      oprot.writeFieldEnd()
16406 
    oprot.writeFieldStop()
16407 
    oprot.writeStructEnd()
16408 
 
16409 
  def validate(self):
16410 
    return
16411 
 
16412 
 
16413 
  def __repr__(self):
16414 
    L = ['%s=%r' % (key, value)
16415 
      for key, value in self.__dict__.iteritems()]
16416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16417 
 
16418 
  def __eq__(self, other):
16419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16420 
 
16421 
  def __ne__(self, other):
16422 
    return not (self == other)
17782 amit.gupta 16423 
 
16424 
class addItemsToCart_args:
16425 
  """
16426 
  Attributes:
16427 
   - cartId
16428 
   - itemQty
16429 
   - couponCode
16430 
  """
16431 
 
16432 
  thrift_spec = (
16433 
    None, # 0
16434 
    (1, TType.I64, 'cartId', None, None, ), # 1
16435 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16436 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16437 
  )
16438 
 
16439 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16440 
    self.cartId = cartId
16441 
    self.itemQty = itemQty
16442 
    self.couponCode = couponCode
16443 
 
16444 
  def read(self, iprot):
16445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16447 
      return
16448 
    iprot.readStructBegin()
16449 
    while True:
16450 
      (fname, ftype, fid) = iprot.readFieldBegin()
16451 
      if ftype == TType.STOP:
16452 
        break
16453 
      if fid == 1:
16454 
        if ftype == TType.I64:
16455 
          self.cartId = iprot.readI64();
16456 
        else:
16457 
          iprot.skip(ftype)
16458 
      elif fid == 2:
16459 
        if ftype == TType.LIST:
16460 
          self.itemQty = []
16461 
          (_etype251, _size248) = iprot.readListBegin()
16462 
          for _i252 in xrange(_size248):
16463 
            _elem253 = ItemQuantity()
16464 
            _elem253.read(iprot)
16465 
            self.itemQty.append(_elem253)
16466 
          iprot.readListEnd()
16467 
        else:
16468 
          iprot.skip(ftype)
16469 
      elif fid == 3:
16470 
        if ftype == TType.STRING:
16471 
          self.couponCode = iprot.readString();
16472 
        else:
16473 
          iprot.skip(ftype)
16474 
      else:
16475 
        iprot.skip(ftype)
16476 
      iprot.readFieldEnd()
16477 
    iprot.readStructEnd()
16478 
 
16479 
  def write(self, oprot):
16480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16482 
      return
16483 
    oprot.writeStructBegin('addItemsToCart_args')
16484 
    if self.cartId is not None:
16485 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16486 
      oprot.writeI64(self.cartId)
16487 
      oprot.writeFieldEnd()
16488 
    if self.itemQty is not None:
16489 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16490 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16491 
      for iter254 in self.itemQty:
16492 
        iter254.write(oprot)
16493 
      oprot.writeListEnd()
16494 
      oprot.writeFieldEnd()
16495 
    if self.couponCode is not None:
16496 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16497 
      oprot.writeString(self.couponCode)
16498 
      oprot.writeFieldEnd()
16499 
    oprot.writeFieldStop()
16500 
    oprot.writeStructEnd()
16501 
 
16502 
  def validate(self):
16503 
    return
16504 
 
16505 
 
16506 
  def __repr__(self):
16507 
    L = ['%s=%r' % (key, value)
16508 
      for key, value in self.__dict__.iteritems()]
16509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16510 
 
16511 
  def __eq__(self, other):
16512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16513 
 
16514 
  def __ne__(self, other):
16515 
    return not (self == other)
16516 
 
16517 
class addItemsToCart_result:
16518 
  """
16519 
  Attributes:
16520 
   - success
16521 
  """
16522 
 
16523 
  thrift_spec = (
16524 
    (0, TType.BOOL, 'success', None, None, ), # 0
16525 
  )
16526 
 
16527 
  def __init__(self, success=None,):
16528 
    self.success = success
16529 
 
16530 
  def read(self, iprot):
16531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16533 
      return
16534 
    iprot.readStructBegin()
16535 
    while True:
16536 
      (fname, ftype, fid) = iprot.readFieldBegin()
16537 
      if ftype == TType.STOP:
16538 
        break
16539 
      if fid == 0:
16540 
        if ftype == TType.BOOL:
16541 
          self.success = iprot.readBool();
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      else:
16545 
        iprot.skip(ftype)
16546 
      iprot.readFieldEnd()
16547 
    iprot.readStructEnd()
16548 
 
16549 
  def write(self, oprot):
16550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16552 
      return
16553 
    oprot.writeStructBegin('addItemsToCart_result')
16554 
    if self.success is not None:
16555 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16556 
      oprot.writeBool(self.success)
16557 
      oprot.writeFieldEnd()
16558 
    oprot.writeFieldStop()
16559 
    oprot.writeStructEnd()
16560 
 
16561 
  def validate(self):
16562 
    return
16563 
 
16564 
 
16565 
  def __repr__(self):
16566 
    L = ['%s=%r' % (key, value)
16567 
      for key, value in self.__dict__.iteritems()]
16568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16569 
 
16570 
  def __eq__(self, other):
16571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16572 
 
16573 
  def __ne__(self, other):
16574 
    return not (self == other)
16575 
 
16576 
class validateCartNew_args:
16577 
  """
16578 
  Attributes:
16579 
   - cartId
16580 
   - pinCode
16581 
   - sourceId
16582 
  """
16583 
 
16584 
  thrift_spec = (
16585 
    None, # 0
16586 
    (1, TType.I64, 'cartId', None, None, ), # 1
16587 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16588 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16589 
  )
16590 
 
16591 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16592 
    self.cartId = cartId
16593 
    self.pinCode = pinCode
16594 
    self.sourceId = sourceId
16595 
 
16596 
  def read(self, iprot):
16597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16599 
      return
16600 
    iprot.readStructBegin()
16601 
    while True:
16602 
      (fname, ftype, fid) = iprot.readFieldBegin()
16603 
      if ftype == TType.STOP:
16604 
        break
16605 
      if fid == 1:
16606 
        if ftype == TType.I64:
16607 
          self.cartId = iprot.readI64();
16608 
        else:
16609 
          iprot.skip(ftype)
16610 
      elif fid == 2:
16611 
        if ftype == TType.STRING:
16612 
          self.pinCode = iprot.readString();
16613 
        else:
16614 
          iprot.skip(ftype)
16615 
      elif fid == 3:
16616 
        if ftype == TType.I64:
16617 
          self.sourceId = iprot.readI64();
16618 
        else:
16619 
          iprot.skip(ftype)
16620 
      else:
16621 
        iprot.skip(ftype)
16622 
      iprot.readFieldEnd()
16623 
    iprot.readStructEnd()
16624 
 
16625 
  def write(self, oprot):
16626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16628 
      return
16629 
    oprot.writeStructBegin('validateCartNew_args')
16630 
    if self.cartId is not None:
16631 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16632 
      oprot.writeI64(self.cartId)
16633 
      oprot.writeFieldEnd()
16634 
    if self.pinCode is not None:
16635 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
16636 
      oprot.writeString(self.pinCode)
16637 
      oprot.writeFieldEnd()
16638 
    if self.sourceId is not None:
16639 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
16640 
      oprot.writeI64(self.sourceId)
16641 
      oprot.writeFieldEnd()
16642 
    oprot.writeFieldStop()
16643 
    oprot.writeStructEnd()
16644 
 
16645 
  def validate(self):
16646 
    return
16647 
 
16648 
 
16649 
  def __repr__(self):
16650 
    L = ['%s=%r' % (key, value)
16651 
      for key, value in self.__dict__.iteritems()]
16652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16653 
 
16654 
  def __eq__(self, other):
16655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16656 
 
16657 
  def __ne__(self, other):
16658 
    return not (self == other)
16659 
 
16660 
class validateCartNew_result:
16661 
  """
16662 
  Attributes:
16663 
   - success
16664 
  """
16665 
 
16666 
  thrift_spec = (
16667 
    (0, TType.STRING, 'success', None, None, ), # 0
16668 
  )
16669 
 
16670 
  def __init__(self, success=None,):
16671 
    self.success = success
16672 
 
16673 
  def read(self, iprot):
16674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16676 
      return
16677 
    iprot.readStructBegin()
16678 
    while True:
16679 
      (fname, ftype, fid) = iprot.readFieldBegin()
16680 
      if ftype == TType.STOP:
16681 
        break
16682 
      if fid == 0:
16683 
        if ftype == TType.STRING:
16684 
          self.success = iprot.readString();
16685 
        else:
16686 
          iprot.skip(ftype)
16687 
      else:
16688 
        iprot.skip(ftype)
16689 
      iprot.readFieldEnd()
16690 
    iprot.readStructEnd()
16691 
 
16692 
  def write(self, oprot):
16693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16695 
      return
16696 
    oprot.writeStructBegin('validateCartNew_result')
16697 
    if self.success is not None:
16698 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16699 
      oprot.writeString(self.success)
16700 
      oprot.writeFieldEnd()
16701 
    oprot.writeFieldStop()
16702 
    oprot.writeStructEnd()
16703 
 
16704 
  def validate(self):
16705 
    return
16706 
 
16707 
 
16708 
  def __repr__(self):
16709 
    L = ['%s=%r' % (key, value)
16710 
      for key, value in self.__dict__.iteritems()]
16711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16712 
 
16713 
  def __eq__(self, other):
16714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16715 
 
16716 
  def __ne__(self, other):
16717 
    return not (self == other)
18530 manish.sha 16718 
 
16719 
class isTaxInvoiceCounter_args:
16720 
  """
16721 
  Attributes:
16722 
   - userId
16723 
  """
16724 
 
16725 
  thrift_spec = (
16726 
    None, # 0
16727 
    (1, TType.I64, 'userId', None, None, ), # 1
16728 
  )
16729 
 
16730 
  def __init__(self, userId=None,):
16731 
    self.userId = userId
16732 
 
16733 
  def read(self, iprot):
16734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16736 
      return
16737 
    iprot.readStructBegin()
16738 
    while True:
16739 
      (fname, ftype, fid) = iprot.readFieldBegin()
16740 
      if ftype == TType.STOP:
16741 
        break
16742 
      if fid == 1:
16743 
        if ftype == TType.I64:
16744 
          self.userId = iprot.readI64();
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      else:
16748 
        iprot.skip(ftype)
16749 
      iprot.readFieldEnd()
16750 
    iprot.readStructEnd()
16751 
 
16752 
  def write(self, oprot):
16753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16755 
      return
16756 
    oprot.writeStructBegin('isTaxInvoiceCounter_args')
16757 
    if self.userId is not None:
16758 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16759 
      oprot.writeI64(self.userId)
16760 
      oprot.writeFieldEnd()
16761 
    oprot.writeFieldStop()
16762 
    oprot.writeStructEnd()
16763 
 
16764 
  def validate(self):
16765 
    return
16766 
 
16767 
 
16768 
  def __repr__(self):
16769 
    L = ['%s=%r' % (key, value)
16770 
      for key, value in self.__dict__.iteritems()]
16771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16772 
 
16773 
  def __eq__(self, other):
16774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16775 
 
16776 
  def __ne__(self, other):
16777 
    return not (self == other)
16778 
 
16779 
class isTaxInvoiceCounter_result:
16780 
  """
16781 
  Attributes:
16782 
   - success
16783 
  """
16784 
 
16785 
  thrift_spec = (
16786 
    (0, TType.BOOL, 'success', None, None, ), # 0
16787 
  )
16788 
 
16789 
  def __init__(self, success=None,):
16790 
    self.success = success
16791 
 
16792 
  def read(self, iprot):
16793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16795 
      return
16796 
    iprot.readStructBegin()
16797 
    while True:
16798 
      (fname, ftype, fid) = iprot.readFieldBegin()
16799 
      if ftype == TType.STOP:
16800 
        break
16801 
      if fid == 0:
16802 
        if ftype == TType.BOOL:
16803 
          self.success = iprot.readBool();
16804 
        else:
16805 
          iprot.skip(ftype)
16806 
      else:
16807 
        iprot.skip(ftype)
16808 
      iprot.readFieldEnd()
16809 
    iprot.readStructEnd()
16810 
 
16811 
  def write(self, oprot):
16812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16814 
      return
16815 
    oprot.writeStructBegin('isTaxInvoiceCounter_result')
16816 
    if self.success is not None:
16817 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16818 
      oprot.writeBool(self.success)
16819 
      oprot.writeFieldEnd()
16820 
    oprot.writeFieldStop()
16821 
    oprot.writeStructEnd()
16822 
 
16823 
  def validate(self):
16824 
    return
16825 
 
16826 
 
16827 
  def __repr__(self):
16828 
    L = ['%s=%r' % (key, value)
16829 
      for key, value in self.__dict__.iteritems()]
16830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16831 
 
16832 
  def __eq__(self, other):
16833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16834 
 
16835 
  def __ne__(self, other):
16836 
    return not (self == other)
16837 
 
16838 
class getBillingAddressForUser_args:
16839 
  """
16840 
  Attributes:
16841 
   - userId
16842 
  """
16843 
 
16844 
  thrift_spec = (
16845 
    None, # 0
16846 
    (1, TType.I64, 'userId', None, None, ), # 1
16847 
  )
16848 
 
16849 
  def __init__(self, userId=None,):
16850 
    self.userId = userId
16851 
 
16852 
  def read(self, iprot):
16853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16855 
      return
16856 
    iprot.readStructBegin()
16857 
    while True:
16858 
      (fname, ftype, fid) = iprot.readFieldBegin()
16859 
      if ftype == TType.STOP:
16860 
        break
16861 
      if fid == 1:
16862 
        if ftype == TType.I64:
16863 
          self.userId = iprot.readI64();
16864 
        else:
16865 
          iprot.skip(ftype)
16866 
      else:
16867 
        iprot.skip(ftype)
16868 
      iprot.readFieldEnd()
16869 
    iprot.readStructEnd()
16870 
 
16871 
  def write(self, oprot):
16872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16874 
      return
16875 
    oprot.writeStructBegin('getBillingAddressForUser_args')
16876 
    if self.userId is not None:
16877 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16878 
      oprot.writeI64(self.userId)
16879 
      oprot.writeFieldEnd()
16880 
    oprot.writeFieldStop()
16881 
    oprot.writeStructEnd()
16882 
 
16883 
  def validate(self):
16884 
    return
16885 
 
16886 
 
16887 
  def __repr__(self):
16888 
    L = ['%s=%r' % (key, value)
16889 
      for key, value in self.__dict__.iteritems()]
16890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16891 
 
16892 
  def __eq__(self, other):
16893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16894 
 
16895 
  def __ne__(self, other):
16896 
    return not (self == other)
16897 
 
16898 
class getBillingAddressForUser_result:
16899 
  """
16900 
  Attributes:
16901 
   - success
16902 
  """
16903 
 
16904 
  thrift_spec = (
16905 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
16906 
  )
16907 
 
16908 
  def __init__(self, success=None,):
16909 
    self.success = success
16910 
 
16911 
  def read(self, iprot):
16912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16914 
      return
16915 
    iprot.readStructBegin()
16916 
    while True:
16917 
      (fname, ftype, fid) = iprot.readFieldBegin()
16918 
      if ftype == TType.STOP:
16919 
        break
16920 
      if fid == 0:
16921 
        if ftype == TType.STRUCT:
16922 
          self.success = Address()
16923 
          self.success.read(iprot)
16924 
        else:
16925 
          iprot.skip(ftype)
16926 
      else:
16927 
        iprot.skip(ftype)
16928 
      iprot.readFieldEnd()
16929 
    iprot.readStructEnd()
16930 
 
16931 
  def write(self, oprot):
16932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16934 
      return
16935 
    oprot.writeStructBegin('getBillingAddressForUser_result')
16936 
    if self.success is not None:
16937 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16938 
      self.success.write(oprot)
16939 
      oprot.writeFieldEnd()
16940 
    oprot.writeFieldStop()
16941 
    oprot.writeStructEnd()
16942 
 
16943 
  def validate(self):
16944 
    return
16945 
 
16946 
 
16947 
  def __repr__(self):
16948 
    L = ['%s=%r' % (key, value)
16949 
      for key, value in self.__dict__.iteritems()]
16950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16951 
 
16952 
  def __eq__(self, other):
16953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16954 
 
16955 
  def __ne__(self, other):
16956 
    return not (self == other)