Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
22358 ashik.ali 104 
  def updateAddress(self, address):
105 
    """
106 
    Parameters:
107 
     - address
108 
    """
109 
    pass
110 
 
94 ashish 111 
  def setUserAsLoggedIn(self, userId, timestamp):
112 
    """
113 
    Parameters:
114 
     - userId
115 
     - timestamp
116 
    """
117 
    pass
118 
 
119 
  def setUserAsLoggedOut(self, userid, timestamp):
120 
    """
121 
    Parameters:
122 
     - userid
123 
     - timestamp
124 
    """
125 
    pass
126 
 
504 rajveer 127 
  def setDefaultAddress(self, userid, addressId):
128 
    """
129 
    Parameters:
130 
     - userid
131 
     - addressId
132 
    """
133 
    pass
134 
 
594 rajveer 135 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 136 
    """
137 
    Parameters:
138 
     - userid
594 rajveer 139 
     - oldPassword
140 
     - newPassword
94 ashish 141 
    """
142 
    pass
143 
 
884 rajveer 144 
  def forgotPassword(self, email, newPassword):
581 rajveer 145 
    """
146 
    Parameters:
147 
     - email
884 rajveer 148 
     - newPassword
581 rajveer 149 
    """
150 
    pass
151 
 
594 rajveer 152 
  def getAllAddressesForUser(self, userId):
153 
    """
154 
    Parameters:
155 
     - userId
156 
    """
157 
    pass
158 
 
1894 vikas 159 
  def getAddressById(self, addressId):
160 
    """
161 
    Parameters:
162 
     - addressId
163 
    """
164 
    pass
165 
 
594 rajveer 166 
  def getDefaultAddressId(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
785 rajveer 173 
  def getDefaultPincode(self, userId):
174 
    """
175 
    Parameters:
176 
     - userId
177 
    """
178 
    pass
179 
 
1274 varun.gupt 180 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
181 
    """
182 
    Parameters:
183 
     - userId
184 
     - replyTo
185 
     - communicationType
186 
     - orderId
187 
     - airwaybillNo
188 
     - productName
189 
     - subject
190 
     - message
191 
    """
192 
    pass
193 
 
1590 varun.gupt 194 
  def getUserCommunicationById(self, id):
195 
    """
196 
    Parameters:
197 
     - id
198 
    """
199 
    pass
200 
 
201 
  def getUserCommunicationByUser(self, userId):
202 
    """
203 
    Parameters:
204 
     - userId
205 
    """
206 
    pass
207 
 
208 
  def getAllUserCommunications(self, ):
209 
    pass
210 
 
5407 amar.kumar 211 
  def removeUserCommunication(self, id):
212 
    """
213 
    Parameters:
214 
     - id
215 
    """
216 
    pass
217 
 
1859 vikas 218 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 219 
    """
220 
    Parameters:
221 
     - name
1859 vikas 222 
     - addedOn
1845 vikas 223 
    """
224 
    pass
225 
 
1899 vikas 226 
  def getAllMasterAffiliates(self, ):
227 
    pass
228 
 
1845 vikas 229 
  def getMasterAffiliateById(self, id):
230 
    """
231 
    Parameters:
232 
     - id
233 
    """
234 
    pass
235 
 
236 
  def getMasterAffiliateByName(self, name):
237 
    """
238 
    Parameters:
239 
     - name
240 
    """
241 
    pass
242 
 
1859 vikas 243 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 244 
    """
245 
    Parameters:
246 
     - name
247 
     - url
248 
     - masterAffiliateId
1859 vikas 249 
     - addedOn
1845 vikas 250 
    """
251 
    pass
252 
 
253 
  def getAffiliateById(self, id):
254 
    """
255 
    Parameters:
256 
     - id
257 
    """
258 
    pass
259 
 
260 
  def getAffiliateByName(self, name):
261 
    """
262 
    Parameters:
263 
     - name
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getTrackerById(self, id):
1845 vikas 268 
    """
269 
    Parameters:
270 
     - id
271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 275 
    """
276 
    Parameters:
1996 vikas 277 
     - id
1845 vikas 278 
    """
279 
    pass
280 
 
1996 vikas 281 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 282 
    """
283 
    Parameters:
284 
     - affiliateId
285 
     - userId
286 
     - event
287 
     - url
288 
     - data
1859 vikas 289 
     - addedOn
1845 vikas 290 
    """
291 
    pass
292 
 
293 
  def getTrackLogById(self, id):
294 
    """
295 
    Parameters:
296 
     - id
297 
    """
298 
    pass
299 
 
3293 vikas 300 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 301 
    """
302 
    Parameters:
1996 vikas 303 
     - affiliateId
3293 vikas 304 
     - startDate
305 
     - endDate
1845 vikas 306 
    """
307 
    pass
308 
 
309 
  def getTrackLogsByUser(self, userId):
310 
    """
311 
    Parameters:
312 
     - userId
313 
    """
314 
    pass
315 
 
1996 vikas 316 
  def getTrackLogs(self, userId, event, url):
1845 vikas 317 
    """
318 
    Parameters:
319 
     - userId
320 
     - event
321 
     - url
322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCurrentCart(self, userId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - userId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCart(self, cartId):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - cartId
94 ashish 336 
    """
337 
    pass
338 
 
559 chandransh 339 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 340 
    """
341 
    Parameters:
559 chandransh 342 
     - from_time
343 
     - to_time
344 
     - status
94 ashish 345 
    """
346 
    pass
347 
 
3557 rajveer 348 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 349 
    """
350 
    Parameters:
559 chandransh 351 
     - cartId
352 
     - itemId
353 
     - quantity
3557 rajveer 354 
     - sourceId
130 ashish 355 
    """
356 
    pass
357 
 
559 chandransh 358 
  def deleteItemFromCart(self, cartId, itemId):
359 
    """
360 
    Parameters:
361 
     - cartId
362 
     - itemId
363 
    """
364 
    pass
130 ashish 365 
 
559 chandransh 366 
  def addAddressToCart(self, cartId, addressId):
367 
    """
368 
    Parameters:
369 
     - cartId
370 
     - addressId
371 
    """
372 
    pass
373 
 
5553 rajveer 374 
  def addStoreToCart(self, cartId, storeId):
375 
    """
376 
    Parameters:
377 
     - cartId
378 
     - storeId
379 
    """
380 
    pass
381 
 
6922 anupam.sin 382 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 383 
    """
384 
    Parameters:
6922 anupam.sin 385 
     - cart
1976 varun.gupt 386 
     - couponCode
387 
    """
388 
    pass
389 
 
390 
  def removeCoupon(self, cartId):
391 
    """
392 
    Parameters:
393 
     - cartId
394 
    """
395 
    pass
396 
 
3554 varun.gupt 397 
  def deleteDiscountsFromCart(self, cartId):
398 
    """
399 
    Deletes all the discounts associated with the cart
400 
 
401 
    Parameters:
402 
     - cartId
403 
    """
404 
    pass
405 
 
406 
  def saveDiscounts(self, discounts):
407 
    """
408 
    Accepts a list of thrift objects of Discount type and saves them
409 
 
410 
    Parameters:
411 
     - discounts
412 
    """
413 
    pass
414 
 
21454 amit.gupta 415 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 416 
    """
690 chandransh 417 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 418 
 
559 chandransh 419 
    Parameters:
420 
     - cartId
2815 vikas 421 
     - sessionSource
422 
     - sessionStartTime
3858 vikas 423 
     - firstSource
424 
     - firstSourceTime
5326 rajveer 425 
     - userId
6389 rajveer 426 
     - schemeId
11526 amit.gupta 427 
     - orderSource
21454 amit.gupta 428 
     - selfPickup
559 chandransh 429 
    """
430 
    pass
431 
 
3557 rajveer 432 
  def validateCart(self, cartId, sourceId):
559 chandransh 433 
    """
690 chandransh 434 
    Validates that:
435 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 436 
    2. All of the lines in the cart are active items.
690 chandransh 437 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 438 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 439 
 
559 chandransh 440 
    Parameters:
441 
     - cartId
3557 rajveer 442 
     - sourceId
559 chandransh 443 
    """
444 
    pass
445 
 
11980 amit.gupta 446 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
447 
    """
448 
    Validates that:
449 
    1. The checkout timestamp is greater than the updatedOn timestamp.
450 
    2. All of the lines in the cart are active items.
451 
    3. The estimate for any of the lines in cart doesn't change.
452 
    If all three are true, returns empty string; else returns appropriate message.
453 
 
454 
    Parameters:
455 
     - cartId
456 
     - sourceId
457 
     - dealCoupon
458 
    """
459 
    pass
460 
 
690 chandransh 461 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 462 
    """
690 chandransh 463 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 464 
 
575 chandransh 465 
    Parameters:
690 chandransh 466 
     - fromCartId
467 
     - toCartId
468 
    """
469 
    pass
470 
 
471 
  def checkOut(self, cartId):
472 
    """
473 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 474 
 
690 chandransh 475 
    Parameters:
575 chandransh 476 
     - cartId
477 
    """
478 
    pass
479 
 
690 chandransh 480 
  def resetCart(self, cartId, items):
559 chandransh 481 
    """
690 chandransh 482 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
483 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 484 
 
559 chandransh 485 
    Parameters:
690 chandransh 486 
     - cartId
487 
     - items
559 chandransh 488 
    """
489 
    pass
490 
 
2981 rajveer 491 
  def getUserCount(self, userType):
559 chandransh 492 
    """
2981 rajveer 493 
    Returns number of registered users.
494 
    If userType = null, then it returns count of all users, including anonymous
495 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
496 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 497 
 
559 chandransh 498 
    Parameters:
2981 rajveer 499 
     - userType
559 chandransh 500 
    """
501 
    pass
502 
 
2981 rajveer 503 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 504 
    """
2981 rajveer 505 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
506 
    If any of startDate or endDate is -1, then that filter is ignored.
507 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 508 
 
509 
 
559 chandransh 510 
    Parameters:
2981 rajveer 511 
     - userType
512 
     - startDate
513 
     - endDate
559 chandransh 514 
    """
515 
    pass
516 
 
2981 rajveer 517 
  def getMyResearchItems(self, userId):
559 chandransh 518 
    """
2981 rajveer 519 
    Returns list of item ids in myresearch for the user
3431 rajveer 520 
 
559 chandransh 521 
    Parameters:
522 
     - userId
523 
    """
524 
    pass
525 
 
2981 rajveer 526 
  def updateMyResearch(self, userId, itemId):
559 chandransh 527 
    """
2981 rajveer 528 
    add item to my research for a user
3431 rajveer 529 
 
559 chandransh 530 
    Parameters:
2981 rajveer 531 
     - userId
532 
     - itemId
559 chandransh 533 
    """
534 
    pass
535 
 
2981 rajveer 536 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 537 
    """
2981 rajveer 538 
    delete item from my research for a user
3431 rajveer 539 
 
1596 ankur.sing 540 
    Parameters:
2981 rajveer 541 
     - userId
542 
     - itemId
1596 ankur.sing 543 
    """
544 
    pass
559 chandransh 545 
 
2981 rajveer 546 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 547 
    """
2981 rajveer 548 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 549 
 
1673 ankur.sing 550 
    Parameters:
2981 rajveer 551 
     - userId
1673 ankur.sing 552 
    """
553 
    pass
1596 ankur.sing 554 
 
2981 rajveer 555 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 556 
    """
2981 rajveer 557 
    add item to browse history for a user
3431 rajveer 558 
 
2642 varun.gupt 559 
    Parameters:
2981 rajveer 560 
     - userId
561 
     - itemId
2642 varun.gupt 562 
    """
563 
    pass
1673 ankur.sing 564 
 
3385 varun.gupt 565 
  def getCartsWithCouponCount(self, couponCode):
566 
    """
567 
    Returns count of Carts with given coupon applied
3431 rajveer 568 
 
3385 varun.gupt 569 
    Parameters:
570 
     - couponCode
571 
    """
572 
    pass
2642 varun.gupt 573 
 
3499 mandeep.dh 574 
  def increaseTrustLevel(self, userId, trustLevelDelta):
575 
    """
576 
    Updates COD trust level of a user
3385 varun.gupt 577 
 
3499 mandeep.dh 578 
    Parameters:
579 
     - userId
580 
     - trustLevelDelta
581 
    """
582 
    pass
583 
 
5407 amar.kumar 584 
  def getTrustLevel(self, userId):
585 
    """
586 
    Get trust level of a user
587 
 
588 
    Parameters:
589 
     - userId
590 
    """
591 
    pass
592 
 
4668 varun.gupt 593 
  def showCODOption(self, cartId, sourceId, pincode):
594 
    """
595 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 596 
 
4668 varun.gupt 597 
    Parameters:
598 
     - cartId
599 
     - sourceId
600 
     - pincode
601 
    """
602 
    pass
603 
 
5623 anupam.sin 604 
  def getUserEmails(self, startDate, endDate):
605 
    """
606 
    Get email addresses for users activated within a given date range
4668 varun.gupt 607 
 
5623 anupam.sin 608 
    Parameters:
609 
     - startDate
610 
     - endDate
611 
    """
612 
    pass
613 
 
9299 kshitij.so 614 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 615 
    """
616 
    Mark a cart lineitem as insured. Returns true/false.
617 
 
618 
    Parameters:
619 
     - itemId
620 
     - cartId
621 
     - toInsure
9299 kshitij.so 622 
     - insurerType
6903 anupam.sin 623 
    """
624 
    pass
625 
 
626 
  def cancelInsurance(self, cartId):
627 
    """
628 
    Cancel insurance for all items in the cart
629 
 
630 
    Parameters:
631 
     - cartId
632 
    """
633 
    pass
634 
 
635 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
636 
    """
637 
    Stores insurance specific details like date of birth and guardianName
638 
 
639 
    Parameters:
640 
     - addressId
641 
     - dob
642 
     - guardianName
643 
    """
644 
    pass
645 
 
646 
  def isInsuranceDetailPresent(self, addressId):
647 
    """
648 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
649 
 
650 
    Parameters:
651 
     - addressId
652 
    """
653 
    pass
654 
 
9791 rajveer 655 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 656 
    """
9791 rajveer 657 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 658 
 
6821 amar.kumar 659 
    Parameters:
660 
     - startDate
661 
     - endDate
662 
    """
663 
    pass
664 
 
11980 amit.gupta 665 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 666 
    """
667 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 668 
 
11592 amit.gupta 669 
    Parameters:
670 
     - cartId
671 
     - sourceId
11980 amit.gupta 672 
     - dealerCoupon
11592 amit.gupta 673 
    """
674 
    pass
675 
 
11679 vikram.rag 676 
  def isPrivateDealUser(self, userId):
677 
    """
678 
    Parameters:
679 
     - userId
680 
    """
681 
    pass
11592 amit.gupta 682 
 
11890 kshitij.so 683 
  def addPrivateDealUser(self, userId):
684 
    """
685 
    Parameters:
686 
     - userId
687 
    """
688 
    pass
11679 vikram.rag 689 
 
11890 kshitij.so 690 
  def changePrivateDealUserStatus(self, userId, isActive):
691 
    """
692 
    Parameters:
693 
     - userId
694 
     - isActive
695 
    """
696 
    pass
697 
 
698 
  def getPrivateDealUser(self, userId):
699 
    """
700 
    Parameters:
701 
     - userId
702 
    """
703 
    pass
704 
 
12696 amit.gupta 705 
  def registerCounter(self, counter, userId):
706 
    """
707 
    Parameters:
708 
     - counter
709 
     - userId
710 
    """
711 
    pass
11890 kshitij.so 712 
 
12722 amit.gupta 713 
  def searchCounter(self, type1, searchString):
714 
    """
715 
    Parameters:
716 
     - type1
717 
     - searchString
718 
    """
719 
    pass
12696 amit.gupta 720 
 
18977 amit.gupta 721 
  def getCounterByUserId(self, userId):
722 
    """
723 
    Parameters:
724 
     - userId
725 
    """
726 
    pass
727 
 
12722 amit.gupta 728 
  def getAllUsersByCounter(self, counterId):
729 
    """
730 
    Parameters:
731 
     - counterId
732 
    """
733 
    pass
734 
 
15251 manish.sha 735 
  def getActiveAccessTokenForUser(self, userId, source):
736 
    """
737 
    Parameters:
738 
     - userId
739 
     - source
740 
    """
741 
    pass
12722 amit.gupta 742 
 
15251 manish.sha 743 
  def validateAccessToken(self, accessToken):
744 
    """
745 
    Parameters:
746 
     - accessToken
747 
    """
748 
    pass
749 
 
17782 amit.gupta 750 
  def addItemsToCart(self, cartId, itemQty, couponCode):
751 
    """
752 
    Parameters:
753 
     - cartId
754 
     - itemQty
755 
     - couponCode
756 
    """
757 
    pass
15251 manish.sha 758 
 
17782 amit.gupta 759 
  def validateCartNew(self, cartId, pinCode, sourceId):
760 
    """
761 
    Parameters:
762 
     - cartId
763 
     - pinCode
764 
     - sourceId
765 
    """
766 
    pass
767 
 
18644 manish.sha 768 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 769 
    """
770 
    Parameters:
771 
     - userId
772 
    """
773 
    pass
17782 amit.gupta 774 
 
18530 manish.sha 775 
  def getBillingAddressForUser(self, userId):
776 
    """
777 
    Parameters:
778 
     - userId
779 
    """
780 
    pass
781 
 
18590 manish.sha 782 
  def isCreditorAssigned(self, userId):
783 
    """
784 
    Parameters:
785 
     - userId
786 
    """
787 
    pass
18530 manish.sha 788 
 
18735 manish.sha 789 
  def isTaxInvoiceEnabledUser(self, userId):
790 
    """
791 
    Parameters:
792 
     - userId
793 
    """
794 
    pass
18590 manish.sha 795 
 
19182 amit.gupta 796 
  def taxInvoiceAvailable(self, addressId):
797 
    """
798 
    Parameters:
799 
     - addressId
800 
    """
801 
    pass
802 
 
18764 kshitij.so 803 
  def getCartByValue(self, cartIds):
804 
    """
805 
    Parameters:
806 
     - cartIds
807 
    """
808 
    pass
18735 manish.sha 809 
 
19889 manas 810 
  def getCounterName(self, userIds):
811 
    """
812 
    Parameters:
813 
     - userIds
814 
    """
815 
    pass
18764 kshitij.so 816 
 
20873 kshitij.so 817 
  def setWalletAmountInCart(self, cartId, wallet_amount):
818 
    """
819 
    Parameters:
820 
     - cartId
821 
     - wallet_amount
822 
    """
823 
    pass
19889 manas 824 
 
20873 kshitij.so 825 
 
3376 rajveer 826 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 827 
  """
828 
  service
829 
  """
830 
  def __init__(self, iprot, oprot=None):
3376 rajveer 831 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 832 
 
559 chandransh 833 
  def createAnonymousUser(self, jsessionId):
94 ashish 834 
    """
835 
    Parameters:
559 chandransh 836 
     - jsessionId
94 ashish 837 
    """
559 chandransh 838 
    self.send_createAnonymousUser(jsessionId)
839 
    return self.recv_createAnonymousUser()
94 ashish 840 
 
559 chandransh 841 
  def send_createAnonymousUser(self, jsessionId):
842 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
843 
    args = createAnonymousUser_args()
844 
    args.jsessionId = jsessionId
94 ashish 845 
    args.write(self._oprot)
846 
    self._oprot.writeMessageEnd()
847 
    self._oprot.trans.flush()
848 
 
559 chandransh 849 
  def recv_createAnonymousUser(self, ):
94 ashish 850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
851 
    if mtype == TMessageType.EXCEPTION:
852 
      x = TApplicationException()
853 
      x.read(self._iprot)
854 
      self._iprot.readMessageEnd()
855 
      raise x
559 chandransh 856 
    result = createAnonymousUser_result()
94 ashish 857 
    result.read(self._iprot)
858 
    self._iprot.readMessageEnd()
3431 rajveer 859 
    if result.success is not None:
94 ashish 860 
      return result.success
3431 rajveer 861 
    if result.ucex is not None:
559 chandransh 862 
      raise result.ucex
863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 864 
 
559 chandransh 865 
  def getUserById(self, userId):
94 ashish 866 
    """
867 
    Parameters:
868 
     - userId
869 
    """
559 chandransh 870 
    self.send_getUserById(userId)
871 
    return self.recv_getUserById()
94 ashish 872 
 
559 chandransh 873 
  def send_getUserById(self, userId):
874 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
875 
    args = getUserById_args()
94 ashish 876 
    args.userId = userId
877 
    args.write(self._oprot)
878 
    self._oprot.writeMessageEnd()
879 
    self._oprot.trans.flush()
880 
 
559 chandransh 881 
  def recv_getUserById(self, ):
94 ashish 882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
883 
    if mtype == TMessageType.EXCEPTION:
884 
      x = TApplicationException()
885 
      x.read(self._iprot)
886 
      self._iprot.readMessageEnd()
887 
      raise x
559 chandransh 888 
    result = getUserById_result()
94 ashish 889 
    result.read(self._iprot)
890 
    self._iprot.readMessageEnd()
3431 rajveer 891 
    if result.success is not None:
94 ashish 892 
      return result.success
3431 rajveer 893 
    if result.ucex is not None:
559 chandransh 894 
      raise result.ucex
895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 896 
 
5326 rajveer 897 
  def getUserByCartId(self, cartId):
898 
    """
899 
    Parameters:
900 
     - cartId
901 
    """
902 
    self.send_getUserByCartId(cartId)
903 
    return self.recv_getUserByCartId()
904 
 
905 
  def send_getUserByCartId(self, cartId):
906 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
907 
    args = getUserByCartId_args()
908 
    args.cartId = cartId
909 
    args.write(self._oprot)
910 
    self._oprot.writeMessageEnd()
911 
    self._oprot.trans.flush()
912 
 
913 
  def recv_getUserByCartId(self, ):
914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
915 
    if mtype == TMessageType.EXCEPTION:
916 
      x = TApplicationException()
917 
      x.read(self._iprot)
918 
      self._iprot.readMessageEnd()
919 
      raise x
920 
    result = getUserByCartId_result()
921 
    result.read(self._iprot)
922 
    self._iprot.readMessageEnd()
923 
    if result.success is not None:
924 
      return result.success
925 
    if result.ucex is not None:
926 
      raise result.ucex
927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
928 
 
1491 vikas 929 
  def getUserByEmail(self, email):
930 
    """
931 
    Parameters:
932 
     - email
933 
    """
934 
    self.send_getUserByEmail(email)
935 
    return self.recv_getUserByEmail()
936 
 
937 
  def send_getUserByEmail(self, email):
938 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
939 
    args = getUserByEmail_args()
940 
    args.email = email
941 
    args.write(self._oprot)
942 
    self._oprot.writeMessageEnd()
943 
    self._oprot.trans.flush()
944 
 
945 
  def recv_getUserByEmail(self, ):
946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
947 
    if mtype == TMessageType.EXCEPTION:
948 
      x = TApplicationException()
949 
      x.read(self._iprot)
950 
      self._iprot.readMessageEnd()
951 
      raise x
952 
    result = getUserByEmail_result()
953 
    result.read(self._iprot)
954 
    self._iprot.readMessageEnd()
3431 rajveer 955 
    if result.success is not None:
1491 vikas 956 
      return result.success
3431 rajveer 957 
    if result.ucex is not None:
1491 vikas 958 
      raise result.ucex
959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
960 
 
3032 mandeep.dh 961 
  def getUserByMobileNumber(self, mobileNumber):
962 
    """
963 
    Parameters:
964 
     - mobileNumber
965 
    """
966 
    self.send_getUserByMobileNumber(mobileNumber)
967 
    return self.recv_getUserByMobileNumber()
968 
 
969 
  def send_getUserByMobileNumber(self, mobileNumber):
970 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
971 
    args = getUserByMobileNumber_args()
972 
    args.mobileNumber = mobileNumber
973 
    args.write(self._oprot)
974 
    self._oprot.writeMessageEnd()
975 
    self._oprot.trans.flush()
976 
 
977 
  def recv_getUserByMobileNumber(self, ):
978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
979 
    if mtype == TMessageType.EXCEPTION:
980 
      x = TApplicationException()
981 
      x.read(self._iprot)
982 
      self._iprot.readMessageEnd()
983 
      raise x
984 
    result = getUserByMobileNumber_result()
985 
    result.read(self._iprot)
986 
    self._iprot.readMessageEnd()
3431 rajveer 987 
    if result.success is not None:
3032 mandeep.dh 988 
      return result.success
3431 rajveer 989 
    if result.ucex is not None:
3032 mandeep.dh 990 
      raise result.ucex
991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
992 
 
559 chandransh 993 
  def createUser(self, user):
94 ashish 994 
    """
995 
    Parameters:
559 chandransh 996 
     - user
94 ashish 997 
    """
559 chandransh 998 
    self.send_createUser(user)
999 
    return self.recv_createUser()
94 ashish 1000 
 
559 chandransh 1001 
  def send_createUser(self, user):
1002 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
1003 
    args = createUser_args()
1004 
    args.user = user
94 ashish 1005 
    args.write(self._oprot)
1006 
    self._oprot.writeMessageEnd()
1007 
    self._oprot.trans.flush()
1008 
 
559 chandransh 1009 
  def recv_createUser(self, ):
94 ashish 1010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1011 
    if mtype == TMessageType.EXCEPTION:
1012 
      x = TApplicationException()
1013 
      x.read(self._iprot)
1014 
      self._iprot.readMessageEnd()
1015 
      raise x
559 chandransh 1016 
    result = createUser_result()
94 ashish 1017 
    result.read(self._iprot)
1018 
    self._iprot.readMessageEnd()
3431 rajveer 1019 
    if result.success is not None:
94 ashish 1020 
      return result.success
3431 rajveer 1021 
    if result.ucex is not None:
559 chandransh 1022 
      raise result.ucex
1023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1024 
 
559 chandransh 1025 
  def updateUser(self, user):
94 ashish 1026 
    """
1027 
    Parameters:
559 chandransh 1028 
     - user
94 ashish 1029 
    """
559 chandransh 1030 
    self.send_updateUser(user)
1031 
    return self.recv_updateUser()
94 ashish 1032 
 
559 chandransh 1033 
  def send_updateUser(self, user):
1034 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1035 
    args = updateUser_args()
1036 
    args.user = user
94 ashish 1037 
    args.write(self._oprot)
1038 
    self._oprot.writeMessageEnd()
1039 
    self._oprot.trans.flush()
1040 
 
559 chandransh 1041 
  def recv_updateUser(self, ):
94 ashish 1042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1043 
    if mtype == TMessageType.EXCEPTION:
1044 
      x = TApplicationException()
1045 
      x.read(self._iprot)
1046 
      self._iprot.readMessageEnd()
1047 
      raise x
559 chandransh 1048 
    result = updateUser_result()
94 ashish 1049 
    result.read(self._iprot)
1050 
    self._iprot.readMessageEnd()
3431 rajveer 1051 
    if result.success is not None:
94 ashish 1052 
      return result.success
3431 rajveer 1053 
    if result.ucex is not None:
559 chandransh 1054 
      raise result.ucex
1055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1056 
 
559 chandransh 1057 
  def authenticateUser(self, email, password):
94 ashish 1058 
    """
1059 
    Parameters:
1060 
     - email
1061 
     - password
1062 
    """
559 chandransh 1063 
    self.send_authenticateUser(email, password)
122 ashish 1064 
    return self.recv_authenticateUser()
1065 
 
559 chandransh 1066 
  def send_authenticateUser(self, email, password):
122 ashish 1067 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1068 
    args = authenticateUser_args()
559 chandransh 1069 
    args.email = email
122 ashish 1070 
    args.password = password
1071 
    args.write(self._oprot)
1072 
    self._oprot.writeMessageEnd()
1073 
    self._oprot.trans.flush()
1074 
 
1075 
  def recv_authenticateUser(self, ):
1076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1077 
    if mtype == TMessageType.EXCEPTION:
1078 
      x = TApplicationException()
1079 
      x.read(self._iprot)
1080 
      self._iprot.readMessageEnd()
1081 
      raise x
1082 
    result = authenticateUser_result()
1083 
    result.read(self._iprot)
1084 
    self._iprot.readMessageEnd()
3431 rajveer 1085 
    if result.success is not None:
122 ashish 1086 
      return result.success
3431 rajveer 1087 
    if result.auex is not None:
559 chandransh 1088 
      raise result.auex
122 ashish 1089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1090 
 
94 ashish 1091 
  def userExists(self, email):
1092 
    """
1093 
    Parameters:
1094 
     - email
1095 
    """
1096 
    self.send_userExists(email)
1097 
    return self.recv_userExists()
1098 
 
1099 
  def send_userExists(self, email):
1100 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1101 
    args = userExists_args()
1102 
    args.email = email
1103 
    args.write(self._oprot)
1104 
    self._oprot.writeMessageEnd()
1105 
    self._oprot.trans.flush()
1106 
 
1107 
  def recv_userExists(self, ):
1108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1109 
    if mtype == TMessageType.EXCEPTION:
1110 
      x = TApplicationException()
1111 
      x.read(self._iprot)
1112 
      self._iprot.readMessageEnd()
1113 
      raise x
1114 
    result = userExists_result()
1115 
    result.read(self._iprot)
1116 
    self._iprot.readMessageEnd()
3431 rajveer 1117 
    if result.success is not None:
94 ashish 1118 
      return result.success
3431 rajveer 1119 
    if result.ucx is not None:
94 ashish 1120 
      raise result.ucx
1121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1122 
 
567 rajveer 1123 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1124 
    """
1125 
    Parameters:
1126 
     - userId
1127 
     - address
513 rajveer 1128 
     - setDefault
94 ashish 1129 
    """
567 rajveer 1130 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1131 
    return self.recv_addAddressForUser()
1132 
 
567 rajveer 1133 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1134 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1135 
    args = addAddressForUser_args()
559 chandransh 1136 
    args.userId = userId
94 ashish 1137 
    args.address = address
513 rajveer 1138 
    args.setDefault = setDefault
94 ashish 1139 
    args.write(self._oprot)
1140 
    self._oprot.writeMessageEnd()
1141 
    self._oprot.trans.flush()
1142 
 
1143 
  def recv_addAddressForUser(self, ):
1144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1145 
    if mtype == TMessageType.EXCEPTION:
1146 
      x = TApplicationException()
1147 
      x.read(self._iprot)
1148 
      self._iprot.readMessageEnd()
1149 
      raise x
1150 
    result = addAddressForUser_result()
1151 
    result.read(self._iprot)
1152 
    self._iprot.readMessageEnd()
3431 rajveer 1153 
    if result.success is not None:
94 ashish 1154 
      return result.success
3431 rajveer 1155 
    if result.ucx is not None:
94 ashish 1156 
      raise result.ucx
1157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1158 
 
1159 
  def removeAddressForUser(self, userid, addressId):
1160 
    """
1161 
    Parameters:
1162 
     - userid
1163 
     - addressId
1164 
    """
1165 
    self.send_removeAddressForUser(userid, addressId)
1166 
    return self.recv_removeAddressForUser()
1167 
 
1168 
  def send_removeAddressForUser(self, userid, addressId):
1169 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1170 
    args = removeAddressForUser_args()
1171 
    args.userid = userid
1172 
    args.addressId = addressId
1173 
    args.write(self._oprot)
1174 
    self._oprot.writeMessageEnd()
1175 
    self._oprot.trans.flush()
1176 
 
1177 
  def recv_removeAddressForUser(self, ):
1178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1179 
    if mtype == TMessageType.EXCEPTION:
1180 
      x = TApplicationException()
1181 
      x.read(self._iprot)
1182 
      self._iprot.readMessageEnd()
1183 
      raise x
1184 
    result = removeAddressForUser_result()
1185 
    result.read(self._iprot)
1186 
    self._iprot.readMessageEnd()
3431 rajveer 1187 
    if result.success is not None:
94 ashish 1188 
      return result.success
3431 rajveer 1189 
    if result.ucx is not None:
94 ashish 1190 
      raise result.ucx
1191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1192 
 
22358 ashik.ali 1193 
  def updateAddress(self, address):
1194 
    """
1195 
    Parameters:
1196 
     - address
1197 
    """
1198 
    self.send_updateAddress(address)
1199 
    return self.recv_updateAddress()
1200 
 
1201 
  def send_updateAddress(self, address):
1202 
    self._oprot.writeMessageBegin('updateAddress', TMessageType.CALL, self._seqid)
1203 
    args = updateAddress_args()
1204 
    args.address = address
1205 
    args.write(self._oprot)
1206 
    self._oprot.writeMessageEnd()
1207 
    self._oprot.trans.flush()
1208 
 
1209 
  def recv_updateAddress(self, ):
1210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1211 
    if mtype == TMessageType.EXCEPTION:
1212 
      x = TApplicationException()
1213 
      x.read(self._iprot)
1214 
      self._iprot.readMessageEnd()
1215 
      raise x
1216 
    result = updateAddress_result()
1217 
    result.read(self._iprot)
1218 
    self._iprot.readMessageEnd()
1219 
    if result.success is not None:
1220 
      return result.success
1221 
    if result.ucx is not None:
1222 
      raise result.ucx
1223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAddress failed: unknown result");
1224 
 
94 ashish 1225 
  def setUserAsLoggedIn(self, userId, timestamp):
1226 
    """
1227 
    Parameters:
1228 
     - userId
1229 
     - timestamp
1230 
    """
1231 
    self.send_setUserAsLoggedIn(userId, timestamp)
1232 
    return self.recv_setUserAsLoggedIn()
1233 
 
1234 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1235 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1236 
    args = setUserAsLoggedIn_args()
1237 
    args.userId = userId
1238 
    args.timestamp = timestamp
1239 
    args.write(self._oprot)
1240 
    self._oprot.writeMessageEnd()
1241 
    self._oprot.trans.flush()
1242 
 
1243 
  def recv_setUserAsLoggedIn(self, ):
1244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1245 
    if mtype == TMessageType.EXCEPTION:
1246 
      x = TApplicationException()
1247 
      x.read(self._iprot)
1248 
      self._iprot.readMessageEnd()
1249 
      raise x
1250 
    result = setUserAsLoggedIn_result()
1251 
    result.read(self._iprot)
1252 
    self._iprot.readMessageEnd()
3431 rajveer 1253 
    if result.success is not None:
94 ashish 1254 
      return result.success
3431 rajveer 1255 
    if result.ucx is not None:
94 ashish 1256 
      raise result.ucx
1257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1258 
 
1259 
  def setUserAsLoggedOut(self, userid, timestamp):
1260 
    """
1261 
    Parameters:
1262 
     - userid
1263 
     - timestamp
1264 
    """
1265 
    self.send_setUserAsLoggedOut(userid, timestamp)
1266 
    return self.recv_setUserAsLoggedOut()
1267 
 
1268 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1269 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1270 
    args = setUserAsLoggedOut_args()
1271 
    args.userid = userid
1272 
    args.timestamp = timestamp
1273 
    args.write(self._oprot)
1274 
    self._oprot.writeMessageEnd()
1275 
    self._oprot.trans.flush()
1276 
 
1277 
  def recv_setUserAsLoggedOut(self, ):
1278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1279 
    if mtype == TMessageType.EXCEPTION:
1280 
      x = TApplicationException()
1281 
      x.read(self._iprot)
1282 
      self._iprot.readMessageEnd()
1283 
      raise x
1284 
    result = setUserAsLoggedOut_result()
1285 
    result.read(self._iprot)
1286 
    self._iprot.readMessageEnd()
3431 rajveer 1287 
    if result.success is not None:
94 ashish 1288 
      return result.success
3431 rajveer 1289 
    if result.ucx is not None:
94 ashish 1290 
      raise result.ucx
1291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1292 
 
504 rajveer 1293 
  def setDefaultAddress(self, userid, addressId):
1294 
    """
1295 
    Parameters:
1296 
     - userid
1297 
     - addressId
1298 
    """
1299 
    self.send_setDefaultAddress(userid, addressId)
1300 
    return self.recv_setDefaultAddress()
1301 
 
1302 
  def send_setDefaultAddress(self, userid, addressId):
1303 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1304 
    args = setDefaultAddress_args()
1305 
    args.userid = userid
1306 
    args.addressId = addressId
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_setDefaultAddress(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = setDefaultAddress_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
3431 rajveer 1321 
    if result.success is not None:
504 rajveer 1322 
      return result.success
3431 rajveer 1323 
    if result.ucx is not None:
504 rajveer 1324 
      raise result.ucx
1325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1326 
 
594 rajveer 1327 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1328 
    """
1329 
    Parameters:
1330 
     - userid
594 rajveer 1331 
     - oldPassword
1332 
     - newPassword
94 ashish 1333 
    """
594 rajveer 1334 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1335 
    return self.recv_updatePassword()
1336 
 
594 rajveer 1337 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1338 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1339 
    args = updatePassword_args()
1340 
    args.userid = userid
594 rajveer 1341 
    args.oldPassword = oldPassword
1342 
    args.newPassword = newPassword
94 ashish 1343 
    args.write(self._oprot)
1344 
    self._oprot.writeMessageEnd()
1345 
    self._oprot.trans.flush()
1346 
 
1347 
  def recv_updatePassword(self, ):
1348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1349 
    if mtype == TMessageType.EXCEPTION:
1350 
      x = TApplicationException()
1351 
      x.read(self._iprot)
1352 
      self._iprot.readMessageEnd()
1353 
      raise x
1354 
    result = updatePassword_result()
1355 
    result.read(self._iprot)
1356 
    self._iprot.readMessageEnd()
3431 rajveer 1357 
    if result.success is not None:
94 ashish 1358 
      return result.success
3431 rajveer 1359 
    if result.ucx is not None:
94 ashish 1360 
      raise result.ucx
1361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1362 
 
884 rajveer 1363 
  def forgotPassword(self, email, newPassword):
581 rajveer 1364 
    """
1365 
    Parameters:
1366 
     - email
884 rajveer 1367 
     - newPassword
581 rajveer 1368 
    """
884 rajveer 1369 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1370 
    return self.recv_forgotPassword()
1371 
 
884 rajveer 1372 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1373 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1374 
    args = forgotPassword_args()
1375 
    args.email = email
884 rajveer 1376 
    args.newPassword = newPassword
581 rajveer 1377 
    args.write(self._oprot)
1378 
    self._oprot.writeMessageEnd()
1379 
    self._oprot.trans.flush()
1380 
 
1381 
  def recv_forgotPassword(self, ):
1382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1383 
    if mtype == TMessageType.EXCEPTION:
1384 
      x = TApplicationException()
1385 
      x.read(self._iprot)
1386 
      self._iprot.readMessageEnd()
1387 
      raise x
1388 
    result = forgotPassword_result()
1389 
    result.read(self._iprot)
1390 
    self._iprot.readMessageEnd()
3431 rajveer 1391 
    if result.success is not None:
581 rajveer 1392 
      return result.success
3431 rajveer 1393 
    if result.ucx is not None:
581 rajveer 1394 
      raise result.ucx
1395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1396 
 
594 rajveer 1397 
  def getAllAddressesForUser(self, userId):
1398 
    """
1399 
    Parameters:
1400 
     - userId
1401 
    """
1402 
    self.send_getAllAddressesForUser(userId)
1403 
    return self.recv_getAllAddressesForUser()
1404 
 
1405 
  def send_getAllAddressesForUser(self, userId):
1406 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1407 
    args = getAllAddressesForUser_args()
1408 
    args.userId = userId
1409 
    args.write(self._oprot)
1410 
    self._oprot.writeMessageEnd()
1411 
    self._oprot.trans.flush()
1412 
 
1413 
  def recv_getAllAddressesForUser(self, ):
1414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1415 
    if mtype == TMessageType.EXCEPTION:
1416 
      x = TApplicationException()
1417 
      x.read(self._iprot)
1418 
      self._iprot.readMessageEnd()
1419 
      raise x
1420 
    result = getAllAddressesForUser_result()
1421 
    result.read(self._iprot)
1422 
    self._iprot.readMessageEnd()
3431 rajveer 1423 
    if result.success is not None:
594 rajveer 1424 
      return result.success
3431 rajveer 1425 
    if result.ucx is not None:
594 rajveer 1426 
      raise result.ucx
1427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1428 
 
1894 vikas 1429 
  def getAddressById(self, addressId):
1430 
    """
1431 
    Parameters:
1432 
     - addressId
1433 
    """
1434 
    self.send_getAddressById(addressId)
1435 
    return self.recv_getAddressById()
1436 
 
1437 
  def send_getAddressById(self, addressId):
1438 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1439 
    args = getAddressById_args()
1440 
    args.addressId = addressId
1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
1445 
  def recv_getAddressById(self, ):
1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
1452 
    result = getAddressById_result()
1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
3431 rajveer 1455 
    if result.success is not None:
1894 vikas 1456 
      return result.success
3431 rajveer 1457 
    if result.ucx is not None:
1894 vikas 1458 
      raise result.ucx
1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1460 
 
594 rajveer 1461 
  def getDefaultAddressId(self, userId):
1462 
    """
1463 
    Parameters:
1464 
     - userId
1465 
    """
1466 
    self.send_getDefaultAddressId(userId)
1467 
    return self.recv_getDefaultAddressId()
1468 
 
1469 
  def send_getDefaultAddressId(self, userId):
1470 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1471 
    args = getDefaultAddressId_args()
1472 
    args.userId = userId
1473 
    args.write(self._oprot)
1474 
    self._oprot.writeMessageEnd()
1475 
    self._oprot.trans.flush()
1476 
 
1477 
  def recv_getDefaultAddressId(self, ):
1478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1479 
    if mtype == TMessageType.EXCEPTION:
1480 
      x = TApplicationException()
1481 
      x.read(self._iprot)
1482 
      self._iprot.readMessageEnd()
1483 
      raise x
1484 
    result = getDefaultAddressId_result()
1485 
    result.read(self._iprot)
1486 
    self._iprot.readMessageEnd()
3431 rajveer 1487 
    if result.success is not None:
594 rajveer 1488 
      return result.success
3431 rajveer 1489 
    if result.ucx is not None:
594 rajveer 1490 
      raise result.ucx
1491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1492 
 
785 rajveer 1493 
  def getDefaultPincode(self, userId):
1494 
    """
1495 
    Parameters:
1496 
     - userId
1497 
    """
1498 
    self.send_getDefaultPincode(userId)
1499 
    return self.recv_getDefaultPincode()
1500 
 
1501 
  def send_getDefaultPincode(self, userId):
1502 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1503 
    args = getDefaultPincode_args()
1504 
    args.userId = userId
1505 
    args.write(self._oprot)
1506 
    self._oprot.writeMessageEnd()
1507 
    self._oprot.trans.flush()
1508 
 
1509 
  def recv_getDefaultPincode(self, ):
1510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1511 
    if mtype == TMessageType.EXCEPTION:
1512 
      x = TApplicationException()
1513 
      x.read(self._iprot)
1514 
      self._iprot.readMessageEnd()
1515 
      raise x
1516 
    result = getDefaultPincode_result()
1517 
    result.read(self._iprot)
1518 
    self._iprot.readMessageEnd()
3431 rajveer 1519 
    if result.success is not None:
785 rajveer 1520 
      return result.success
3431 rajveer 1521 
    if result.ucx is not None:
785 rajveer 1522 
      raise result.ucx
1523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1524 
 
1274 varun.gupt 1525 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1526 
    """
1527 
    Parameters:
1528 
     - userId
1529 
     - replyTo
1530 
     - communicationType
1531 
     - orderId
1532 
     - airwaybillNo
1533 
     - productName
1534 
     - subject
1535 
     - message
1536 
    """
1537 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1538 
    return self.recv_saveUserCommunication()
1539 
 
1540 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1541 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1542 
    args = saveUserCommunication_args()
1543 
    args.userId = userId
1544 
    args.replyTo = replyTo
1545 
    args.communicationType = communicationType
1546 
    args.orderId = orderId
1547 
    args.airwaybillNo = airwaybillNo
1548 
    args.productName = productName
1549 
    args.subject = subject
1550 
    args.message = message
1551 
    args.write(self._oprot)
1552 
    self._oprot.writeMessageEnd()
1553 
    self._oprot.trans.flush()
1554 
 
1555 
  def recv_saveUserCommunication(self, ):
1556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1557 
    if mtype == TMessageType.EXCEPTION:
1558 
      x = TApplicationException()
1559 
      x.read(self._iprot)
1560 
      self._iprot.readMessageEnd()
1561 
      raise x
1562 
    result = saveUserCommunication_result()
1563 
    result.read(self._iprot)
1564 
    self._iprot.readMessageEnd()
3431 rajveer 1565 
    if result.success is not None:
1274 varun.gupt 1566 
      return result.success
3431 rajveer 1567 
    if result.ucx is not None:
1274 varun.gupt 1568 
      raise result.ucx
1569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1570 
 
1590 varun.gupt 1571 
  def getUserCommunicationById(self, id):
1572 
    """
1573 
    Parameters:
1574 
     - id
1575 
    """
1576 
    self.send_getUserCommunicationById(id)
1577 
    return self.recv_getUserCommunicationById()
1578 
 
1579 
  def send_getUserCommunicationById(self, id):
1580 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1581 
    args = getUserCommunicationById_args()
1582 
    args.id = id
1583 
    args.write(self._oprot)
1584 
    self._oprot.writeMessageEnd()
1585 
    self._oprot.trans.flush()
1586 
 
1587 
  def recv_getUserCommunicationById(self, ):
1588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1589 
    if mtype == TMessageType.EXCEPTION:
1590 
      x = TApplicationException()
1591 
      x.read(self._iprot)
1592 
      self._iprot.readMessageEnd()
1593 
      raise x
1594 
    result = getUserCommunicationById_result()
1595 
    result.read(self._iprot)
1596 
    self._iprot.readMessageEnd()
3431 rajveer 1597 
    if result.success is not None:
1590 varun.gupt 1598 
      return result.success
3431 rajveer 1599 
    if result.ucx is not None:
1590 varun.gupt 1600 
      raise result.ucx
1601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1602 
 
1603 
  def getUserCommunicationByUser(self, userId):
1604 
    """
1605 
    Parameters:
1606 
     - userId
1607 
    """
1608 
    self.send_getUserCommunicationByUser(userId)
1609 
    return self.recv_getUserCommunicationByUser()
1610 
 
1611 
  def send_getUserCommunicationByUser(self, userId):
1612 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1613 
    args = getUserCommunicationByUser_args()
1614 
    args.userId = userId
1615 
    args.write(self._oprot)
1616 
    self._oprot.writeMessageEnd()
1617 
    self._oprot.trans.flush()
1618 
 
1619 
  def recv_getUserCommunicationByUser(self, ):
1620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1621 
    if mtype == TMessageType.EXCEPTION:
1622 
      x = TApplicationException()
1623 
      x.read(self._iprot)
1624 
      self._iprot.readMessageEnd()
1625 
      raise x
1626 
    result = getUserCommunicationByUser_result()
1627 
    result.read(self._iprot)
1628 
    self._iprot.readMessageEnd()
3431 rajveer 1629 
    if result.success is not None:
1590 varun.gupt 1630 
      return result.success
3431 rajveer 1631 
    if result.ucx is not None:
1590 varun.gupt 1632 
      raise result.ucx
1633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1634 
 
1635 
  def getAllUserCommunications(self, ):
1636 
    self.send_getAllUserCommunications()
1637 
    return self.recv_getAllUserCommunications()
1638 
 
1639 
  def send_getAllUserCommunications(self, ):
1640 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1641 
    args = getAllUserCommunications_args()
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1646 
  def recv_getAllUserCommunications(self, ):
1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1653 
    result = getAllUserCommunications_result()
1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
3431 rajveer 1656 
    if result.success is not None:
1590 varun.gupt 1657 
      return result.success
3431 rajveer 1658 
    if result.ucx is not None:
1590 varun.gupt 1659 
      raise result.ucx
1660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1661 
 
5407 amar.kumar 1662 
  def removeUserCommunication(self, id):
1663 
    """
1664 
    Parameters:
1665 
     - id
1666 
    """
1667 
    self.send_removeUserCommunication(id)
1668 
    self.recv_removeUserCommunication()
1669 
 
1670 
  def send_removeUserCommunication(self, id):
1671 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1672 
    args = removeUserCommunication_args()
1673 
    args.id = id
1674 
    args.write(self._oprot)
1675 
    self._oprot.writeMessageEnd()
1676 
    self._oprot.trans.flush()
1677 
 
1678 
  def recv_removeUserCommunication(self, ):
1679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1680 
    if mtype == TMessageType.EXCEPTION:
1681 
      x = TApplicationException()
1682 
      x.read(self._iprot)
1683 
      self._iprot.readMessageEnd()
1684 
      raise x
1685 
    result = removeUserCommunication_result()
1686 
    result.read(self._iprot)
1687 
    self._iprot.readMessageEnd()
1688 
    if result.ucx is not None:
1689 
      raise result.ucx
1690 
    return
1691 
 
1859 vikas 1692 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1693 
    """
1694 
    Parameters:
1695 
     - name
1859 vikas 1696 
     - addedOn
1845 vikas 1697 
    """
1859 vikas 1698 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1699 
    return self.recv_createMasterAffiliate()
1700 
 
1859 vikas 1701 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1702 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1703 
    args = createMasterAffiliate_args()
1704 
    args.name = name
1859 vikas 1705 
    args.addedOn = addedOn
1845 vikas 1706 
    args.write(self._oprot)
1707 
    self._oprot.writeMessageEnd()
1708 
    self._oprot.trans.flush()
1709 
 
1710 
  def recv_createMasterAffiliate(self, ):
1711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1712 
    if mtype == TMessageType.EXCEPTION:
1713 
      x = TApplicationException()
1714 
      x.read(self._iprot)
1715 
      self._iprot.readMessageEnd()
1716 
      raise x
1717 
    result = createMasterAffiliate_result()
1718 
    result.read(self._iprot)
1719 
    self._iprot.readMessageEnd()
3431 rajveer 1720 
    if result.success is not None:
1845 vikas 1721 
      return result.success
3431 rajveer 1722 
    if result.utx is not None:
1845 vikas 1723 
      raise result.utx
1724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1725 
 
1899 vikas 1726 
  def getAllMasterAffiliates(self, ):
1727 
    self.send_getAllMasterAffiliates()
1728 
    return self.recv_getAllMasterAffiliates()
1729 
 
1730 
  def send_getAllMasterAffiliates(self, ):
1731 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1732 
    args = getAllMasterAffiliates_args()
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getAllMasterAffiliates(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getAllMasterAffiliates_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
1899 vikas 1748 
      return result.success
3431 rajveer 1749 
    if result.utx is not None:
1899 vikas 1750 
      raise result.utx
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1752 
 
1845 vikas 1753 
  def getMasterAffiliateById(self, id):
1754 
    """
1755 
    Parameters:
1756 
     - id
1757 
    """
1758 
    self.send_getMasterAffiliateById(id)
1759 
    return self.recv_getMasterAffiliateById()
1760 
 
1761 
  def send_getMasterAffiliateById(self, id):
1762 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1763 
    args = getMasterAffiliateById_args()
1764 
    args.id = id
1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1769 
  def recv_getMasterAffiliateById(self, ):
1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1776 
    result = getMasterAffiliateById_result()
1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
3431 rajveer 1779 
    if result.success is not None:
1845 vikas 1780 
      return result.success
3431 rajveer 1781 
    if result.utx is not None:
1845 vikas 1782 
      raise result.utx
1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1784 
 
1785 
  def getMasterAffiliateByName(self, name):
1786 
    """
1787 
    Parameters:
1788 
     - name
1789 
    """
1790 
    self.send_getMasterAffiliateByName(name)
1791 
    return self.recv_getMasterAffiliateByName()
1792 
 
1793 
  def send_getMasterAffiliateByName(self, name):
1794 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1795 
    args = getMasterAffiliateByName_args()
1796 
    args.name = name
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_getMasterAffiliateByName(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = getMasterAffiliateByName_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
3431 rajveer 1811 
    if result.success is not None:
1845 vikas 1812 
      return result.success
3431 rajveer 1813 
    if result.utx is not None:
1845 vikas 1814 
      raise result.utx
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1816 
 
1859 vikas 1817 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1818 
    """
1819 
    Parameters:
1820 
     - name
1821 
     - url
1822 
     - masterAffiliateId
1859 vikas 1823 
     - addedOn
1845 vikas 1824 
    """
1859 vikas 1825 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1826 
    return self.recv_createAffiliate()
1827 
 
1859 vikas 1828 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1829 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1830 
    args = createAffiliate_args()
1831 
    args.name = name
1832 
    args.url = url
1833 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1834 
    args.addedOn = addedOn
1845 vikas 1835 
    args.write(self._oprot)
1836 
    self._oprot.writeMessageEnd()
1837 
    self._oprot.trans.flush()
1838 
 
1839 
  def recv_createAffiliate(self, ):
1840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1841 
    if mtype == TMessageType.EXCEPTION:
1842 
      x = TApplicationException()
1843 
      x.read(self._iprot)
1844 
      self._iprot.readMessageEnd()
1845 
      raise x
1846 
    result = createAffiliate_result()
1847 
    result.read(self._iprot)
1848 
    self._iprot.readMessageEnd()
3431 rajveer 1849 
    if result.success is not None:
1845 vikas 1850 
      return result.success
3431 rajveer 1851 
    if result.utx is not None:
1845 vikas 1852 
      raise result.utx
1853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1854 
 
1855 
  def getAffiliateById(self, id):
1856 
    """
1857 
    Parameters:
1858 
     - id
1859 
    """
1860 
    self.send_getAffiliateById(id)
1861 
    return self.recv_getAffiliateById()
1862 
 
1863 
  def send_getAffiliateById(self, id):
1864 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1865 
    args = getAffiliateById_args()
1866 
    args.id = id
1867 
    args.write(self._oprot)
1868 
    self._oprot.writeMessageEnd()
1869 
    self._oprot.trans.flush()
1870 
 
1871 
  def recv_getAffiliateById(self, ):
1872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1873 
    if mtype == TMessageType.EXCEPTION:
1874 
      x = TApplicationException()
1875 
      x.read(self._iprot)
1876 
      self._iprot.readMessageEnd()
1877 
      raise x
1878 
    result = getAffiliateById_result()
1879 
    result.read(self._iprot)
1880 
    self._iprot.readMessageEnd()
3431 rajveer 1881 
    if result.success is not None:
1845 vikas 1882 
      return result.success
3431 rajveer 1883 
    if result.utx is not None:
1845 vikas 1884 
      raise result.utx
1885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1886 
 
1887 
  def getAffiliateByName(self, name):
1888 
    """
1889 
    Parameters:
1890 
     - name
1891 
    """
1892 
    self.send_getAffiliateByName(name)
1893 
    return self.recv_getAffiliateByName()
1894 
 
1895 
  def send_getAffiliateByName(self, name):
1896 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1897 
    args = getAffiliateByName_args()
1898 
    args.name = name
1899 
    args.write(self._oprot)
1900 
    self._oprot.writeMessageEnd()
1901 
    self._oprot.trans.flush()
1902 
 
1903 
  def recv_getAffiliateByName(self, ):
1904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1905 
    if mtype == TMessageType.EXCEPTION:
1906 
      x = TApplicationException()
1907 
      x.read(self._iprot)
1908 
      self._iprot.readMessageEnd()
1909 
      raise x
1910 
    result = getAffiliateByName_result()
1911 
    result.read(self._iprot)
1912 
    self._iprot.readMessageEnd()
3431 rajveer 1913 
    if result.success is not None:
1845 vikas 1914 
      return result.success
3431 rajveer 1915 
    if result.utx is not None:
1845 vikas 1916 
      raise result.utx
1917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1918 
 
1996 vikas 1919 
  def getTrackerById(self, id):
1845 vikas 1920 
    """
1921 
    Parameters:
1922 
     - id
1923 
    """
1996 vikas 1924 
    self.send_getTrackerById(id)
1845 vikas 1925 
    return self.recv_getTrackerById()
1926 
 
1996 vikas 1927 
  def send_getTrackerById(self, id):
1845 vikas 1928 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1929 
    args = getTrackerById_args()
1996 vikas 1930 
    args.id = id
1845 vikas 1931 
    args.write(self._oprot)
1932 
    self._oprot.writeMessageEnd()
1933 
    self._oprot.trans.flush()
1934 
 
1935 
  def recv_getTrackerById(self, ):
1936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1937 
    if mtype == TMessageType.EXCEPTION:
1938 
      x = TApplicationException()
1939 
      x.read(self._iprot)
1940 
      self._iprot.readMessageEnd()
1941 
      raise x
1942 
    result = getTrackerById_result()
1943 
    result.read(self._iprot)
1944 
    self._iprot.readMessageEnd()
3431 rajveer 1945 
    if result.success is not None:
1845 vikas 1946 
      return result.success
3431 rajveer 1947 
    if result.utx is not None:
1845 vikas 1948 
      raise result.utx
1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1950 
 
1996 vikas 1951 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1952 
    """
1953 
    Parameters:
1996 vikas 1954 
     - id
1845 vikas 1955 
    """
1996 vikas 1956 
    self.send_getAffiliatesByMasterAffiliate(id)
1957 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1958 
 
1996 vikas 1959 
  def send_getAffiliatesByMasterAffiliate(self, id):
1960 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1961 
    args = getAffiliatesByMasterAffiliate_args()
1962 
    args.id = id
1845 vikas 1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
1996 vikas 1967 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
1996 vikas 1974 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
3431 rajveer 1977 
    if result.success is not None:
1845 vikas 1978 
      return result.success
3431 rajveer 1979 
    if result.utx is not None:
1845 vikas 1980 
      raise result.utx
1996 vikas 1981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1982 
 
1996 vikas 1983 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1984 
    """
1985 
    Parameters:
1996 vikas 1986 
     - affiliateId
1845 vikas 1987 
     - userId
1988 
     - event
1989 
     - url
1990 
     - data
1859 vikas 1991 
     - addedOn
1845 vikas 1992 
    """
1996 vikas 1993 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1994 
    return self.recv_addTrackLog()
1995 
 
1996 vikas 1996 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1997 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1998 
    args = addTrackLog_args()
1996 vikas 1999 
    args.affiliateId = affiliateId
1845 vikas 2000 
    args.userId = userId
2001 
    args.event = event
2002 
    args.url = url
2003 
    args.data = data
1859 vikas 2004 
    args.addedOn = addedOn
1845 vikas 2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_addTrackLog(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = addTrackLog_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
3431 rajveer 2019 
    if result.success is not None:
1845 vikas 2020 
      return result.success
3431 rajveer 2021 
    if result.utx is not None:
1845 vikas 2022 
      raise result.utx
2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
2024 
 
2025 
  def getTrackLogById(self, id):
2026 
    """
2027 
    Parameters:
2028 
     - id
2029 
    """
2030 
    self.send_getTrackLogById(id)
2031 
    return self.recv_getTrackLogById()
2032 
 
2033 
  def send_getTrackLogById(self, id):
2034 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
2035 
    args = getTrackLogById_args()
2036 
    args.id = id
2037 
    args.write(self._oprot)
2038 
    self._oprot.writeMessageEnd()
2039 
    self._oprot.trans.flush()
2040 
 
2041 
  def recv_getTrackLogById(self, ):
2042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2043 
    if mtype == TMessageType.EXCEPTION:
2044 
      x = TApplicationException()
2045 
      x.read(self._iprot)
2046 
      self._iprot.readMessageEnd()
2047 
      raise x
2048 
    result = getTrackLogById_result()
2049 
    result.read(self._iprot)
2050 
    self._iprot.readMessageEnd()
3431 rajveer 2051 
    if result.success is not None:
1845 vikas 2052 
      return result.success
3431 rajveer 2053 
    if result.utx is not None:
1845 vikas 2054 
      raise result.utx
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2056 
 
3293 vikas 2057 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2058 
    """
2059 
    Parameters:
1996 vikas 2060 
     - affiliateId
3293 vikas 2061 
     - startDate
2062 
     - endDate
1845 vikas 2063 
    """
3293 vikas 2064 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2065 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2066 
 
3293 vikas 2067 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2068 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2069 
    args = getTrackLogsByAffiliate_args()
2070 
    args.affiliateId = affiliateId
3293 vikas 2071 
    args.startDate = startDate
2072 
    args.endDate = endDate
1845 vikas 2073 
    args.write(self._oprot)
2074 
    self._oprot.writeMessageEnd()
2075 
    self._oprot.trans.flush()
2076 
 
1996 vikas 2077 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2079 
    if mtype == TMessageType.EXCEPTION:
2080 
      x = TApplicationException()
2081 
      x.read(self._iprot)
2082 
      self._iprot.readMessageEnd()
2083 
      raise x
1996 vikas 2084 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2085 
    result.read(self._iprot)
2086 
    self._iprot.readMessageEnd()
3431 rajveer 2087 
    if result.success is not None:
1845 vikas 2088 
      return result.success
3431 rajveer 2089 
    if result.utx is not None:
1845 vikas 2090 
      raise result.utx
1996 vikas 2091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2092 
 
2093 
  def getTrackLogsByUser(self, userId):
2094 
    """
2095 
    Parameters:
2096 
     - userId
2097 
    """
2098 
    self.send_getTrackLogsByUser(userId)
2099 
    return self.recv_getTrackLogsByUser()
2100 
 
2101 
  def send_getTrackLogsByUser(self, userId):
2102 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2103 
    args = getTrackLogsByUser_args()
2104 
    args.userId = userId
2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
2109 
  def recv_getTrackLogsByUser(self, ):
2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
2116 
    result = getTrackLogsByUser_result()
2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
3431 rajveer 2119 
    if result.success is not None:
1845 vikas 2120 
      return result.success
3431 rajveer 2121 
    if result.utx is not None:
1845 vikas 2122 
      raise result.utx
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2124 
 
1996 vikas 2125 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2126 
    """
2127 
    Parameters:
2128 
     - userId
2129 
     - event
2130 
     - url
2131 
    """
1996 vikas 2132 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2133 
    return self.recv_getTrackLogs()
2134 
 
1996 vikas 2135 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2136 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2137 
    args = getTrackLogs_args()
2138 
    args.userId = userId
2139 
    args.event = event
2140 
    args.url = url
2141 
    args.write(self._oprot)
2142 
    self._oprot.writeMessageEnd()
2143 
    self._oprot.trans.flush()
2144 
 
2145 
  def recv_getTrackLogs(self, ):
2146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2147 
    if mtype == TMessageType.EXCEPTION:
2148 
      x = TApplicationException()
2149 
      x.read(self._iprot)
2150 
      self._iprot.readMessageEnd()
2151 
      raise x
2152 
    result = getTrackLogs_result()
2153 
    result.read(self._iprot)
2154 
    self._iprot.readMessageEnd()
3431 rajveer 2155 
    if result.success is not None:
1845 vikas 2156 
      return result.success
3431 rajveer 2157 
    if result.utx is not None:
1845 vikas 2158 
      raise result.utx
2159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2160 
 
559 chandransh 2161 
  def getCurrentCart(self, userId):
94 ashish 2162 
    """
2163 
    Parameters:
559 chandransh 2164 
     - userId
94 ashish 2165 
    """
559 chandransh 2166 
    self.send_getCurrentCart(userId)
2167 
    return self.recv_getCurrentCart()
94 ashish 2168 
 
559 chandransh 2169 
  def send_getCurrentCart(self, userId):
2170 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2171 
    args = getCurrentCart_args()
2172 
    args.userId = userId
94 ashish 2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
559 chandransh 2177 
  def recv_getCurrentCart(self, ):
94 ashish 2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
559 chandransh 2184 
    result = getCurrentCart_result()
94 ashish 2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
3431 rajveer 2187 
    if result.success is not None:
94 ashish 2188 
      return result.success
3431 rajveer 2189 
    if result.scx is not None:
559 chandransh 2190 
      raise result.scx
2191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2192 
 
559 chandransh 2193 
  def getCart(self, cartId):
94 ashish 2194 
    """
2195 
    Parameters:
559 chandransh 2196 
     - cartId
94 ashish 2197 
    """
559 chandransh 2198 
    self.send_getCart(cartId)
2199 
    return self.recv_getCart()
94 ashish 2200 
 
559 chandransh 2201 
  def send_getCart(self, cartId):
2202 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2203 
    args = getCart_args()
2204 
    args.cartId = cartId
94 ashish 2205 
    args.write(self._oprot)
2206 
    self._oprot.writeMessageEnd()
2207 
    self._oprot.trans.flush()
2208 
 
559 chandransh 2209 
  def recv_getCart(self, ):
94 ashish 2210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2211 
    if mtype == TMessageType.EXCEPTION:
2212 
      x = TApplicationException()
2213 
      x.read(self._iprot)
2214 
      self._iprot.readMessageEnd()
2215 
      raise x
559 chandransh 2216 
    result = getCart_result()
94 ashish 2217 
    result.read(self._iprot)
2218 
    self._iprot.readMessageEnd()
3431 rajveer 2219 
    if result.success is not None:
94 ashish 2220 
      return result.success
3431 rajveer 2221 
    if result.scx is not None:
559 chandransh 2222 
      raise result.scx
2223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2224 
 
559 chandransh 2225 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2226 
    """
2227 
    Parameters:
559 chandransh 2228 
     - from_time
2229 
     - to_time
2230 
     - status
94 ashish 2231 
    """
559 chandransh 2232 
    self.send_getCartsByTime(from_time, to_time, status)
2233 
    return self.recv_getCartsByTime()
94 ashish 2234 
 
559 chandransh 2235 
  def send_getCartsByTime(self, from_time, to_time, status):
2236 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2237 
    args = getCartsByTime_args()
2238 
    args.from_time = from_time
2239 
    args.to_time = to_time
2240 
    args.status = status
94 ashish 2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
559 chandransh 2245 
  def recv_getCartsByTime(self, ):
94 ashish 2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
559 chandransh 2252 
    result = getCartsByTime_result()
94 ashish 2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
3431 rajveer 2255 
    if result.success is not None:
94 ashish 2256 
      return result.success
3431 rajveer 2257 
    if result.scx is not None:
559 chandransh 2258 
      raise result.scx
2259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2260 
 
3557 rajveer 2261 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2262 
    """
2263 
    Parameters:
2264 
     - cartId
2265 
     - itemId
2266 
     - quantity
3557 rajveer 2267 
     - sourceId
559 chandransh 2268 
    """
3557 rajveer 2269 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2270 
    return self.recv_addItemToCart()
559 chandransh 2271 
 
3557 rajveer 2272 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2273 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2274 
    args = addItemToCart_args()
2275 
    args.cartId = cartId
2276 
    args.itemId = itemId
2277 
    args.quantity = quantity
3557 rajveer 2278 
    args.sourceId = sourceId
559 chandransh 2279 
    args.write(self._oprot)
2280 
    self._oprot.writeMessageEnd()
2281 
    self._oprot.trans.flush()
2282 
 
2283 
  def recv_addItemToCart(self, ):
2284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2285 
    if mtype == TMessageType.EXCEPTION:
2286 
      x = TApplicationException()
2287 
      x.read(self._iprot)
2288 
      self._iprot.readMessageEnd()
2289 
      raise x
2290 
    result = addItemToCart_result()
2291 
    result.read(self._iprot)
2292 
    self._iprot.readMessageEnd()
3431 rajveer 2293 
    if result.success is not None:
2035 rajveer 2294 
      return result.success
3431 rajveer 2295 
    if result.scx is not None:
559 chandransh 2296 
      raise result.scx
2035 rajveer 2297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2298 
 
2299 
  def deleteItemFromCart(self, cartId, itemId):
2300 
    """
2301 
    Parameters:
2302 
     - cartId
2303 
     - itemId
2304 
    """
2305 
    self.send_deleteItemFromCart(cartId, itemId)
2306 
    self.recv_deleteItemFromCart()
2307 
 
2308 
  def send_deleteItemFromCart(self, cartId, itemId):
2309 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2310 
    args = deleteItemFromCart_args()
2311 
    args.cartId = cartId
2312 
    args.itemId = itemId
2313 
    args.write(self._oprot)
2314 
    self._oprot.writeMessageEnd()
2315 
    self._oprot.trans.flush()
2316 
 
2317 
  def recv_deleteItemFromCart(self, ):
2318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2319 
    if mtype == TMessageType.EXCEPTION:
2320 
      x = TApplicationException()
2321 
      x.read(self._iprot)
2322 
      self._iprot.readMessageEnd()
2323 
      raise x
2324 
    result = deleteItemFromCart_result()
2325 
    result.read(self._iprot)
2326 
    self._iprot.readMessageEnd()
3431 rajveer 2327 
    if result.scx is not None:
559 chandransh 2328 
      raise result.scx
2329 
    return
2330 
 
2331 
  def addAddressToCart(self, cartId, addressId):
2332 
    """
2333 
    Parameters:
2334 
     - cartId
2335 
     - addressId
2336 
    """
2337 
    self.send_addAddressToCart(cartId, addressId)
2338 
    self.recv_addAddressToCart()
2339 
 
2340 
  def send_addAddressToCart(self, cartId, addressId):
2341 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2342 
    args = addAddressToCart_args()
2343 
    args.cartId = cartId
2344 
    args.addressId = addressId
2345 
    args.write(self._oprot)
2346 
    self._oprot.writeMessageEnd()
2347 
    self._oprot.trans.flush()
2348 
 
2349 
  def recv_addAddressToCart(self, ):
2350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2351 
    if mtype == TMessageType.EXCEPTION:
2352 
      x = TApplicationException()
2353 
      x.read(self._iprot)
2354 
      self._iprot.readMessageEnd()
2355 
      raise x
2356 
    result = addAddressToCart_result()
2357 
    result.read(self._iprot)
2358 
    self._iprot.readMessageEnd()
3431 rajveer 2359 
    if result.scx is not None:
575 chandransh 2360 
      raise result.scx
559 chandransh 2361 
    return
2362 
 
5553 rajveer 2363 
  def addStoreToCart(self, cartId, storeId):
2364 
    """
2365 
    Parameters:
2366 
     - cartId
2367 
     - storeId
2368 
    """
2369 
    self.send_addStoreToCart(cartId, storeId)
2370 
    self.recv_addStoreToCart()
2371 
 
2372 
  def send_addStoreToCart(self, cartId, storeId):
2373 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2374 
    args = addStoreToCart_args()
2375 
    args.cartId = cartId
2376 
    args.storeId = storeId
2377 
    args.write(self._oprot)
2378 
    self._oprot.writeMessageEnd()
2379 
    self._oprot.trans.flush()
2380 
 
2381 
  def recv_addStoreToCart(self, ):
2382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2383 
    if mtype == TMessageType.EXCEPTION:
2384 
      x = TApplicationException()
2385 
      x.read(self._iprot)
2386 
      self._iprot.readMessageEnd()
2387 
      raise x
2388 
    result = addStoreToCart_result()
2389 
    result.read(self._iprot)
2390 
    self._iprot.readMessageEnd()
2391 
    if result.scx is not None:
2392 
      raise result.scx
2393 
    return
2394 
 
6922 anupam.sin 2395 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2396 
    """
2397 
    Parameters:
6922 anupam.sin 2398 
     - cart
1976 varun.gupt 2399 
     - couponCode
2400 
    """
6922 anupam.sin 2401 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2402 
    self.recv_applyCouponToCart()
2403 
 
6922 anupam.sin 2404 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2405 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2406 
    args = applyCouponToCart_args()
6922 anupam.sin 2407 
    args.cart = cart
1976 varun.gupt 2408 
    args.couponCode = couponCode
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_applyCouponToCart(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = applyCouponToCart_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
3431 rajveer 2423 
    if result.scx is not None:
1976 varun.gupt 2424 
      raise result.scx
2425 
    return
2426 
 
2427 
  def removeCoupon(self, cartId):
2428 
    """
2429 
    Parameters:
2430 
     - cartId
2431 
    """
2432 
    self.send_removeCoupon(cartId)
2433 
    self.recv_removeCoupon()
2434 
 
2435 
  def send_removeCoupon(self, cartId):
2436 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2437 
    args = removeCoupon_args()
2438 
    args.cartId = cartId
2439 
    args.write(self._oprot)
2440 
    self._oprot.writeMessageEnd()
2441 
    self._oprot.trans.flush()
2442 
 
2443 
  def recv_removeCoupon(self, ):
2444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2445 
    if mtype == TMessageType.EXCEPTION:
2446 
      x = TApplicationException()
2447 
      x.read(self._iprot)
2448 
      self._iprot.readMessageEnd()
2449 
      raise x
2450 
    result = removeCoupon_result()
2451 
    result.read(self._iprot)
2452 
    self._iprot.readMessageEnd()
3431 rajveer 2453 
    if result.scx is not None:
1976 varun.gupt 2454 
      raise result.scx
2455 
    return
2456 
 
3554 varun.gupt 2457 
  def deleteDiscountsFromCart(self, cartId):
2458 
    """
2459 
    Deletes all the discounts associated with the cart
2460 
 
2461 
    Parameters:
2462 
     - cartId
2463 
    """
2464 
    self.send_deleteDiscountsFromCart(cartId)
2465 
    self.recv_deleteDiscountsFromCart()
2466 
 
2467 
  def send_deleteDiscountsFromCart(self, cartId):
2468 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2469 
    args = deleteDiscountsFromCart_args()
2470 
    args.cartId = cartId
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_deleteDiscountsFromCart(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = deleteDiscountsFromCart_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    if result.scx is not None:
2486 
      raise result.scx
2487 
    return
2488 
 
2489 
  def saveDiscounts(self, discounts):
2490 
    """
2491 
    Accepts a list of thrift objects of Discount type and saves them
2492 
 
2493 
    Parameters:
2494 
     - discounts
2495 
    """
2496 
    self.send_saveDiscounts(discounts)
2497 
    self.recv_saveDiscounts()
2498 
 
2499 
  def send_saveDiscounts(self, discounts):
2500 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2501 
    args = saveDiscounts_args()
2502 
    args.discounts = discounts
2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_saveDiscounts(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = saveDiscounts_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
2517 
    if result.scx is not None:
2518 
      raise result.scx
2519 
    return
2520 
 
21454 amit.gupta 2521 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 2522 
    """
690 chandransh 2523 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2524 
 
559 chandransh 2525 
    Parameters:
2526 
     - cartId
2815 vikas 2527 
     - sessionSource
2528 
     - sessionStartTime
3858 vikas 2529 
     - firstSource
2530 
     - firstSourceTime
5326 rajveer 2531 
     - userId
6389 rajveer 2532 
     - schemeId
11526 amit.gupta 2533 
     - orderSource
21454 amit.gupta 2534 
     - selfPickup
559 chandransh 2535 
    """
21454 amit.gupta 2536 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup)
690 chandransh 2537 
    return self.recv_createOrders()
559 chandransh 2538 
 
21454 amit.gupta 2539 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
690 chandransh 2540 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2541 
    args = createOrders_args()
559 chandransh 2542 
    args.cartId = cartId
2815 vikas 2543 
    args.sessionSource = sessionSource
2544 
    args.sessionStartTime = sessionStartTime
3858 vikas 2545 
    args.firstSource = firstSource
2546 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2547 
    args.userId = userId
6389 rajveer 2548 
    args.schemeId = schemeId
11526 amit.gupta 2549 
    args.orderSource = orderSource
21454 amit.gupta 2550 
    args.selfPickup = selfPickup
559 chandransh 2551 
    args.write(self._oprot)
2552 
    self._oprot.writeMessageEnd()
2553 
    self._oprot.trans.flush()
2554 
 
690 chandransh 2555 
  def recv_createOrders(self, ):
559 chandransh 2556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2557 
    if mtype == TMessageType.EXCEPTION:
2558 
      x = TApplicationException()
2559 
      x.read(self._iprot)
2560 
      self._iprot.readMessageEnd()
2561 
      raise x
690 chandransh 2562 
    result = createOrders_result()
559 chandransh 2563 
    result.read(self._iprot)
2564 
    self._iprot.readMessageEnd()
3431 rajveer 2565 
    if result.success is not None:
130 ashish 2566 
      return result.success
3431 rajveer 2567 
    if result.scx is not None:
559 chandransh 2568 
      raise result.scx
690 chandransh 2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2570 
 
3557 rajveer 2571 
  def validateCart(self, cartId, sourceId):
130 ashish 2572 
    """
690 chandransh 2573 
    Validates that:
2574 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2575 
    2. All of the lines in the cart are active items.
690 chandransh 2576 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2577 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2578 
 
130 ashish 2579 
    Parameters:
559 chandransh 2580 
     - cartId
3557 rajveer 2581 
     - sourceId
130 ashish 2582 
    """
3557 rajveer 2583 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2584 
    return self.recv_validateCart()
130 ashish 2585 
 
3557 rajveer 2586 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2587 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2588 
    args = validateCart_args()
2589 
    args.cartId = cartId
3557 rajveer 2590 
    args.sourceId = sourceId
130 ashish 2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
559 chandransh 2595 
  def recv_validateCart(self, ):
130 ashish 2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
559 chandransh 2602 
    result = validateCart_result()
130 ashish 2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
3431 rajveer 2605 
    if result.success is not None:
130 ashish 2606 
      return result.success
3431 rajveer 2607 
    if result.scex is not None:
575 chandransh 2608 
      raise result.scex
559 chandransh 2609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2610 
 
11980 amit.gupta 2611 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2612 
    """
2613 
    Validates that:
2614 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2615 
    2. All of the lines in the cart are active items.
2616 
    3. The estimate for any of the lines in cart doesn't change.
2617 
    If all three are true, returns empty string; else returns appropriate message.
2618 
 
2619 
    Parameters:
2620 
     - cartId
2621 
     - sourceId
2622 
     - dealCoupon
2623 
    """
2624 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2625 
    return self.recv_validateCartWithDealerCoupon()
2626 
 
2627 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2628 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2629 
    args = validateCartWithDealerCoupon_args()
2630 
    args.cartId = cartId
2631 
    args.sourceId = sourceId
2632 
    args.dealCoupon = dealCoupon
2633 
    args.write(self._oprot)
2634 
    self._oprot.writeMessageEnd()
2635 
    self._oprot.trans.flush()
2636 
 
2637 
  def recv_validateCartWithDealerCoupon(self, ):
2638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2639 
    if mtype == TMessageType.EXCEPTION:
2640 
      x = TApplicationException()
2641 
      x.read(self._iprot)
2642 
      self._iprot.readMessageEnd()
2643 
      raise x
2644 
    result = validateCartWithDealerCoupon_result()
2645 
    result.read(self._iprot)
2646 
    self._iprot.readMessageEnd()
2647 
    if result.success is not None:
2648 
      return result.success
2649 
    if result.scex is not None:
2650 
      raise result.scex
2651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2652 
 
690 chandransh 2653 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2654 
    """
690 chandransh 2655 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2656 
 
575 chandransh 2657 
    Parameters:
690 chandransh 2658 
     - fromCartId
2659 
     - toCartId
2660 
    """
2661 
    self.send_mergeCart(fromCartId, toCartId)
2662 
    self.recv_mergeCart()
2663 
 
2664 
  def send_mergeCart(self, fromCartId, toCartId):
2665 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2666 
    args = mergeCart_args()
2667 
    args.fromCartId = fromCartId
2668 
    args.toCartId = toCartId
2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2673 
  def recv_mergeCart(self, ):
2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2680 
    result = mergeCart_result()
2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
2683 
    return
2684 
 
2685 
  def checkOut(self, cartId):
2686 
    """
2687 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2688 
 
690 chandransh 2689 
    Parameters:
575 chandransh 2690 
     - cartId
2691 
    """
690 chandransh 2692 
    self.send_checkOut(cartId)
2693 
    return self.recv_checkOut()
575 chandransh 2694 
 
690 chandransh 2695 
  def send_checkOut(self, cartId):
2696 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2697 
    args = checkOut_args()
575 chandransh 2698 
    args.cartId = cartId
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
690 chandransh 2703 
  def recv_checkOut(self, ):
575 chandransh 2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
690 chandransh 2710 
    result = checkOut_result()
575 chandransh 2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
3431 rajveer 2713 
    if result.success is not None:
575 chandransh 2714 
      return result.success
3431 rajveer 2715 
    if result.scex is not None:
575 chandransh 2716 
      raise result.scex
690 chandransh 2717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2718 
 
690 chandransh 2719 
  def resetCart(self, cartId, items):
559 chandransh 2720 
    """
690 chandransh 2721 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2722 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2723 
 
559 chandransh 2724 
    Parameters:
690 chandransh 2725 
     - cartId
2726 
     - items
559 chandransh 2727 
    """
690 chandransh 2728 
    self.send_resetCart(cartId, items)
2729 
    return self.recv_resetCart()
130 ashish 2730 
 
690 chandransh 2731 
  def send_resetCart(self, cartId, items):
2732 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2733 
    args = resetCart_args()
2734 
    args.cartId = cartId
2735 
    args.items = items
559 chandransh 2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
690 chandransh 2740 
  def recv_resetCart(self, ):
559 chandransh 2741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2742 
    if mtype == TMessageType.EXCEPTION:
2743 
      x = TApplicationException()
2744 
      x.read(self._iprot)
2745 
      self._iprot.readMessageEnd()
2746 
      raise x
690 chandransh 2747 
    result = resetCart_result()
559 chandransh 2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
3431 rajveer 2750 
    if result.success is not None:
690 chandransh 2751 
      return result.success
3431 rajveer 2752 
    if result.scex is not None:
690 chandransh 2753 
      raise result.scex
2754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2755 
 
2981 rajveer 2756 
  def getUserCount(self, userType):
559 chandransh 2757 
    """
2981 rajveer 2758 
    Returns number of registered users.
2759 
    If userType = null, then it returns count of all users, including anonymous
2760 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2761 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2762 
 
559 chandransh 2763 
    Parameters:
2981 rajveer 2764 
     - userType
559 chandransh 2765 
    """
2981 rajveer 2766 
    self.send_getUserCount(userType)
2767 
    return self.recv_getUserCount()
559 chandransh 2768 
 
2981 rajveer 2769 
  def send_getUserCount(self, userType):
2770 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2771 
    args = getUserCount_args()
2772 
    args.userType = userType
559 chandransh 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2981 rajveer 2777 
  def recv_getUserCount(self, ):
559 chandransh 2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2981 rajveer 2784 
    result = getUserCount_result()
559 chandransh 2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
3431 rajveer 2787 
    if result.success is not None:
559 chandransh 2788 
      return result.success
2981 rajveer 2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2790 
 
2981 rajveer 2791 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2792 
    """
2981 rajveer 2793 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2794 
    If any of startDate or endDate is -1, then that filter is ignored.
2795 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2796 
 
2797 
 
559 chandransh 2798 
    Parameters:
2981 rajveer 2799 
     - userType
2800 
     - startDate
2801 
     - endDate
559 chandransh 2802 
    """
2981 rajveer 2803 
    self.send_getAllUsers(userType, startDate, endDate)
2804 
    return self.recv_getAllUsers()
559 chandransh 2805 
 
2981 rajveer 2806 
  def send_getAllUsers(self, userType, startDate, endDate):
2807 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2808 
    args = getAllUsers_args()
2809 
    args.userType = userType
2810 
    args.startDate = startDate
2811 
    args.endDate = endDate
559 chandransh 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
2981 rajveer 2816 
  def recv_getAllUsers(self, ):
559 chandransh 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
2981 rajveer 2823 
    result = getAllUsers_result()
559 chandransh 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
3431 rajveer 2826 
    if result.success is not None:
559 chandransh 2827 
      return result.success
2981 rajveer 2828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2829 
 
2981 rajveer 2830 
  def getMyResearchItems(self, userId):
559 chandransh 2831 
    """
2981 rajveer 2832 
    Returns list of item ids in myresearch for the user
3431 rajveer 2833 
 
559 chandransh 2834 
    Parameters:
772 rajveer 2835 
     - userId
559 chandransh 2836 
    """
2981 rajveer 2837 
    self.send_getMyResearchItems(userId)
2838 
    return self.recv_getMyResearchItems()
559 chandransh 2839 
 
2981 rajveer 2840 
  def send_getMyResearchItems(self, userId):
2841 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2842 
    args = getMyResearchItems_args()
772 rajveer 2843 
    args.userId = userId
559 chandransh 2844 
    args.write(self._oprot)
2845 
    self._oprot.writeMessageEnd()
2846 
    self._oprot.trans.flush()
2847 
 
2981 rajveer 2848 
  def recv_getMyResearchItems(self, ):
559 chandransh 2849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2850 
    if mtype == TMessageType.EXCEPTION:
2851 
      x = TApplicationException()
2852 
      x.read(self._iprot)
2853 
      self._iprot.readMessageEnd()
2854 
      raise x
2981 rajveer 2855 
    result = getMyResearchItems_result()
559 chandransh 2856 
    result.read(self._iprot)
2857 
    self._iprot.readMessageEnd()
3431 rajveer 2858 
    if result.success is not None:
559 chandransh 2859 
      return result.success
3431 rajveer 2860 
    if result.scx is not None:
559 chandransh 2861 
      raise result.scx
2981 rajveer 2862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2863 
 
2981 rajveer 2864 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2865 
    """
2981 rajveer 2866 
    add item to my research for a user
3431 rajveer 2867 
 
559 chandransh 2868 
    Parameters:
2981 rajveer 2869 
     - userId
2870 
     - itemId
559 chandransh 2871 
    """
2981 rajveer 2872 
    self.send_updateMyResearch(userId, itemId)
2873 
    return self.recv_updateMyResearch()
559 chandransh 2874 
 
2981 rajveer 2875 
  def send_updateMyResearch(self, userId, itemId):
2876 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2877 
    args = updateMyResearch_args()
2878 
    args.userId = userId
2879 
    args.itemId = itemId
559 chandransh 2880 
    args.write(self._oprot)
2881 
    self._oprot.writeMessageEnd()
2882 
    self._oprot.trans.flush()
2883 
 
2981 rajveer 2884 
  def recv_updateMyResearch(self, ):
559 chandransh 2885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2886 
    if mtype == TMessageType.EXCEPTION:
2887 
      x = TApplicationException()
2888 
      x.read(self._iprot)
2889 
      self._iprot.readMessageEnd()
2890 
      raise x
2981 rajveer 2891 
    result = updateMyResearch_result()
559 chandransh 2892 
    result.read(self._iprot)
2893 
    self._iprot.readMessageEnd()
3431 rajveer 2894 
    if result.success is not None:
2981 rajveer 2895 
      return result.success
3431 rajveer 2896 
    if result.scx is not None:
2981 rajveer 2897 
      raise result.scx
2898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2899 
 
2981 rajveer 2900 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2901 
    """
2981 rajveer 2902 
    delete item from my research for a user
3431 rajveer 2903 
 
1596 ankur.sing 2904 
    Parameters:
2981 rajveer 2905 
     - userId
2906 
     - itemId
1596 ankur.sing 2907 
    """
2981 rajveer 2908 
    self.send_deleteItemFromMyResearch(userId, itemId)
2909 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2910 
 
2981 rajveer 2911 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2912 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2913 
    args = deleteItemFromMyResearch_args()
2914 
    args.userId = userId
2915 
    args.itemId = itemId
1596 ankur.sing 2916 
    args.write(self._oprot)
2917 
    self._oprot.writeMessageEnd()
2918 
    self._oprot.trans.flush()
2919 
 
2981 rajveer 2920 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2922 
    if mtype == TMessageType.EXCEPTION:
2923 
      x = TApplicationException()
2924 
      x.read(self._iprot)
2925 
      self._iprot.readMessageEnd()
2926 
      raise x
2981 rajveer 2927 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2928 
    result.read(self._iprot)
2929 
    self._iprot.readMessageEnd()
3431 rajveer 2930 
    if result.scx is not None:
2981 rajveer 2931 
      raise result.scx
2932 
    return
1596 ankur.sing 2933 
 
2981 rajveer 2934 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2935 
    """
2981 rajveer 2936 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2937 
 
1673 ankur.sing 2938 
    Parameters:
2981 rajveer 2939 
     - userId
1673 ankur.sing 2940 
    """
2981 rajveer 2941 
    self.send_getBrowseHistoryItems(userId)
2942 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2943 
 
2981 rajveer 2944 
  def send_getBrowseHistoryItems(self, userId):
2945 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2946 
    args = getBrowseHistoryItems_args()
2947 
    args.userId = userId
1673 ankur.sing 2948 
    args.write(self._oprot)
2949 
    self._oprot.writeMessageEnd()
2950 
    self._oprot.trans.flush()
2951 
 
2981 rajveer 2952 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2954 
    if mtype == TMessageType.EXCEPTION:
2955 
      x = TApplicationException()
2956 
      x.read(self._iprot)
2957 
      self._iprot.readMessageEnd()
2958 
      raise x
2981 rajveer 2959 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2960 
    result.read(self._iprot)
2961 
    self._iprot.readMessageEnd()
3431 rajveer 2962 
    if result.success is not None:
1673 ankur.sing 2963 
      return result.success
3431 rajveer 2964 
    if result.scx is not None:
2981 rajveer 2965 
      raise result.scx
2966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2967 
 
2981 rajveer 2968 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2969 
    """
2981 rajveer 2970 
    add item to browse history for a user
3431 rajveer 2971 
 
2642 varun.gupt 2972 
    Parameters:
2981 rajveer 2973 
     - userId
2974 
     - itemId
2642 varun.gupt 2975 
    """
2981 rajveer 2976 
    self.send_updateBrowseHistory(userId, itemId)
2977 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2978 
 
2981 rajveer 2979 
  def send_updateBrowseHistory(self, userId, itemId):
2980 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2981 
    args = updateBrowseHistory_args()
2982 
    args.userId = userId
2983 
    args.itemId = itemId
2642 varun.gupt 2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
2981 rajveer 2988 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
2981 rajveer 2995 
    result = updateBrowseHistory_result()
2642 varun.gupt 2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
2998 
    return
2999 
 
3385 varun.gupt 3000 
  def getCartsWithCouponCount(self, couponCode):
3001 
    """
3002 
    Returns count of Carts with given coupon applied
3431 rajveer 3003 
 
3385 varun.gupt 3004 
    Parameters:
3005 
     - couponCode
3006 
    """
3007 
    self.send_getCartsWithCouponCount(couponCode)
3008 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 3009 
 
3385 varun.gupt 3010 
  def send_getCartsWithCouponCount(self, couponCode):
3011 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
3012 
    args = getCartsWithCouponCount_args()
3013 
    args.couponCode = couponCode
3014 
    args.write(self._oprot)
3015 
    self._oprot.writeMessageEnd()
3016 
    self._oprot.trans.flush()
3017 
 
3018 
  def recv_getCartsWithCouponCount(self, ):
3019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3020 
    if mtype == TMessageType.EXCEPTION:
3021 
      x = TApplicationException()
3022 
      x.read(self._iprot)
3023 
      self._iprot.readMessageEnd()
3024 
      raise x
3025 
    result = getCartsWithCouponCount_result()
3026 
    result.read(self._iprot)
3027 
    self._iprot.readMessageEnd()
3431 rajveer 3028 
    if result.success is not None:
3385 varun.gupt 3029 
      return result.success
3030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
3031 
 
3499 mandeep.dh 3032 
  def increaseTrustLevel(self, userId, trustLevelDelta):
3033 
    """
3034 
    Updates COD trust level of a user
3385 varun.gupt 3035 
 
3499 mandeep.dh 3036 
    Parameters:
3037 
     - userId
3038 
     - trustLevelDelta
3039 
    """
3040 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
3041 
 
3042 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
3043 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
3044 
    args = increaseTrustLevel_args()
3045 
    args.userId = userId
3046 
    args.trustLevelDelta = trustLevelDelta
3047 
    args.write(self._oprot)
3048 
    self._oprot.writeMessageEnd()
3049 
    self._oprot.trans.flush()
5407 amar.kumar 3050 
  def getTrustLevel(self, userId):
3051 
    """
3052 
    Get trust level of a user
3053 
 
3054 
    Parameters:
3055 
     - userId
3056 
    """
3057 
    self.send_getTrustLevel(userId)
3058 
    return self.recv_getTrustLevel()
3059 
 
3060 
  def send_getTrustLevel(self, userId):
3061 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3062 
    args = getTrustLevel_args()
3063 
    args.userId = userId
3064 
    args.write(self._oprot)
3065 
    self._oprot.writeMessageEnd()
3066 
    self._oprot.trans.flush()
3067 
 
3068 
  def recv_getTrustLevel(self, ):
3069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3070 
    if mtype == TMessageType.EXCEPTION:
3071 
      x = TApplicationException()
3072 
      x.read(self._iprot)
3073 
      self._iprot.readMessageEnd()
3074 
      raise x
3075 
    result = getTrustLevel_result()
3076 
    result.read(self._iprot)
3077 
    self._iprot.readMessageEnd()
3078 
    if result.success is not None:
3079 
      return result.success
3080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3081 
 
4668 varun.gupt 3082 
  def showCODOption(self, cartId, sourceId, pincode):
3083 
    """
3084 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3085 
 
4668 varun.gupt 3086 
    Parameters:
3087 
     - cartId
3088 
     - sourceId
3089 
     - pincode
3090 
    """
3091 
    self.send_showCODOption(cartId, sourceId, pincode)
3092 
    return self.recv_showCODOption()
3093 
 
3094 
  def send_showCODOption(self, cartId, sourceId, pincode):
3095 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3096 
    args = showCODOption_args()
3097 
    args.cartId = cartId
3098 
    args.sourceId = sourceId
3099 
    args.pincode = pincode
3100 
    args.write(self._oprot)
3101 
    self._oprot.writeMessageEnd()
3102 
    self._oprot.trans.flush()
3103 
 
3104 
  def recv_showCODOption(self, ):
3105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3106 
    if mtype == TMessageType.EXCEPTION:
3107 
      x = TApplicationException()
3108 
      x.read(self._iprot)
3109 
      self._iprot.readMessageEnd()
3110 
      raise x
3111 
    result = showCODOption_result()
3112 
    result.read(self._iprot)
3113 
    self._iprot.readMessageEnd()
3114 
    if result.success is not None:
3115 
      return result.success
3116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3117 
 
5623 anupam.sin 3118 
  def getUserEmails(self, startDate, endDate):
3119 
    """
3120 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3121 
 
5623 anupam.sin 3122 
    Parameters:
3123 
     - startDate
3124 
     - endDate
3125 
    """
3126 
    self.send_getUserEmails(startDate, endDate)
3127 
    return self.recv_getUserEmails()
3128 
 
3129 
  def send_getUserEmails(self, startDate, endDate):
3130 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3131 
    args = getUserEmails_args()
3132 
    args.startDate = startDate
3133 
    args.endDate = endDate
3134 
    args.write(self._oprot)
3135 
    self._oprot.writeMessageEnd()
3136 
    self._oprot.trans.flush()
3137 
 
3138 
  def recv_getUserEmails(self, ):
3139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3140 
    if mtype == TMessageType.EXCEPTION:
3141 
      x = TApplicationException()
3142 
      x.read(self._iprot)
3143 
      self._iprot.readMessageEnd()
3144 
      raise x
3145 
    result = getUserEmails_result()
3146 
    result.read(self._iprot)
3147 
    self._iprot.readMessageEnd()
3148 
    if result.success is not None:
3149 
      return result.success
3150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3151 
 
9299 kshitij.so 3152 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3153 
    """
3154 
    Mark a cart lineitem as insured. Returns true/false.
3155 
 
3156 
    Parameters:
3157 
     - itemId
3158 
     - cartId
3159 
     - toInsure
9299 kshitij.so 3160 
     - insurerType
6903 anupam.sin 3161 
    """
9299 kshitij.so 3162 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3163 
    return self.recv_insureItem()
3164 
 
9299 kshitij.so 3165 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3166 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3167 
    args = insureItem_args()
3168 
    args.itemId = itemId
3169 
    args.cartId = cartId
3170 
    args.toInsure = toInsure
9299 kshitij.so 3171 
    args.insurerType = insurerType
6903 anupam.sin 3172 
    args.write(self._oprot)
3173 
    self._oprot.writeMessageEnd()
3174 
    self._oprot.trans.flush()
3175 
 
3176 
  def recv_insureItem(self, ):
3177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3178 
    if mtype == TMessageType.EXCEPTION:
3179 
      x = TApplicationException()
3180 
      x.read(self._iprot)
3181 
      self._iprot.readMessageEnd()
3182 
      raise x
3183 
    result = insureItem_result()
3184 
    result.read(self._iprot)
3185 
    self._iprot.readMessageEnd()
3186 
    if result.success is not None:
3187 
      return result.success
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3189 
 
3190 
  def cancelInsurance(self, cartId):
3191 
    """
3192 
    Cancel insurance for all items in the cart
3193 
 
3194 
    Parameters:
3195 
     - cartId
3196 
    """
3197 
    self.send_cancelInsurance(cartId)
3198 
    return self.recv_cancelInsurance()
3199 
 
3200 
  def send_cancelInsurance(self, cartId):
3201 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3202 
    args = cancelInsurance_args()
3203 
    args.cartId = cartId
3204 
    args.write(self._oprot)
3205 
    self._oprot.writeMessageEnd()
3206 
    self._oprot.trans.flush()
3207 
 
3208 
  def recv_cancelInsurance(self, ):
3209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3210 
    if mtype == TMessageType.EXCEPTION:
3211 
      x = TApplicationException()
3212 
      x.read(self._iprot)
3213 
      self._iprot.readMessageEnd()
3214 
      raise x
3215 
    result = cancelInsurance_result()
3216 
    result.read(self._iprot)
3217 
    self._iprot.readMessageEnd()
3218 
    if result.success is not None:
3219 
      return result.success
3220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3221 
 
3222 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3223 
    """
3224 
    Stores insurance specific details like date of birth and guardianName
3225 
 
3226 
    Parameters:
3227 
     - addressId
3228 
     - dob
3229 
     - guardianName
3230 
    """
3231 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3232 
    return self.recv_storeInsuranceSpecificDetails()
3233 
 
3234 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3235 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3236 
    args = storeInsuranceSpecificDetails_args()
3237 
    args.addressId = addressId
3238 
    args.dob = dob
3239 
    args.guardianName = guardianName
3240 
    args.write(self._oprot)
3241 
    self._oprot.writeMessageEnd()
3242 
    self._oprot.trans.flush()
3243 
 
3244 
  def recv_storeInsuranceSpecificDetails(self, ):
3245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3246 
    if mtype == TMessageType.EXCEPTION:
3247 
      x = TApplicationException()
3248 
      x.read(self._iprot)
3249 
      self._iprot.readMessageEnd()
3250 
      raise x
3251 
    result = storeInsuranceSpecificDetails_result()
3252 
    result.read(self._iprot)
3253 
    self._iprot.readMessageEnd()
3254 
    if result.success is not None:
3255 
      return result.success
3256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3257 
 
3258 
  def isInsuranceDetailPresent(self, addressId):
3259 
    """
3260 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3261 
 
3262 
    Parameters:
3263 
     - addressId
3264 
    """
3265 
    self.send_isInsuranceDetailPresent(addressId)
3266 
    return self.recv_isInsuranceDetailPresent()
3267 
 
3268 
  def send_isInsuranceDetailPresent(self, addressId):
3269 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3270 
    args = isInsuranceDetailPresent_args()
3271 
    args.addressId = addressId
3272 
    args.write(self._oprot)
3273 
    self._oprot.writeMessageEnd()
3274 
    self._oprot.trans.flush()
3275 
 
3276 
  def recv_isInsuranceDetailPresent(self, ):
3277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3278 
    if mtype == TMessageType.EXCEPTION:
3279 
      x = TApplicationException()
3280 
      x.read(self._iprot)
3281 
      self._iprot.readMessageEnd()
3282 
      raise x
3283 
    result = isInsuranceDetailPresent_result()
3284 
    result.read(self._iprot)
3285 
    self._iprot.readMessageEnd()
3286 
    if result.success is not None:
3287 
      return result.success
3288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3289 
 
9791 rajveer 3290 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3291 
    """
9791 rajveer 3292 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3293 
 
6821 amar.kumar 3294 
    Parameters:
3295 
     - startDate
3296 
     - endDate
3297 
    """
9791 rajveer 3298 
    self.send_getProductsAddedToCart(startDate, endDate)
3299 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3300 
 
9791 rajveer 3301 
  def send_getProductsAddedToCart(self, startDate, endDate):
3302 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3303 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3304 
    args.startDate = startDate
3305 
    args.endDate = endDate
3306 
    args.write(self._oprot)
3307 
    self._oprot.writeMessageEnd()
3308 
    self._oprot.trans.flush()
3309 
 
9791 rajveer 3310 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3312 
    if mtype == TMessageType.EXCEPTION:
3313 
      x = TApplicationException()
3314 
      x.read(self._iprot)
3315 
      self._iprot.readMessageEnd()
3316 
      raise x
9791 rajveer 3317 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3318 
    result.read(self._iprot)
3319 
    self._iprot.readMessageEnd()
3320 
    if result.success is not None:
3321 
      return result.success
9791 rajveer 3322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3323 
 
11980 amit.gupta 3324 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3325 
    """
3326 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3327 
 
11592 amit.gupta 3328 
    Parameters:
3329 
     - cartId
3330 
     - sourceId
11980 amit.gupta 3331 
     - dealerCoupon
11592 amit.gupta 3332 
    """
11980 amit.gupta 3333 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3334 
    return self.recv_validateCartPlus()
3335 
 
11980 amit.gupta 3336 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3337 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3338 
    args = validateCartPlus_args()
3339 
    args.cartId = cartId
3340 
    args.sourceId = sourceId
11980 amit.gupta 3341 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_validateCartPlus(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = validateCartPlus_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    if result.success is not None:
3357 
      return result.success
3358 
    if result.scex is not None:
3359 
      raise result.scex
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3361 
 
11679 vikram.rag 3362 
  def isPrivateDealUser(self, userId):
3363 
    """
3364 
    Parameters:
3365 
     - userId
3366 
    """
3367 
    self.send_isPrivateDealUser(userId)
3368 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3369 
 
11679 vikram.rag 3370 
  def send_isPrivateDealUser(self, userId):
3371 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3372 
    args = isPrivateDealUser_args()
3373 
    args.userId = userId
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_isPrivateDealUser(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 = isPrivateDealUser_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, "isPrivateDealUser failed: unknown result");
3391 
 
11890 kshitij.so 3392 
  def addPrivateDealUser(self, userId):
3393 
    """
3394 
    Parameters:
3395 
     - userId
3396 
    """
3397 
    self.send_addPrivateDealUser(userId)
3398 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3399 
 
11890 kshitij.so 3400 
  def send_addPrivateDealUser(self, userId):
3401 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3402 
    args = addPrivateDealUser_args()
3403 
    args.userId = userId
3404 
    args.write(self._oprot)
3405 
    self._oprot.writeMessageEnd()
3406 
    self._oprot.trans.flush()
3407 
 
3408 
  def recv_addPrivateDealUser(self, ):
3409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3410 
    if mtype == TMessageType.EXCEPTION:
3411 
      x = TApplicationException()
3412 
      x.read(self._iprot)
3413 
      self._iprot.readMessageEnd()
3414 
      raise x
3415 
    result = addPrivateDealUser_result()
3416 
    result.read(self._iprot)
3417 
    self._iprot.readMessageEnd()
3418 
    if result.success is not None:
3419 
      return result.success
3420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3421 
 
3422 
  def changePrivateDealUserStatus(self, userId, isActive):
3423 
    """
3424 
    Parameters:
3425 
     - userId
3426 
     - isActive
3427 
    """
3428 
    self.send_changePrivateDealUserStatus(userId, isActive)
3429 
    return self.recv_changePrivateDealUserStatus()
3430 
 
3431 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3432 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3433 
    args = changePrivateDealUserStatus_args()
3434 
    args.userId = userId
3435 
    args.isActive = isActive
3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
3440 
  def recv_changePrivateDealUserStatus(self, ):
3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
3447 
    result = changePrivateDealUserStatus_result()
3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3450 
    if result.success is not None:
3451 
      return result.success
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3453 
 
3454 
  def getPrivateDealUser(self, userId):
3455 
    """
3456 
    Parameters:
3457 
     - userId
3458 
    """
3459 
    self.send_getPrivateDealUser(userId)
3460 
    return self.recv_getPrivateDealUser()
3461 
 
3462 
  def send_getPrivateDealUser(self, userId):
3463 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3464 
    args = getPrivateDealUser_args()
3465 
    args.userId = userId
3466 
    args.write(self._oprot)
3467 
    self._oprot.writeMessageEnd()
3468 
    self._oprot.trans.flush()
3469 
 
3470 
  def recv_getPrivateDealUser(self, ):
3471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3472 
    if mtype == TMessageType.EXCEPTION:
3473 
      x = TApplicationException()
3474 
      x.read(self._iprot)
3475 
      self._iprot.readMessageEnd()
3476 
      raise x
3477 
    result = getPrivateDealUser_result()
3478 
    result.read(self._iprot)
3479 
    self._iprot.readMessageEnd()
3480 
    if result.success is not None:
3481 
      return result.success
3482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3483 
 
12696 amit.gupta 3484 
  def registerCounter(self, counter, userId):
3485 
    """
3486 
    Parameters:
3487 
     - counter
3488 
     - userId
3489 
    """
3490 
    self.send_registerCounter(counter, userId)
3491 
    return self.recv_registerCounter()
11890 kshitij.so 3492 
 
12696 amit.gupta 3493 
  def send_registerCounter(self, counter, userId):
3494 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3495 
    args = registerCounter_args()
3496 
    args.counter = counter
3497 
    args.userId = userId
3498 
    args.write(self._oprot)
3499 
    self._oprot.writeMessageEnd()
3500 
    self._oprot.trans.flush()
3501 
 
3502 
  def recv_registerCounter(self, ):
3503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3504 
    if mtype == TMessageType.EXCEPTION:
3505 
      x = TApplicationException()
3506 
      x.read(self._iprot)
3507 
      self._iprot.readMessageEnd()
3508 
      raise x
3509 
    result = registerCounter_result()
3510 
    result.read(self._iprot)
3511 
    self._iprot.readMessageEnd()
3512 
    if result.success is not None:
3513 
      return result.success
3514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3515 
 
12722 amit.gupta 3516 
  def searchCounter(self, type1, searchString):
3517 
    """
3518 
    Parameters:
3519 
     - type1
3520 
     - searchString
3521 
    """
3522 
    self.send_searchCounter(type1, searchString)
3523 
    return self.recv_searchCounter()
12696 amit.gupta 3524 
 
12722 amit.gupta 3525 
  def send_searchCounter(self, type1, searchString):
3526 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3527 
    args = searchCounter_args()
3528 
    args.type1 = type1
3529 
    args.searchString = searchString
3530 
    args.write(self._oprot)
3531 
    self._oprot.writeMessageEnd()
3532 
    self._oprot.trans.flush()
3533 
 
3534 
  def recv_searchCounter(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 = searchCounter_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, "searchCounter failed: unknown result");
3547 
 
18977 amit.gupta 3548 
  def getCounterByUserId(self, userId):
3549 
    """
3550 
    Parameters:
3551 
     - userId
3552 
    """
3553 
    self.send_getCounterByUserId(userId)
3554 
    return self.recv_getCounterByUserId()
3555 
 
3556 
  def send_getCounterByUserId(self, userId):
3557 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3558 
    args = getCounterByUserId_args()
3559 
    args.userId = userId
3560 
    args.write(self._oprot)
3561 
    self._oprot.writeMessageEnd()
3562 
    self._oprot.trans.flush()
3563 
 
3564 
  def recv_getCounterByUserId(self, ):
3565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3566 
    if mtype == TMessageType.EXCEPTION:
3567 
      x = TApplicationException()
3568 
      x.read(self._iprot)
3569 
      self._iprot.readMessageEnd()
3570 
      raise x
3571 
    result = getCounterByUserId_result()
3572 
    result.read(self._iprot)
3573 
    self._iprot.readMessageEnd()
3574 
    if result.success is not None:
3575 
      return result.success
3576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3577 
 
12722 amit.gupta 3578 
  def getAllUsersByCounter(self, counterId):
3579 
    """
3580 
    Parameters:
3581 
     - counterId
3582 
    """
3583 
    self.send_getAllUsersByCounter(counterId)
3584 
    return self.recv_getAllUsersByCounter()
3585 
 
3586 
  def send_getAllUsersByCounter(self, counterId):
3587 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3588 
    args = getAllUsersByCounter_args()
3589 
    args.counterId = counterId
3590 
    args.write(self._oprot)
3591 
    self._oprot.writeMessageEnd()
3592 
    self._oprot.trans.flush()
3593 
 
3594 
  def recv_getAllUsersByCounter(self, ):
3595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3596 
    if mtype == TMessageType.EXCEPTION:
3597 
      x = TApplicationException()
3598 
      x.read(self._iprot)
3599 
      self._iprot.readMessageEnd()
3600 
      raise x
3601 
    result = getAllUsersByCounter_result()
3602 
    result.read(self._iprot)
3603 
    self._iprot.readMessageEnd()
3604 
    if result.success is not None:
3605 
      return result.success
3606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3607 
 
15251 manish.sha 3608 
  def getActiveAccessTokenForUser(self, userId, source):
3609 
    """
3610 
    Parameters:
3611 
     - userId
3612 
     - source
3613 
    """
3614 
    self.send_getActiveAccessTokenForUser(userId, source)
3615 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3616 
 
15251 manish.sha 3617 
  def send_getActiveAccessTokenForUser(self, userId, source):
3618 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3619 
    args = getActiveAccessTokenForUser_args()
3620 
    args.userId = userId
3621 
    args.source = source
3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_getActiveAccessTokenForUser(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = getActiveAccessTokenForUser_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
3636 
    if result.success is not None:
3637 
      return result.success
3638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3639 
 
3640 
  def validateAccessToken(self, accessToken):
3641 
    """
3642 
    Parameters:
3643 
     - accessToken
3644 
    """
3645 
    self.send_validateAccessToken(accessToken)
3646 
    return self.recv_validateAccessToken()
3647 
 
3648 
  def send_validateAccessToken(self, accessToken):
3649 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3650 
    args = validateAccessToken_args()
3651 
    args.accessToken = accessToken
3652 
    args.write(self._oprot)
3653 
    self._oprot.writeMessageEnd()
3654 
    self._oprot.trans.flush()
3655 
 
3656 
  def recv_validateAccessToken(self, ):
3657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3658 
    if mtype == TMessageType.EXCEPTION:
3659 
      x = TApplicationException()
3660 
      x.read(self._iprot)
3661 
      self._iprot.readMessageEnd()
3662 
      raise x
3663 
    result = validateAccessToken_result()
3664 
    result.read(self._iprot)
3665 
    self._iprot.readMessageEnd()
3666 
    if result.success is not None:
3667 
      return result.success
3668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3669 
 
17782 amit.gupta 3670 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3671 
    """
3672 
    Parameters:
3673 
     - cartId
3674 
     - itemQty
3675 
     - couponCode
3676 
    """
3677 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3678 
    return self.recv_addItemsToCart()
15251 manish.sha 3679 
 
17782 amit.gupta 3680 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3681 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3682 
    args = addItemsToCart_args()
3683 
    args.cartId = cartId
3684 
    args.itemQty = itemQty
3685 
    args.couponCode = couponCode
3686 
    args.write(self._oprot)
3687 
    self._oprot.writeMessageEnd()
3688 
    self._oprot.trans.flush()
3689 
 
3690 
  def recv_addItemsToCart(self, ):
3691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3692 
    if mtype == TMessageType.EXCEPTION:
3693 
      x = TApplicationException()
3694 
      x.read(self._iprot)
3695 
      self._iprot.readMessageEnd()
3696 
      raise x
3697 
    result = addItemsToCart_result()
3698 
    result.read(self._iprot)
3699 
    self._iprot.readMessageEnd()
3700 
    if result.success is not None:
3701 
      return result.success
3702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3703 
 
3704 
  def validateCartNew(self, cartId, pinCode, sourceId):
3705 
    """
3706 
    Parameters:
3707 
     - cartId
3708 
     - pinCode
3709 
     - sourceId
3710 
    """
3711 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3712 
    return self.recv_validateCartNew()
3713 
 
3714 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3715 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3716 
    args = validateCartNew_args()
3717 
    args.cartId = cartId
3718 
    args.pinCode = pinCode
3719 
    args.sourceId = sourceId
3720 
    args.write(self._oprot)
3721 
    self._oprot.writeMessageEnd()
3722 
    self._oprot.trans.flush()
3723 
 
3724 
  def recv_validateCartNew(self, ):
3725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3726 
    if mtype == TMessageType.EXCEPTION:
3727 
      x = TApplicationException()
3728 
      x.read(self._iprot)
3729 
      self._iprot.readMessageEnd()
3730 
      raise x
3731 
    result = validateCartNew_result()
3732 
    result.read(self._iprot)
3733 
    self._iprot.readMessageEnd()
3734 
    if result.success is not None:
3735 
      return result.success
3736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3737 
 
18644 manish.sha 3738 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3739 
    """
3740 
    Parameters:
3741 
     - userId
3742 
    """
18644 manish.sha 3743 
    self.send_isAddressEditableForCounter(userId)
3744 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3745 
 
18644 manish.sha 3746 
  def send_isAddressEditableForCounter(self, userId):
3747 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3748 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3749 
    args.userId = userId
3750 
    args.write(self._oprot)
3751 
    self._oprot.writeMessageEnd()
3752 
    self._oprot.trans.flush()
3753 
 
18644 manish.sha 3754 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3756 
    if mtype == TMessageType.EXCEPTION:
3757 
      x = TApplicationException()
3758 
      x.read(self._iprot)
3759 
      self._iprot.readMessageEnd()
3760 
      raise x
18644 manish.sha 3761 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3762 
    result.read(self._iprot)
3763 
    self._iprot.readMessageEnd()
3764 
    if result.success is not None:
3765 
      return result.success
18644 manish.sha 3766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3767 
 
3768 
  def getBillingAddressForUser(self, userId):
3769 
    """
3770 
    Parameters:
3771 
     - userId
3772 
    """
3773 
    self.send_getBillingAddressForUser(userId)
3774 
    return self.recv_getBillingAddressForUser()
3775 
 
3776 
  def send_getBillingAddressForUser(self, userId):
3777 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3778 
    args = getBillingAddressForUser_args()
3779 
    args.userId = userId
3780 
    args.write(self._oprot)
3781 
    self._oprot.writeMessageEnd()
3782 
    self._oprot.trans.flush()
3783 
 
3784 
  def recv_getBillingAddressForUser(self, ):
3785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3786 
    if mtype == TMessageType.EXCEPTION:
3787 
      x = TApplicationException()
3788 
      x.read(self._iprot)
3789 
      self._iprot.readMessageEnd()
3790 
      raise x
3791 
    result = getBillingAddressForUser_result()
3792 
    result.read(self._iprot)
3793 
    self._iprot.readMessageEnd()
3794 
    if result.success is not None:
3795 
      return result.success
3796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3797 
 
18590 manish.sha 3798 
  def isCreditorAssigned(self, userId):
3799 
    """
3800 
    Parameters:
3801 
     - userId
3802 
    """
3803 
    self.send_isCreditorAssigned(userId)
3804 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3805 
 
18590 manish.sha 3806 
  def send_isCreditorAssigned(self, userId):
3807 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3808 
    args = isCreditorAssigned_args()
3809 
    args.userId = userId
3810 
    args.write(self._oprot)
3811 
    self._oprot.writeMessageEnd()
3812 
    self._oprot.trans.flush()
3813 
 
3814 
  def recv_isCreditorAssigned(self, ):
3815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3816 
    if mtype == TMessageType.EXCEPTION:
3817 
      x = TApplicationException()
3818 
      x.read(self._iprot)
3819 
      self._iprot.readMessageEnd()
3820 
      raise x
3821 
    result = isCreditorAssigned_result()
3822 
    result.read(self._iprot)
3823 
    self._iprot.readMessageEnd()
3824 
    if result.success is not None:
3825 
      return result.success
3826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3827 
 
18735 manish.sha 3828 
  def isTaxInvoiceEnabledUser(self, userId):
3829 
    """
3830 
    Parameters:
3831 
     - userId
3832 
    """
3833 
    self.send_isTaxInvoiceEnabledUser(userId)
3834 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3835 
 
18735 manish.sha 3836 
  def send_isTaxInvoiceEnabledUser(self, userId):
3837 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3838 
    args = isTaxInvoiceEnabledUser_args()
3839 
    args.userId = userId
3840 
    args.write(self._oprot)
3841 
    self._oprot.writeMessageEnd()
3842 
    self._oprot.trans.flush()
3843 
 
3844 
  def recv_isTaxInvoiceEnabledUser(self, ):
3845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3846 
    if mtype == TMessageType.EXCEPTION:
3847 
      x = TApplicationException()
3848 
      x.read(self._iprot)
3849 
      self._iprot.readMessageEnd()
3850 
      raise x
3851 
    result = isTaxInvoiceEnabledUser_result()
3852 
    result.read(self._iprot)
3853 
    self._iprot.readMessageEnd()
3854 
    if result.success is not None:
3855 
      return result.success
3856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3857 
 
19182 amit.gupta 3858 
  def taxInvoiceAvailable(self, addressId):
3859 
    """
3860 
    Parameters:
3861 
     - addressId
3862 
    """
3863 
    self.send_taxInvoiceAvailable(addressId)
3864 
    return self.recv_taxInvoiceAvailable()
3865 
 
3866 
  def send_taxInvoiceAvailable(self, addressId):
3867 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3868 
    args = taxInvoiceAvailable_args()
3869 
    args.addressId = addressId
3870 
    args.write(self._oprot)
3871 
    self._oprot.writeMessageEnd()
3872 
    self._oprot.trans.flush()
3873 
 
3874 
  def recv_taxInvoiceAvailable(self, ):
3875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3876 
    if mtype == TMessageType.EXCEPTION:
3877 
      x = TApplicationException()
3878 
      x.read(self._iprot)
3879 
      self._iprot.readMessageEnd()
3880 
      raise x
3881 
    result = taxInvoiceAvailable_result()
3882 
    result.read(self._iprot)
3883 
    self._iprot.readMessageEnd()
3884 
    if result.success is not None:
3885 
      return result.success
3886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3887 
 
18764 kshitij.so 3888 
  def getCartByValue(self, cartIds):
3889 
    """
3890 
    Parameters:
3891 
     - cartIds
3892 
    """
3893 
    self.send_getCartByValue(cartIds)
3894 
    return self.recv_getCartByValue()
18735 manish.sha 3895 
 
18764 kshitij.so 3896 
  def send_getCartByValue(self, cartIds):
3897 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3898 
    args = getCartByValue_args()
3899 
    args.cartIds = cartIds
3900 
    args.write(self._oprot)
3901 
    self._oprot.writeMessageEnd()
3902 
    self._oprot.trans.flush()
3903 
 
3904 
  def recv_getCartByValue(self, ):
3905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3906 
    if mtype == TMessageType.EXCEPTION:
3907 
      x = TApplicationException()
3908 
      x.read(self._iprot)
3909 
      self._iprot.readMessageEnd()
3910 
      raise x
3911 
    result = getCartByValue_result()
3912 
    result.read(self._iprot)
3913 
    self._iprot.readMessageEnd()
3914 
    if result.success is not None:
3915 
      return result.success
3916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3917 
 
19889 manas 3918 
  def getCounterName(self, userIds):
3919 
    """
3920 
    Parameters:
3921 
     - userIds
3922 
    """
3923 
    self.send_getCounterName(userIds)
3924 
    return self.recv_getCounterName()
18764 kshitij.so 3925 
 
19889 manas 3926 
  def send_getCounterName(self, userIds):
3927 
    self._oprot.writeMessageBegin('getCounterName', TMessageType.CALL, self._seqid)
3928 
    args = getCounterName_args()
3929 
    args.userIds = userIds
3930 
    args.write(self._oprot)
3931 
    self._oprot.writeMessageEnd()
3932 
    self._oprot.trans.flush()
3933 
 
3934 
  def recv_getCounterName(self, ):
3935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3936 
    if mtype == TMessageType.EXCEPTION:
3937 
      x = TApplicationException()
3938 
      x.read(self._iprot)
3939 
      self._iprot.readMessageEnd()
3940 
      raise x
3941 
    result = getCounterName_result()
3942 
    result.read(self._iprot)
3943 
    self._iprot.readMessageEnd()
3944 
    if result.success is not None:
3945 
      return result.success
3946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterName failed: unknown result");
3947 
 
20873 kshitij.so 3948 
  def setWalletAmountInCart(self, cartId, wallet_amount):
3949 
    """
3950 
    Parameters:
3951 
     - cartId
3952 
     - wallet_amount
3953 
    """
3954 
    self.send_setWalletAmountInCart(cartId, wallet_amount)
3955 
    return self.recv_setWalletAmountInCart()
19889 manas 3956 
 
20873 kshitij.so 3957 
  def send_setWalletAmountInCart(self, cartId, wallet_amount):
3958 
    self._oprot.writeMessageBegin('setWalletAmountInCart', TMessageType.CALL, self._seqid)
3959 
    args = setWalletAmountInCart_args()
3960 
    args.cartId = cartId
3961 
    args.wallet_amount = wallet_amount
3962 
    args.write(self._oprot)
3963 
    self._oprot.writeMessageEnd()
3964 
    self._oprot.trans.flush()
3965 
 
3966 
  def recv_setWalletAmountInCart(self, ):
3967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3968 
    if mtype == TMessageType.EXCEPTION:
3969 
      x = TApplicationException()
3970 
      x.read(self._iprot)
3971 
      self._iprot.readMessageEnd()
3972 
      raise x
3973 
    result = setWalletAmountInCart_result()
3974 
    result.read(self._iprot)
3975 
    self._iprot.readMessageEnd()
3976 
    if result.success is not None:
3977 
      return result.success
3978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setWalletAmountInCart failed: unknown result");
3979 
 
3980 
 
3376 rajveer 3981 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3982 
  def __init__(self, handler):
3376 rajveer 3983 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3984 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3985 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3986 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3987 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3988 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3989 
    self._processMap["createUser"] = Processor.process_createUser
3990 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3991 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3992 
    self._processMap["userExists"] = Processor.process_userExists
3993 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3994 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
22358 ashik.ali 3995 
    self._processMap["updateAddress"] = Processor.process_updateAddress
94 ashish 3996 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3997 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3998 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3999 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 4000 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 4001 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 4002 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 4003 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 4004 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 4005 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 4006 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
4007 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
4008 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 4009 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 4010 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 4011 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 4012 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
4013 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
4014 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
4015 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
4016 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 4017 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 4018 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
4019 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
4020 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 4021 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 4022 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
4023 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 4024 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
4025 
    self._processMap["getCart"] = Processor.process_getCart
4026 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
4027 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
4028 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
4029 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 4030 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 4031 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
4032 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 4033 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
4034 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 4035 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 4036 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 4037 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 4038 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 4039 
    self._processMap["checkOut"] = Processor.process_checkOut
4040 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 4041 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 4042 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 4043 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
4044 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
4045 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
4046 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
4047 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 4048 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 4049 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 4050 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 4051 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 4052 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 4053 
    self._processMap["insureItem"] = Processor.process_insureItem
4054 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
4055 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
4056 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 4057 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 4058 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 4059 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 4060 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
4061 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
4062 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 4063 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 4064 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 4065 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 4066 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 4067 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
4068 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 4069 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
4070 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 4071 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 4072 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 4073 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 4074 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 4075 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 4076 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
19889 manas 4077 
    self._processMap["getCounterName"] = Processor.process_getCounterName
20873 kshitij.so 4078 
    self._processMap["setWalletAmountInCart"] = Processor.process_setWalletAmountInCart
94 ashish 4079 
 
4080 
  def process(self, iprot, oprot):
4081 
    (name, type, seqid) = iprot.readMessageBegin()
4082 
    if name not in self._processMap:
4083 
      iprot.skip(TType.STRUCT)
4084 
      iprot.readMessageEnd()
4085 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4086 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4087 
      x.write(oprot)
4088 
      oprot.writeMessageEnd()
4089 
      oprot.trans.flush()
4090 
      return
4091 
    else:
4092 
      self._processMap[name](self, seqid, iprot, oprot)
4093 
    return True
4094 
 
559 chandransh 4095 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
4096 
    args = createAnonymousUser_args()
94 ashish 4097 
    args.read(iprot)
4098 
    iprot.readMessageEnd()
559 chandransh 4099 
    result = createAnonymousUser_result()
94 ashish 4100 
    try:
559 chandransh 4101 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
4102 
    except UserContextException, ucex:
4103 
      result.ucex = ucex
4104 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
4108 
 
559 chandransh 4109 
  def process_getUserById(self, seqid, iprot, oprot):
4110 
    args = getUserById_args()
94 ashish 4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
559 chandransh 4113 
    result = getUserById_result()
94 ashish 4114 
    try:
559 chandransh 4115 
      result.success = self._handler.getUserById(args.userId)
4116 
    except UserContextException, ucex:
4117 
      result.ucex = ucex
4118 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 4119 
    result.write(oprot)
4120 
    oprot.writeMessageEnd()
4121 
    oprot.trans.flush()
4122 
 
5326 rajveer 4123 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4124 
    args = getUserByCartId_args()
4125 
    args.read(iprot)
4126 
    iprot.readMessageEnd()
4127 
    result = getUserByCartId_result()
4128 
    try:
4129 
      result.success = self._handler.getUserByCartId(args.cartId)
4130 
    except UserContextException, ucex:
4131 
      result.ucex = ucex
4132 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
1491 vikas 4137 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4138 
    args = getUserByEmail_args()
4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
4141 
    result = getUserByEmail_result()
4142 
    try:
4143 
      result.success = self._handler.getUserByEmail(args.email)
4144 
    except UserContextException, ucex:
4145 
      result.ucex = ucex
4146 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4147 
    result.write(oprot)
4148 
    oprot.writeMessageEnd()
4149 
    oprot.trans.flush()
4150 
 
3032 mandeep.dh 4151 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4152 
    args = getUserByMobileNumber_args()
4153 
    args.read(iprot)
4154 
    iprot.readMessageEnd()
4155 
    result = getUserByMobileNumber_result()
4156 
    try:
4157 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4158 
    except UserContextException, ucex:
4159 
      result.ucex = ucex
4160 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4161 
    result.write(oprot)
4162 
    oprot.writeMessageEnd()
4163 
    oprot.trans.flush()
4164 
 
559 chandransh 4165 
  def process_createUser(self, seqid, iprot, oprot):
4166 
    args = createUser_args()
94 ashish 4167 
    args.read(iprot)
4168 
    iprot.readMessageEnd()
559 chandransh 4169 
    result = createUser_result()
94 ashish 4170 
    try:
559 chandransh 4171 
      result.success = self._handler.createUser(args.user)
4172 
    except UserContextException, ucex:
4173 
      result.ucex = ucex
4174 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4175 
    result.write(oprot)
4176 
    oprot.writeMessageEnd()
4177 
    oprot.trans.flush()
4178 
 
559 chandransh 4179 
  def process_updateUser(self, seqid, iprot, oprot):
4180 
    args = updateUser_args()
94 ashish 4181 
    args.read(iprot)
4182 
    iprot.readMessageEnd()
559 chandransh 4183 
    result = updateUser_result()
94 ashish 4184 
    try:
559 chandransh 4185 
      result.success = self._handler.updateUser(args.user)
4186 
    except UserContextException, ucex:
4187 
      result.ucex = ucex
4188 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4189 
    result.write(oprot)
4190 
    oprot.writeMessageEnd()
4191 
    oprot.trans.flush()
4192 
 
122 ashish 4193 
  def process_authenticateUser(self, seqid, iprot, oprot):
4194 
    args = authenticateUser_args()
4195 
    args.read(iprot)
4196 
    iprot.readMessageEnd()
4197 
    result = authenticateUser_result()
4198 
    try:
559 chandransh 4199 
      result.success = self._handler.authenticateUser(args.email, args.password)
4200 
    except AuthenticationException, auex:
4201 
      result.auex = auex
122 ashish 4202 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4203 
    result.write(oprot)
4204 
    oprot.writeMessageEnd()
4205 
    oprot.trans.flush()
4206 
 
94 ashish 4207 
  def process_userExists(self, seqid, iprot, oprot):
4208 
    args = userExists_args()
4209 
    args.read(iprot)
4210 
    iprot.readMessageEnd()
4211 
    result = userExists_result()
4212 
    try:
4213 
      result.success = self._handler.userExists(args.email)
4214 
    except UserContextException, ucx:
4215 
      result.ucx = ucx
4216 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4217 
    result.write(oprot)
4218 
    oprot.writeMessageEnd()
4219 
    oprot.trans.flush()
4220 
 
4221 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4222 
    args = addAddressForUser_args()
4223 
    args.read(iprot)
4224 
    iprot.readMessageEnd()
4225 
    result = addAddressForUser_result()
4226 
    try:
567 rajveer 4227 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4228 
    except UserContextException, ucx:
4229 
      result.ucx = ucx
4230 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4231 
    result.write(oprot)
4232 
    oprot.writeMessageEnd()
4233 
    oprot.trans.flush()
4234 
 
4235 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4236 
    args = removeAddressForUser_args()
4237 
    args.read(iprot)
4238 
    iprot.readMessageEnd()
4239 
    result = removeAddressForUser_result()
4240 
    try:
4241 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4242 
    except UserContextException, ucx:
4243 
      result.ucx = ucx
4244 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4245 
    result.write(oprot)
4246 
    oprot.writeMessageEnd()
4247 
    oprot.trans.flush()
4248 
 
22358 ashik.ali 4249 
  def process_updateAddress(self, seqid, iprot, oprot):
4250 
    args = updateAddress_args()
4251 
    args.read(iprot)
4252 
    iprot.readMessageEnd()
4253 
    result = updateAddress_result()
4254 
    try:
4255 
      result.success = self._handler.updateAddress(args.address)
4256 
    except UserContextException, ucx:
4257 
      result.ucx = ucx
4258 
    oprot.writeMessageBegin("updateAddress", TMessageType.REPLY, seqid)
4259 
    result.write(oprot)
4260 
    oprot.writeMessageEnd()
4261 
    oprot.trans.flush()
4262 
 
94 ashish 4263 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4264 
    args = setUserAsLoggedIn_args()
4265 
    args.read(iprot)
4266 
    iprot.readMessageEnd()
4267 
    result = setUserAsLoggedIn_result()
4268 
    try:
4269 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4270 
    except UserContextException, ucx:
4271 
      result.ucx = ucx
4272 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4273 
    result.write(oprot)
4274 
    oprot.writeMessageEnd()
4275 
    oprot.trans.flush()
4276 
 
4277 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4278 
    args = setUserAsLoggedOut_args()
4279 
    args.read(iprot)
4280 
    iprot.readMessageEnd()
4281 
    result = setUserAsLoggedOut_result()
4282 
    try:
4283 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4284 
    except UserContextException, ucx:
4285 
      result.ucx = ucx
4286 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4287 
    result.write(oprot)
4288 
    oprot.writeMessageEnd()
4289 
    oprot.trans.flush()
4290 
 
504 rajveer 4291 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4292 
    args = setDefaultAddress_args()
4293 
    args.read(iprot)
4294 
    iprot.readMessageEnd()
4295 
    result = setDefaultAddress_result()
4296 
    try:
4297 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4298 
    except UserContextException, ucx:
4299 
      result.ucx = ucx
4300 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4301 
    result.write(oprot)
4302 
    oprot.writeMessageEnd()
4303 
    oprot.trans.flush()
4304 
 
94 ashish 4305 
  def process_updatePassword(self, seqid, iprot, oprot):
4306 
    args = updatePassword_args()
4307 
    args.read(iprot)
4308 
    iprot.readMessageEnd()
4309 
    result = updatePassword_result()
4310 
    try:
594 rajveer 4311 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4312 
    except UserContextException, ucx:
4313 
      result.ucx = ucx
4314 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4315 
    result.write(oprot)
4316 
    oprot.writeMessageEnd()
4317 
    oprot.trans.flush()
4318 
 
581 rajveer 4319 
  def process_forgotPassword(self, seqid, iprot, oprot):
4320 
    args = forgotPassword_args()
4321 
    args.read(iprot)
4322 
    iprot.readMessageEnd()
4323 
    result = forgotPassword_result()
4324 
    try:
884 rajveer 4325 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4326 
    except UserContextException, ucx:
4327 
      result.ucx = ucx
4328 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4329 
    result.write(oprot)
4330 
    oprot.writeMessageEnd()
4331 
    oprot.trans.flush()
4332 
 
594 rajveer 4333 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4334 
    args = getAllAddressesForUser_args()
4335 
    args.read(iprot)
4336 
    iprot.readMessageEnd()
4337 
    result = getAllAddressesForUser_result()
4338 
    try:
4339 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4340 
    except UserContextException, ucx:
4341 
      result.ucx = ucx
4342 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4343 
    result.write(oprot)
4344 
    oprot.writeMessageEnd()
4345 
    oprot.trans.flush()
4346 
 
1894 vikas 4347 
  def process_getAddressById(self, seqid, iprot, oprot):
4348 
    args = getAddressById_args()
4349 
    args.read(iprot)
4350 
    iprot.readMessageEnd()
4351 
    result = getAddressById_result()
4352 
    try:
4353 
      result.success = self._handler.getAddressById(args.addressId)
4354 
    except UserContextException, ucx:
4355 
      result.ucx = ucx
4356 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4357 
    result.write(oprot)
4358 
    oprot.writeMessageEnd()
4359 
    oprot.trans.flush()
4360 
 
594 rajveer 4361 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4362 
    args = getDefaultAddressId_args()
4363 
    args.read(iprot)
4364 
    iprot.readMessageEnd()
4365 
    result = getDefaultAddressId_result()
4366 
    try:
4367 
      result.success = self._handler.getDefaultAddressId(args.userId)
4368 
    except UserContextException, ucx:
4369 
      result.ucx = ucx
4370 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4371 
    result.write(oprot)
4372 
    oprot.writeMessageEnd()
4373 
    oprot.trans.flush()
4374 
 
785 rajveer 4375 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4376 
    args = getDefaultPincode_args()
4377 
    args.read(iprot)
4378 
    iprot.readMessageEnd()
4379 
    result = getDefaultPincode_result()
4380 
    try:
4381 
      result.success = self._handler.getDefaultPincode(args.userId)
4382 
    except UserContextException, ucx:
4383 
      result.ucx = ucx
4384 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4385 
    result.write(oprot)
4386 
    oprot.writeMessageEnd()
4387 
    oprot.trans.flush()
4388 
 
1274 varun.gupt 4389 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4390 
    args = saveUserCommunication_args()
4391 
    args.read(iprot)
4392 
    iprot.readMessageEnd()
4393 
    result = saveUserCommunication_result()
4394 
    try:
4395 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4396 
    except UserCommunicationException, ucx:
4397 
      result.ucx = ucx
4398 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4399 
    result.write(oprot)
4400 
    oprot.writeMessageEnd()
4401 
    oprot.trans.flush()
4402 
 
1590 varun.gupt 4403 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4404 
    args = getUserCommunicationById_args()
4405 
    args.read(iprot)
4406 
    iprot.readMessageEnd()
4407 
    result = getUserCommunicationById_result()
4408 
    try:
4409 
      result.success = self._handler.getUserCommunicationById(args.id)
4410 
    except UserCommunicationException, ucx:
4411 
      result.ucx = ucx
4412 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4413 
    result.write(oprot)
4414 
    oprot.writeMessageEnd()
4415 
    oprot.trans.flush()
4416 
 
4417 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4418 
    args = getUserCommunicationByUser_args()
4419 
    args.read(iprot)
4420 
    iprot.readMessageEnd()
4421 
    result = getUserCommunicationByUser_result()
4422 
    try:
4423 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4424 
    except UserCommunicationException, ucx:
4425 
      result.ucx = ucx
4426 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4427 
    result.write(oprot)
4428 
    oprot.writeMessageEnd()
4429 
    oprot.trans.flush()
4430 
 
4431 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4432 
    args = getAllUserCommunications_args()
4433 
    args.read(iprot)
4434 
    iprot.readMessageEnd()
4435 
    result = getAllUserCommunications_result()
4436 
    try:
4437 
      result.success = self._handler.getAllUserCommunications()
4438 
    except UserCommunicationException, ucx:
4439 
      result.ucx = ucx
4440 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4441 
    result.write(oprot)
4442 
    oprot.writeMessageEnd()
4443 
    oprot.trans.flush()
4444 
 
5407 amar.kumar 4445 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4446 
    args = removeUserCommunication_args()
4447 
    args.read(iprot)
4448 
    iprot.readMessageEnd()
4449 
    result = removeUserCommunication_result()
4450 
    try:
4451 
      self._handler.removeUserCommunication(args.id)
4452 
    except UserCommunicationException, ucx:
4453 
      result.ucx = ucx
4454 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4455 
    result.write(oprot)
4456 
    oprot.writeMessageEnd()
4457 
    oprot.trans.flush()
4458 
 
1845 vikas 4459 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4460 
    args = createMasterAffiliate_args()
4461 
    args.read(iprot)
4462 
    iprot.readMessageEnd()
4463 
    result = createMasterAffiliate_result()
4464 
    try:
1859 vikas 4465 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4466 
    except UserAffiliateException, utx:
1845 vikas 4467 
      result.utx = utx
4468 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4469 
    result.write(oprot)
4470 
    oprot.writeMessageEnd()
4471 
    oprot.trans.flush()
4472 
 
1899 vikas 4473 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4474 
    args = getAllMasterAffiliates_args()
4475 
    args.read(iprot)
4476 
    iprot.readMessageEnd()
4477 
    result = getAllMasterAffiliates_result()
4478 
    try:
4479 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4480 
    except UserAffiliateException, utx:
1899 vikas 4481 
      result.utx = utx
4482 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4483 
    result.write(oprot)
4484 
    oprot.writeMessageEnd()
4485 
    oprot.trans.flush()
4486 
 
1845 vikas 4487 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4488 
    args = getMasterAffiliateById_args()
4489 
    args.read(iprot)
4490 
    iprot.readMessageEnd()
4491 
    result = getMasterAffiliateById_result()
4492 
    try:
4493 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4494 
    except UserAffiliateException, utx:
1845 vikas 4495 
      result.utx = utx
4496 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4497 
    result.write(oprot)
4498 
    oprot.writeMessageEnd()
4499 
    oprot.trans.flush()
4500 
 
4501 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4502 
    args = getMasterAffiliateByName_args()
4503 
    args.read(iprot)
4504 
    iprot.readMessageEnd()
4505 
    result = getMasterAffiliateByName_result()
4506 
    try:
4507 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4508 
    except UserAffiliateException, utx:
1845 vikas 4509 
      result.utx = utx
4510 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4511 
    result.write(oprot)
4512 
    oprot.writeMessageEnd()
4513 
    oprot.trans.flush()
4514 
 
4515 
  def process_createAffiliate(self, seqid, iprot, oprot):
4516 
    args = createAffiliate_args()
4517 
    args.read(iprot)
4518 
    iprot.readMessageEnd()
4519 
    result = createAffiliate_result()
4520 
    try:
1859 vikas 4521 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4522 
    except UserAffiliateException, utx:
1845 vikas 4523 
      result.utx = utx
4524 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4525 
    result.write(oprot)
4526 
    oprot.writeMessageEnd()
4527 
    oprot.trans.flush()
4528 
 
4529 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4530 
    args = getAffiliateById_args()
4531 
    args.read(iprot)
4532 
    iprot.readMessageEnd()
4533 
    result = getAffiliateById_result()
4534 
    try:
4535 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4536 
    except UserAffiliateException, utx:
1845 vikas 4537 
      result.utx = utx
4538 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4539 
    result.write(oprot)
4540 
    oprot.writeMessageEnd()
4541 
    oprot.trans.flush()
4542 
 
4543 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4544 
    args = getAffiliateByName_args()
4545 
    args.read(iprot)
4546 
    iprot.readMessageEnd()
4547 
    result = getAffiliateByName_result()
4548 
    try:
4549 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4550 
    except UserAffiliateException, utx:
1845 vikas 4551 
      result.utx = utx
4552 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4553 
    result.write(oprot)
4554 
    oprot.writeMessageEnd()
4555 
    oprot.trans.flush()
4556 
 
4557 
  def process_getTrackerById(self, seqid, iprot, oprot):
4558 
    args = getTrackerById_args()
4559 
    args.read(iprot)
4560 
    iprot.readMessageEnd()
4561 
    result = getTrackerById_result()
4562 
    try:
1996 vikas 4563 
      result.success = self._handler.getTrackerById(args.id)
4564 
    except UserAffiliateException, utx:
1845 vikas 4565 
      result.utx = utx
4566 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4567 
    result.write(oprot)
4568 
    oprot.writeMessageEnd()
4569 
    oprot.trans.flush()
4570 
 
1996 vikas 4571 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4572 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4573 
    args.read(iprot)
4574 
    iprot.readMessageEnd()
1996 vikas 4575 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4576 
    try:
1996 vikas 4577 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4578 
    except UserAffiliateException, utx:
1845 vikas 4579 
      result.utx = utx
1996 vikas 4580 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
4584 
 
4585 
  def process_addTrackLog(self, seqid, iprot, oprot):
4586 
    args = addTrackLog_args()
4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
4589 
    result = addTrackLog_result()
4590 
    try:
1996 vikas 4591 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4592 
    except UserAffiliateException, utx:
1845 vikas 4593 
      result.utx = utx
4594 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4595 
    result.write(oprot)
4596 
    oprot.writeMessageEnd()
4597 
    oprot.trans.flush()
4598 
 
4599 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4600 
    args = getTrackLogById_args()
4601 
    args.read(iprot)
4602 
    iprot.readMessageEnd()
4603 
    result = getTrackLogById_result()
4604 
    try:
4605 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4606 
    except UserAffiliateException, utx:
1845 vikas 4607 
      result.utx = utx
4608 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
4612 
 
1996 vikas 4613 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4614 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
1996 vikas 4617 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4618 
    try:
3293 vikas 4619 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4620 
    except UserAffiliateException, utx:
1845 vikas 4621 
      result.utx = utx
1996 vikas 4622 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4623 
    result.write(oprot)
4624 
    oprot.writeMessageEnd()
4625 
    oprot.trans.flush()
4626 
 
4627 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4628 
    args = getTrackLogsByUser_args()
4629 
    args.read(iprot)
4630 
    iprot.readMessageEnd()
4631 
    result = getTrackLogsByUser_result()
4632 
    try:
4633 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4634 
    except UserAffiliateException, utx:
1845 vikas 4635 
      result.utx = utx
4636 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4637 
    result.write(oprot)
4638 
    oprot.writeMessageEnd()
4639 
    oprot.trans.flush()
4640 
 
4641 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4642 
    args = getTrackLogs_args()
4643 
    args.read(iprot)
4644 
    iprot.readMessageEnd()
4645 
    result = getTrackLogs_result()
4646 
    try:
1996 vikas 4647 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4648 
    except UserAffiliateException, utx:
1845 vikas 4649 
      result.utx = utx
4650 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
559 chandransh 4655 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4656 
    args = getCurrentCart_args()
94 ashish 4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
559 chandransh 4659 
    result = getCurrentCart_result()
94 ashish 4660 
    try:
559 chandransh 4661 
      result.success = self._handler.getCurrentCart(args.userId)
4662 
    except ShoppingCartException, scx:
4663 
      result.scx = scx
4664 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4665 
    result.write(oprot)
4666 
    oprot.writeMessageEnd()
4667 
    oprot.trans.flush()
4668 
 
559 chandransh 4669 
  def process_getCart(self, seqid, iprot, oprot):
4670 
    args = getCart_args()
94 ashish 4671 
    args.read(iprot)
4672 
    iprot.readMessageEnd()
559 chandransh 4673 
    result = getCart_result()
94 ashish 4674 
    try:
559 chandransh 4675 
      result.success = self._handler.getCart(args.cartId)
4676 
    except ShoppingCartException, scx:
4677 
      result.scx = scx
4678 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4679 
    result.write(oprot)
4680 
    oprot.writeMessageEnd()
4681 
    oprot.trans.flush()
4682 
 
559 chandransh 4683 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4684 
    args = getCartsByTime_args()
94 ashish 4685 
    args.read(iprot)
4686 
    iprot.readMessageEnd()
559 chandransh 4687 
    result = getCartsByTime_result()
94 ashish 4688 
    try:
559 chandransh 4689 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4690 
    except ShoppingCartException, scx:
4691 
      result.scx = scx
4692 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4693 
    result.write(oprot)
4694 
    oprot.writeMessageEnd()
4695 
    oprot.trans.flush()
4696 
 
559 chandransh 4697 
  def process_addItemToCart(self, seqid, iprot, oprot):
4698 
    args = addItemToCart_args()
130 ashish 4699 
    args.read(iprot)
4700 
    iprot.readMessageEnd()
559 chandransh 4701 
    result = addItemToCart_result()
130 ashish 4702 
    try:
3557 rajveer 4703 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4704 
    except ShoppingCartException, scx:
4705 
      result.scx = scx
4706 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4707 
    result.write(oprot)
4708 
    oprot.writeMessageEnd()
4709 
    oprot.trans.flush()
4710 
 
559 chandransh 4711 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4712 
    args = deleteItemFromCart_args()
4713 
    args.read(iprot)
4714 
    iprot.readMessageEnd()
4715 
    result = deleteItemFromCart_result()
4716 
    try:
4717 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4718 
    except ShoppingCartException, scx:
4719 
      result.scx = scx
4720 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4721 
    result.write(oprot)
4722 
    oprot.writeMessageEnd()
4723 
    oprot.trans.flush()
130 ashish 4724 
 
559 chandransh 4725 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4726 
    args = addAddressToCart_args()
4727 
    args.read(iprot)
4728 
    iprot.readMessageEnd()
4729 
    result = addAddressToCart_result()
575 chandransh 4730 
    try:
4731 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4732 
    except ShoppingCartException, scx:
4733 
      result.scx = scx
559 chandransh 4734 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4735 
    result.write(oprot)
4736 
    oprot.writeMessageEnd()
4737 
    oprot.trans.flush()
4738 
 
5553 rajveer 4739 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4740 
    args = addStoreToCart_args()
4741 
    args.read(iprot)
4742 
    iprot.readMessageEnd()
4743 
    result = addStoreToCart_result()
4744 
    try:
4745 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4746 
    except ShoppingCartException, scx:
4747 
      result.scx = scx
4748 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
1976 varun.gupt 4753 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4754 
    args = applyCouponToCart_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = applyCouponToCart_result()
4758 
    try:
6922 anupam.sin 4759 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4760 
    except ShoppingCartException, scx:
4761 
      result.scx = scx
4762 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4763 
    result.write(oprot)
4764 
    oprot.writeMessageEnd()
4765 
    oprot.trans.flush()
4766 
 
4767 
  def process_removeCoupon(self, seqid, iprot, oprot):
4768 
    args = removeCoupon_args()
4769 
    args.read(iprot)
4770 
    iprot.readMessageEnd()
4771 
    result = removeCoupon_result()
4772 
    try:
4773 
      self._handler.removeCoupon(args.cartId)
4774 
    except ShoppingCartException, scx:
4775 
      result.scx = scx
4776 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4777 
    result.write(oprot)
4778 
    oprot.writeMessageEnd()
4779 
    oprot.trans.flush()
4780 
 
3554 varun.gupt 4781 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4782 
    args = deleteDiscountsFromCart_args()
4783 
    args.read(iprot)
4784 
    iprot.readMessageEnd()
4785 
    result = deleteDiscountsFromCart_result()
4786 
    try:
4787 
      self._handler.deleteDiscountsFromCart(args.cartId)
4788 
    except ShoppingCartException, scx:
4789 
      result.scx = scx
4790 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4791 
    result.write(oprot)
4792 
    oprot.writeMessageEnd()
4793 
    oprot.trans.flush()
4794 
 
4795 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4796 
    args = saveDiscounts_args()
4797 
    args.read(iprot)
4798 
    iprot.readMessageEnd()
4799 
    result = saveDiscounts_result()
4800 
    try:
4801 
      self._handler.saveDiscounts(args.discounts)
4802 
    except ShoppingCartException, scx:
4803 
      result.scx = scx
4804 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4805 
    result.write(oprot)
4806 
    oprot.writeMessageEnd()
4807 
    oprot.trans.flush()
4808 
 
690 chandransh 4809 
  def process_createOrders(self, seqid, iprot, oprot):
4810 
    args = createOrders_args()
559 chandransh 4811 
    args.read(iprot)
4812 
    iprot.readMessageEnd()
690 chandransh 4813 
    result = createOrders_result()
559 chandransh 4814 
    try:
21454 amit.gupta 4815 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource, args.selfPickup)
559 chandransh 4816 
    except ShoppingCartException, scx:
4817 
      result.scx = scx
690 chandransh 4818 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4819 
    result.write(oprot)
4820 
    oprot.writeMessageEnd()
4821 
    oprot.trans.flush()
4822 
 
4823 
  def process_validateCart(self, seqid, iprot, oprot):
4824 
    args = validateCart_args()
4825 
    args.read(iprot)
4826 
    iprot.readMessageEnd()
4827 
    result = validateCart_result()
575 chandransh 4828 
    try:
3557 rajveer 4829 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4830 
    except ShoppingCartException, scex:
4831 
      result.scex = scex
559 chandransh 4832 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4833 
    result.write(oprot)
4834 
    oprot.writeMessageEnd()
4835 
    oprot.trans.flush()
4836 
 
11980 amit.gupta 4837 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4838 
    args = validateCartWithDealerCoupon_args()
4839 
    args.read(iprot)
4840 
    iprot.readMessageEnd()
4841 
    result = validateCartWithDealerCoupon_result()
4842 
    try:
4843 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4844 
    except ShoppingCartException, scex:
4845 
      result.scex = scex
4846 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4847 
    result.write(oprot)
4848 
    oprot.writeMessageEnd()
4849 
    oprot.trans.flush()
4850 
 
690 chandransh 4851 
  def process_mergeCart(self, seqid, iprot, oprot):
4852 
    args = mergeCart_args()
575 chandransh 4853 
    args.read(iprot)
4854 
    iprot.readMessageEnd()
690 chandransh 4855 
    result = mergeCart_result()
4856 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4857 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4858 
    result.write(oprot)
4859 
    oprot.writeMessageEnd()
4860 
    oprot.trans.flush()
4861 
 
4862 
  def process_checkOut(self, seqid, iprot, oprot):
4863 
    args = checkOut_args()
4864 
    args.read(iprot)
4865 
    iprot.readMessageEnd()
4866 
    result = checkOut_result()
575 chandransh 4867 
    try:
690 chandransh 4868 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4869 
    except ShoppingCartException, scex:
4870 
      result.scex = scex
690 chandransh 4871 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4872 
    result.write(oprot)
4873 
    oprot.writeMessageEnd()
4874 
    oprot.trans.flush()
4875 
 
690 chandransh 4876 
  def process_resetCart(self, seqid, iprot, oprot):
4877 
    args = resetCart_args()
559 chandransh 4878 
    args.read(iprot)
4879 
    iprot.readMessageEnd()
690 chandransh 4880 
    result = resetCart_result()
4881 
    try:
4882 
      result.success = self._handler.resetCart(args.cartId, args.items)
4883 
    except ShoppingCartException, scex:
4884 
      result.scex = scex
4885 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4886 
    result.write(oprot)
4887 
    oprot.writeMessageEnd()
4888 
    oprot.trans.flush()
4889 
 
2981 rajveer 4890 
  def process_getUserCount(self, seqid, iprot, oprot):
4891 
    args = getUserCount_args()
559 chandransh 4892 
    args.read(iprot)
4893 
    iprot.readMessageEnd()
2981 rajveer 4894 
    result = getUserCount_result()
4895 
    result.success = self._handler.getUserCount(args.userType)
4896 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4897 
    result.write(oprot)
4898 
    oprot.writeMessageEnd()
4899 
    oprot.trans.flush()
4900 
 
2981 rajveer 4901 
  def process_getAllUsers(self, seqid, iprot, oprot):
4902 
    args = getAllUsers_args()
559 chandransh 4903 
    args.read(iprot)
4904 
    iprot.readMessageEnd()
2981 rajveer 4905 
    result = getAllUsers_result()
4906 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4907 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4908 
    result.write(oprot)
4909 
    oprot.writeMessageEnd()
4910 
    oprot.trans.flush()
4911 
 
2981 rajveer 4912 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4913 
    args = getMyResearchItems_args()
559 chandransh 4914 
    args.read(iprot)
4915 
    iprot.readMessageEnd()
2981 rajveer 4916 
    result = getMyResearchItems_result()
559 chandransh 4917 
    try:
2981 rajveer 4918 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4919 
    except WidgetException, scx:
4920 
      result.scx = scx
2981 rajveer 4921 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4922 
    result.write(oprot)
4923 
    oprot.writeMessageEnd()
4924 
    oprot.trans.flush()
4925 
 
2981 rajveer 4926 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4927 
    args = updateMyResearch_args()
772 rajveer 4928 
    args.read(iprot)
4929 
    iprot.readMessageEnd()
2981 rajveer 4930 
    result = updateMyResearch_result()
4931 
    try:
4932 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4933 
    except WidgetException, scx:
4934 
      result.scx = scx
4935 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4936 
    result.write(oprot)
4937 
    oprot.writeMessageEnd()
4938 
    oprot.trans.flush()
559 chandransh 4939 
 
2981 rajveer 4940 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4941 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
2981 rajveer 4944 
    result = deleteItemFromMyResearch_result()
4945 
    try:
4946 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4947 
    except WidgetException, scx:
4948 
      result.scx = scx
4949 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
772 rajveer 4953 
 
2981 rajveer 4954 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4955 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
2981 rajveer 4958 
    result = getBrowseHistoryItems_result()
4959 
    try:
4960 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4961 
    except WidgetException, scx:
4962 
      result.scx = scx
4963 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4964 
    result.write(oprot)
4965 
    oprot.writeMessageEnd()
4966 
    oprot.trans.flush()
1596 ankur.sing 4967 
 
2981 rajveer 4968 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4969 
    args = updateBrowseHistory_args()
2642 varun.gupt 4970 
    args.read(iprot)
4971 
    iprot.readMessageEnd()
2981 rajveer 4972 
    result = updateBrowseHistory_result()
4973 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4974 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
1673 ankur.sing 4978 
 
3385 varun.gupt 4979 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4980 
    args = getCartsWithCouponCount_args()
4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
4983 
    result = getCartsWithCouponCount_result()
4984 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4985 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4986 
    result.write(oprot)
4987 
    oprot.writeMessageEnd()
4988 
    oprot.trans.flush()
2642 varun.gupt 4989 
 
3499 mandeep.dh 4990 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4991 
    args = increaseTrustLevel_args()
4992 
    args.read(iprot)
4993 
    iprot.readMessageEnd()
4994 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4995 
    return
3385 varun.gupt 4996 
 
5407 amar.kumar 4997 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4998 
    args = getTrustLevel_args()
4999 
    args.read(iprot)
5000 
    iprot.readMessageEnd()
5001 
    result = getTrustLevel_result()
5002 
    result.success = self._handler.getTrustLevel(args.userId)
5003 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
5007 
 
4668 varun.gupt 5008 
  def process_showCODOption(self, seqid, iprot, oprot):
5009 
    args = showCODOption_args()
5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
5012 
    result = showCODOption_result()
5013 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
5014 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
5015 
    result.write(oprot)
5016 
    oprot.writeMessageEnd()
5017 
    oprot.trans.flush()
3499 mandeep.dh 5018 
 
5623 anupam.sin 5019 
  def process_getUserEmails(self, seqid, iprot, oprot):
5020 
    args = getUserEmails_args()
5021 
    args.read(iprot)
5022 
    iprot.readMessageEnd()
5023 
    result = getUserEmails_result()
5024 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
5025 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
5026 
    result.write(oprot)
5027 
    oprot.writeMessageEnd()
5028 
    oprot.trans.flush()
4668 varun.gupt 5029 
 
6903 anupam.sin 5030 
  def process_insureItem(self, seqid, iprot, oprot):
5031 
    args = insureItem_args()
5032 
    args.read(iprot)
5033 
    iprot.readMessageEnd()
5034 
    result = insureItem_result()
9299 kshitij.so 5035 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 5036 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
5037 
    result.write(oprot)
5038 
    oprot.writeMessageEnd()
5039 
    oprot.trans.flush()
5040 
 
5041 
  def process_cancelInsurance(self, seqid, iprot, oprot):
5042 
    args = cancelInsurance_args()
5043 
    args.read(iprot)
5044 
    iprot.readMessageEnd()
5045 
    result = cancelInsurance_result()
5046 
    result.success = self._handler.cancelInsurance(args.cartId)
5047 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
5048 
    result.write(oprot)
5049 
    oprot.writeMessageEnd()
5050 
    oprot.trans.flush()
5051 
 
5052 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
5053 
    args = storeInsuranceSpecificDetails_args()
5054 
    args.read(iprot)
5055 
    iprot.readMessageEnd()
5056 
    result = storeInsuranceSpecificDetails_result()
5057 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
5058 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
5062 
 
5063 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
5064 
    args = isInsuranceDetailPresent_args()
5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
5067 
    result = isInsuranceDetailPresent_result()
5068 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
5069 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
5070 
    result.write(oprot)
5071 
    oprot.writeMessageEnd()
5072 
    oprot.trans.flush()
5073 
 
9791 rajveer 5074 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
5075 
    args = getProductsAddedToCart_args()
6821 amar.kumar 5076 
    args.read(iprot)
5077 
    iprot.readMessageEnd()
9791 rajveer 5078 
    result = getProductsAddedToCart_result()
5079 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
5080 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 5081 
    result.write(oprot)
5082 
    oprot.writeMessageEnd()
5083 
    oprot.trans.flush()
5623 anupam.sin 5084 
 
11592 amit.gupta 5085 
  def process_validateCartPlus(self, seqid, iprot, oprot):
5086 
    args = validateCartPlus_args()
5087 
    args.read(iprot)
5088 
    iprot.readMessageEnd()
5089 
    result = validateCartPlus_result()
5090 
    try:
11980 amit.gupta 5091 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 5092 
    except ShoppingCartException, scex:
5093 
      result.scex = scex
5094 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
5095 
    result.write(oprot)
5096 
    oprot.writeMessageEnd()
5097 
    oprot.trans.flush()
6821 amar.kumar 5098 
 
11679 vikram.rag 5099 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
5100 
    args = isPrivateDealUser_args()
5101 
    args.read(iprot)
5102 
    iprot.readMessageEnd()
5103 
    result = isPrivateDealUser_result()
5104 
    result.success = self._handler.isPrivateDealUser(args.userId)
5105 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
5106 
    result.write(oprot)
5107 
    oprot.writeMessageEnd()
5108 
    oprot.trans.flush()
11592 amit.gupta 5109 
 
11890 kshitij.so 5110 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
5111 
    args = addPrivateDealUser_args()
5112 
    args.read(iprot)
5113 
    iprot.readMessageEnd()
5114 
    result = addPrivateDealUser_result()
5115 
    result.success = self._handler.addPrivateDealUser(args.userId)
5116 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
5117 
    result.write(oprot)
5118 
    oprot.writeMessageEnd()
5119 
    oprot.trans.flush()
11679 vikram.rag 5120 
 
11890 kshitij.so 5121 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
5122 
    args = changePrivateDealUserStatus_args()
5123 
    args.read(iprot)
5124 
    iprot.readMessageEnd()
5125 
    result = changePrivateDealUserStatus_result()
5126 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
5127 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
5128 
    result.write(oprot)
5129 
    oprot.writeMessageEnd()
5130 
    oprot.trans.flush()
5131 
 
5132 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
5133 
    args = getPrivateDealUser_args()
5134 
    args.read(iprot)
5135 
    iprot.readMessageEnd()
5136 
    result = getPrivateDealUser_result()
5137 
    result.success = self._handler.getPrivateDealUser(args.userId)
5138 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5139 
    result.write(oprot)
5140 
    oprot.writeMessageEnd()
5141 
    oprot.trans.flush()
5142 
 
12696 amit.gupta 5143 
  def process_registerCounter(self, seqid, iprot, oprot):
5144 
    args = registerCounter_args()
5145 
    args.read(iprot)
5146 
    iprot.readMessageEnd()
5147 
    result = registerCounter_result()
5148 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5149 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5150 
    result.write(oprot)
5151 
    oprot.writeMessageEnd()
5152 
    oprot.trans.flush()
11890 kshitij.so 5153 
 
12722 amit.gupta 5154 
  def process_searchCounter(self, seqid, iprot, oprot):
5155 
    args = searchCounter_args()
5156 
    args.read(iprot)
5157 
    iprot.readMessageEnd()
5158 
    result = searchCounter_result()
5159 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5160 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5161 
    result.write(oprot)
5162 
    oprot.writeMessageEnd()
5163 
    oprot.trans.flush()
12696 amit.gupta 5164 
 
18977 amit.gupta 5165 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5166 
    args = getCounterByUserId_args()
5167 
    args.read(iprot)
5168 
    iprot.readMessageEnd()
5169 
    result = getCounterByUserId_result()
5170 
    result.success = self._handler.getCounterByUserId(args.userId)
5171 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5172 
    result.write(oprot)
5173 
    oprot.writeMessageEnd()
5174 
    oprot.trans.flush()
5175 
 
12722 amit.gupta 5176 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5177 
    args = getAllUsersByCounter_args()
5178 
    args.read(iprot)
5179 
    iprot.readMessageEnd()
5180 
    result = getAllUsersByCounter_result()
5181 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5182 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5183 
    result.write(oprot)
5184 
    oprot.writeMessageEnd()
5185 
    oprot.trans.flush()
5186 
 
15251 manish.sha 5187 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5188 
    args = getActiveAccessTokenForUser_args()
5189 
    args.read(iprot)
5190 
    iprot.readMessageEnd()
5191 
    result = getActiveAccessTokenForUser_result()
5192 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5193 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5194 
    result.write(oprot)
5195 
    oprot.writeMessageEnd()
5196 
    oprot.trans.flush()
12722 amit.gupta 5197 
 
15251 manish.sha 5198 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5199 
    args = validateAccessToken_args()
5200 
    args.read(iprot)
5201 
    iprot.readMessageEnd()
5202 
    result = validateAccessToken_result()
5203 
    result.success = self._handler.validateAccessToken(args.accessToken)
5204 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5205 
    result.write(oprot)
5206 
    oprot.writeMessageEnd()
5207 
    oprot.trans.flush()
5208 
 
17782 amit.gupta 5209 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5210 
    args = addItemsToCart_args()
5211 
    args.read(iprot)
5212 
    iprot.readMessageEnd()
5213 
    result = addItemsToCart_result()
5214 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5215 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5216 
    result.write(oprot)
5217 
    oprot.writeMessageEnd()
5218 
    oprot.trans.flush()
15251 manish.sha 5219 
 
17782 amit.gupta 5220 
  def process_validateCartNew(self, seqid, iprot, oprot):
5221 
    args = validateCartNew_args()
5222 
    args.read(iprot)
5223 
    iprot.readMessageEnd()
5224 
    result = validateCartNew_result()
5225 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5226 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5227 
    result.write(oprot)
5228 
    oprot.writeMessageEnd()
5229 
    oprot.trans.flush()
5230 
 
18644 manish.sha 5231 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5232 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5233 
    args.read(iprot)
5234 
    iprot.readMessageEnd()
18644 manish.sha 5235 
    result = isAddressEditableForCounter_result()
5236 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5237 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
17782 amit.gupta 5241 
 
18530 manish.sha 5242 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5243 
    args = getBillingAddressForUser_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = getBillingAddressForUser_result()
5247 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5248 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
5252 
 
18590 manish.sha 5253 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5254 
    args = isCreditorAssigned_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = isCreditorAssigned_result()
5258 
    result.success = self._handler.isCreditorAssigned(args.userId)
5259 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
18530 manish.sha 5263 
 
18735 manish.sha 5264 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5265 
    args = isTaxInvoiceEnabledUser_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = isTaxInvoiceEnabledUser_result()
5269 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5270 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5271 
    result.write(oprot)
5272 
    oprot.writeMessageEnd()
5273 
    oprot.trans.flush()
18590 manish.sha 5274 
 
19182 amit.gupta 5275 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5276 
    args = taxInvoiceAvailable_args()
5277 
    args.read(iprot)
5278 
    iprot.readMessageEnd()
5279 
    result = taxInvoiceAvailable_result()
5280 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5281 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
18764 kshitij.so 5286 
  def process_getCartByValue(self, seqid, iprot, oprot):
5287 
    args = getCartByValue_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = getCartByValue_result()
5291 
    result.success = self._handler.getCartByValue(args.cartIds)
5292 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5293 
    result.write(oprot)
5294 
    oprot.writeMessageEnd()
5295 
    oprot.trans.flush()
18735 manish.sha 5296 
 
19889 manas 5297 
  def process_getCounterName(self, seqid, iprot, oprot):
5298 
    args = getCounterName_args()
5299 
    args.read(iprot)
5300 
    iprot.readMessageEnd()
5301 
    result = getCounterName_result()
5302 
    result.success = self._handler.getCounterName(args.userIds)
5303 
    oprot.writeMessageBegin("getCounterName", TMessageType.REPLY, seqid)
5304 
    result.write(oprot)
5305 
    oprot.writeMessageEnd()
5306 
    oprot.trans.flush()
18764 kshitij.so 5307 
 
20873 kshitij.so 5308 
  def process_setWalletAmountInCart(self, seqid, iprot, oprot):
5309 
    args = setWalletAmountInCart_args()
5310 
    args.read(iprot)
5311 
    iprot.readMessageEnd()
5312 
    result = setWalletAmountInCart_result()
5313 
    result.success = self._handler.setWalletAmountInCart(args.cartId, args.wallet_amount)
5314 
    oprot.writeMessageBegin("setWalletAmountInCart", TMessageType.REPLY, seqid)
5315 
    result.write(oprot)
5316 
    oprot.writeMessageEnd()
5317 
    oprot.trans.flush()
19889 manas 5318 
 
20873 kshitij.so 5319 
 
94 ashish 5320 
# HELPER FUNCTIONS AND STRUCTURES
5321 
 
559 chandransh 5322 
class createAnonymousUser_args:
94 ashish 5323 
  """
5324 
  Attributes:
559 chandransh 5325 
   - jsessionId
94 ashish 5326 
  """
5327 
 
5328 
  thrift_spec = (
5329 
    None, # 0
559 chandransh 5330 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5331 
  )
5332 
 
559 chandransh 5333 
  def __init__(self, jsessionId=None,):
5334 
    self.jsessionId = jsessionId
94 ashish 5335 
 
5336 
  def read(self, iprot):
5337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5339 
      return
5340 
    iprot.readStructBegin()
5341 
    while True:
5342 
      (fname, ftype, fid) = iprot.readFieldBegin()
5343 
      if ftype == TType.STOP:
5344 
        break
5345 
      if fid == 1:
559 chandransh 5346 
        if ftype == TType.STRING:
5347 
          self.jsessionId = iprot.readString();
94 ashish 5348 
        else:
5349 
          iprot.skip(ftype)
5350 
      else:
5351 
        iprot.skip(ftype)
5352 
      iprot.readFieldEnd()
5353 
    iprot.readStructEnd()
5354 
 
5355 
  def write(self, oprot):
5356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5358 
      return
559 chandransh 5359 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5360 
    if self.jsessionId is not None:
559 chandransh 5361 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5362 
      oprot.writeString(self.jsessionId)
94 ashish 5363 
      oprot.writeFieldEnd()
5364 
    oprot.writeFieldStop()
5365 
    oprot.writeStructEnd()
5366 
 
3431 rajveer 5367 
  def validate(self):
5368 
    return
5369 
 
5370 
 
94 ashish 5371 
  def __repr__(self):
5372 
    L = ['%s=%r' % (key, value)
5373 
      for key, value in self.__dict__.iteritems()]
5374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5375 
 
5376 
  def __eq__(self, other):
5377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5378 
 
5379 
  def __ne__(self, other):
5380 
    return not (self == other)
5381 
 
559 chandransh 5382 
class createAnonymousUser_result:
94 ashish 5383 
  """
5384 
  Attributes:
5385 
   - success
559 chandransh 5386 
   - ucex
94 ashish 5387 
  """
5388 
 
5389 
  thrift_spec = (
559 chandransh 5390 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5391 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5392 
  )
5393 
 
559 chandransh 5394 
  def __init__(self, success=None, ucex=None,):
94 ashish 5395 
    self.success = success
559 chandransh 5396 
    self.ucex = ucex
94 ashish 5397 
 
5398 
  def read(self, iprot):
5399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5401 
      return
5402 
    iprot.readStructBegin()
5403 
    while True:
5404 
      (fname, ftype, fid) = iprot.readFieldBegin()
5405 
      if ftype == TType.STOP:
5406 
        break
5407 
      if fid == 0:
5408 
        if ftype == TType.STRUCT:
559 chandransh 5409 
          self.success = User()
94 ashish 5410 
          self.success.read(iprot)
5411 
        else:
5412 
          iprot.skip(ftype)
5413 
      elif fid == 1:
5414 
        if ftype == TType.STRUCT:
559 chandransh 5415 
          self.ucex = UserContextException()
5416 
          self.ucex.read(iprot)
94 ashish 5417 
        else:
5418 
          iprot.skip(ftype)
5419 
      else:
5420 
        iprot.skip(ftype)
5421 
      iprot.readFieldEnd()
5422 
    iprot.readStructEnd()
5423 
 
5424 
  def write(self, oprot):
5425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5427 
      return
559 chandransh 5428 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5429 
    if self.success is not None:
94 ashish 5430 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5431 
      self.success.write(oprot)
5432 
      oprot.writeFieldEnd()
3431 rajveer 5433 
    if self.ucex is not None:
559 chandransh 5434 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5435 
      self.ucex.write(oprot)
94 ashish 5436 
      oprot.writeFieldEnd()
5437 
    oprot.writeFieldStop()
5438 
    oprot.writeStructEnd()
5439 
 
3431 rajveer 5440 
  def validate(self):
5441 
    return
5442 
 
5443 
 
94 ashish 5444 
  def __repr__(self):
5445 
    L = ['%s=%r' % (key, value)
5446 
      for key, value in self.__dict__.iteritems()]
5447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5448 
 
5449 
  def __eq__(self, other):
5450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5451 
 
5452 
  def __ne__(self, other):
5453 
    return not (self == other)
5454 
 
559 chandransh 5455 
class getUserById_args:
94 ashish 5456 
  """
5457 
  Attributes:
5458 
   - userId
5459 
  """
5460 
 
5461 
  thrift_spec = (
5462 
    None, # 0
5463 
    (1, TType.I64, 'userId', None, None, ), # 1
5464 
  )
5465 
 
559 chandransh 5466 
  def __init__(self, userId=None,):
94 ashish 5467 
    self.userId = userId
5468 
 
5469 
  def read(self, iprot):
5470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5472 
      return
5473 
    iprot.readStructBegin()
5474 
    while True:
5475 
      (fname, ftype, fid) = iprot.readFieldBegin()
5476 
      if ftype == TType.STOP:
5477 
        break
5478 
      if fid == 1:
5479 
        if ftype == TType.I64:
5480 
          self.userId = iprot.readI64();
5481 
        else:
5482 
          iprot.skip(ftype)
5483 
      else:
5484 
        iprot.skip(ftype)
5485 
      iprot.readFieldEnd()
5486 
    iprot.readStructEnd()
5487 
 
5488 
  def write(self, oprot):
5489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5491 
      return
559 chandransh 5492 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5493 
    if self.userId is not None:
94 ashish 5494 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5495 
      oprot.writeI64(self.userId)
5496 
      oprot.writeFieldEnd()
5497 
    oprot.writeFieldStop()
5498 
    oprot.writeStructEnd()
5499 
 
3431 rajveer 5500 
  def validate(self):
5501 
    return
5502 
 
5503 
 
94 ashish 5504 
  def __repr__(self):
5505 
    L = ['%s=%r' % (key, value)
5506 
      for key, value in self.__dict__.iteritems()]
5507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5508 
 
5509 
  def __eq__(self, other):
5510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5511 
 
5512 
  def __ne__(self, other):
5513 
    return not (self == other)
5514 
 
559 chandransh 5515 
class getUserById_result:
94 ashish 5516 
  """
5517 
  Attributes:
5518 
   - success
559 chandransh 5519 
   - ucex
94 ashish 5520 
  """
5521 
 
5522 
  thrift_spec = (
559 chandransh 5523 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5524 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5525 
  )
5526 
 
559 chandransh 5527 
  def __init__(self, success=None, ucex=None,):
94 ashish 5528 
    self.success = success
559 chandransh 5529 
    self.ucex = ucex
94 ashish 5530 
 
5531 
  def read(self, iprot):
5532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5534 
      return
5535 
    iprot.readStructBegin()
5536 
    while True:
5537 
      (fname, ftype, fid) = iprot.readFieldBegin()
5538 
      if ftype == TType.STOP:
5539 
        break
5540 
      if fid == 0:
5541 
        if ftype == TType.STRUCT:
559 chandransh 5542 
          self.success = User()
94 ashish 5543 
          self.success.read(iprot)
5544 
        else:
5545 
          iprot.skip(ftype)
5546 
      elif fid == 1:
5547 
        if ftype == TType.STRUCT:
559 chandransh 5548 
          self.ucex = UserContextException()
5549 
          self.ucex.read(iprot)
94 ashish 5550 
        else:
5551 
          iprot.skip(ftype)
5552 
      else:
5553 
        iprot.skip(ftype)
5554 
      iprot.readFieldEnd()
5555 
    iprot.readStructEnd()
5556 
 
5557 
  def write(self, oprot):
5558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5560 
      return
559 chandransh 5561 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5562 
    if self.success is not None:
94 ashish 5563 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5564 
      self.success.write(oprot)
5565 
      oprot.writeFieldEnd()
3431 rajveer 5566 
    if self.ucex is not None:
559 chandransh 5567 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5568 
      self.ucex.write(oprot)
94 ashish 5569 
      oprot.writeFieldEnd()
5570 
    oprot.writeFieldStop()
5571 
    oprot.writeStructEnd()
5572 
 
3431 rajveer 5573 
  def validate(self):
5574 
    return
5575 
 
5576 
 
94 ashish 5577 
  def __repr__(self):
5578 
    L = ['%s=%r' % (key, value)
5579 
      for key, value in self.__dict__.iteritems()]
5580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5581 
 
5582 
  def __eq__(self, other):
5583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5584 
 
5585 
  def __ne__(self, other):
5586 
    return not (self == other)
5587 
 
5326 rajveer 5588 
class getUserByCartId_args:
1491 vikas 5589 
  """
5590 
  Attributes:
5326 rajveer 5591 
   - cartId
1491 vikas 5592 
  """
5593 
 
5594 
  thrift_spec = (
5595 
    None, # 0
5326 rajveer 5596 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5597 
  )
5598 
 
5326 rajveer 5599 
  def __init__(self, cartId=None,):
5600 
    self.cartId = cartId
1491 vikas 5601 
 
5602 
  def read(self, iprot):
5603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5605 
      return
5606 
    iprot.readStructBegin()
5607 
    while True:
5608 
      (fname, ftype, fid) = iprot.readFieldBegin()
5609 
      if ftype == TType.STOP:
5610 
        break
5611 
      if fid == 1:
5326 rajveer 5612 
        if ftype == TType.I64:
5613 
          self.cartId = iprot.readI64();
1491 vikas 5614 
        else:
5615 
          iprot.skip(ftype)
5616 
      else:
5617 
        iprot.skip(ftype)
5618 
      iprot.readFieldEnd()
5619 
    iprot.readStructEnd()
5620 
 
5621 
  def write(self, oprot):
5622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5624 
      return
5326 rajveer 5625 
    oprot.writeStructBegin('getUserByCartId_args')
5626 
    if self.cartId is not None:
5627 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5628 
      oprot.writeI64(self.cartId)
1491 vikas 5629 
      oprot.writeFieldEnd()
5630 
    oprot.writeFieldStop()
5631 
    oprot.writeStructEnd()
5632 
 
3431 rajveer 5633 
  def validate(self):
5634 
    return
5635 
 
5636 
 
1491 vikas 5637 
  def __repr__(self):
5638 
    L = ['%s=%r' % (key, value)
5639 
      for key, value in self.__dict__.iteritems()]
5640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5641 
 
5642 
  def __eq__(self, other):
5643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5644 
 
5645 
  def __ne__(self, other):
5646 
    return not (self == other)
5647 
 
5326 rajveer 5648 
class getUserByCartId_result:
1491 vikas 5649 
  """
5650 
  Attributes:
5651 
   - success
5652 
   - ucex
5653 
  """
5654 
 
5655 
  thrift_spec = (
5656 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5657 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5658 
  )
5659 
 
5660 
  def __init__(self, success=None, ucex=None,):
5661 
    self.success = success
5662 
    self.ucex = ucex
5663 
 
5664 
  def read(self, iprot):
5665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5667 
      return
5668 
    iprot.readStructBegin()
5669 
    while True:
5670 
      (fname, ftype, fid) = iprot.readFieldBegin()
5671 
      if ftype == TType.STOP:
5672 
        break
5673 
      if fid == 0:
5674 
        if ftype == TType.STRUCT:
5675 
          self.success = User()
5676 
          self.success.read(iprot)
5677 
        else:
5678 
          iprot.skip(ftype)
5679 
      elif fid == 1:
5680 
        if ftype == TType.STRUCT:
5681 
          self.ucex = UserContextException()
5682 
          self.ucex.read(iprot)
5683 
        else:
5684 
          iprot.skip(ftype)
5685 
      else:
5686 
        iprot.skip(ftype)
5687 
      iprot.readFieldEnd()
5688 
    iprot.readStructEnd()
5689 
 
5690 
  def write(self, oprot):
5691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5693 
      return
5326 rajveer 5694 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5695 
    if self.success is not None:
1491 vikas 5696 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5697 
      self.success.write(oprot)
5698 
      oprot.writeFieldEnd()
3431 rajveer 5699 
    if self.ucex is not None:
1491 vikas 5700 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5701 
      self.ucex.write(oprot)
5702 
      oprot.writeFieldEnd()
5703 
    oprot.writeFieldStop()
5704 
    oprot.writeStructEnd()
5705 
 
3431 rajveer 5706 
  def validate(self):
5707 
    return
5708 
 
5709 
 
1491 vikas 5710 
  def __repr__(self):
5711 
    L = ['%s=%r' % (key, value)
5712 
      for key, value in self.__dict__.iteritems()]
5713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5714 
 
5715 
  def __eq__(self, other):
5716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5717 
 
5718 
  def __ne__(self, other):
5719 
    return not (self == other)
5720 
 
5326 rajveer 5721 
class getUserByEmail_args:
3032 mandeep.dh 5722 
  """
5723 
  Attributes:
5326 rajveer 5724 
   - email
3032 mandeep.dh 5725 
  """
5726 
 
5727 
  thrift_spec = (
5728 
    None, # 0
5326 rajveer 5729 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5730 
  )
5731 
 
5326 rajveer 5732 
  def __init__(self, email=None,):
5733 
    self.email = email
3032 mandeep.dh 5734 
 
5735 
  def read(self, iprot):
5736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5738 
      return
5739 
    iprot.readStructBegin()
5740 
    while True:
5741 
      (fname, ftype, fid) = iprot.readFieldBegin()
5742 
      if ftype == TType.STOP:
5743 
        break
5744 
      if fid == 1:
5326 rajveer 5745 
        if ftype == TType.STRING:
5746 
          self.email = iprot.readString();
3032 mandeep.dh 5747 
        else:
5748 
          iprot.skip(ftype)
5749 
      else:
5750 
        iprot.skip(ftype)
5751 
      iprot.readFieldEnd()
5752 
    iprot.readStructEnd()
5753 
 
5754 
  def write(self, oprot):
5755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5757 
      return
5326 rajveer 5758 
    oprot.writeStructBegin('getUserByEmail_args')
5759 
    if self.email is not None:
5760 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5761 
      oprot.writeString(self.email)
3032 mandeep.dh 5762 
      oprot.writeFieldEnd()
5763 
    oprot.writeFieldStop()
5764 
    oprot.writeStructEnd()
5765 
 
3431 rajveer 5766 
  def validate(self):
5767 
    return
5768 
 
5769 
 
3032 mandeep.dh 5770 
  def __repr__(self):
5771 
    L = ['%s=%r' % (key, value)
5772 
      for key, value in self.__dict__.iteritems()]
5773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5774 
 
5775 
  def __eq__(self, other):
5776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5777 
 
5778 
  def __ne__(self, other):
5779 
    return not (self == other)
5780 
 
5326 rajveer 5781 
class getUserByEmail_result:
3032 mandeep.dh 5782 
  """
5783 
  Attributes:
5784 
   - success
5785 
   - ucex
5786 
  """
5787 
 
5788 
  thrift_spec = (
5789 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5790 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5791 
  )
5792 
 
5793 
  def __init__(self, success=None, ucex=None,):
5794 
    self.success = success
5795 
    self.ucex = ucex
5796 
 
5797 
  def read(self, iprot):
5798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5800 
      return
5801 
    iprot.readStructBegin()
5802 
    while True:
5803 
      (fname, ftype, fid) = iprot.readFieldBegin()
5804 
      if ftype == TType.STOP:
5805 
        break
5806 
      if fid == 0:
5807 
        if ftype == TType.STRUCT:
5808 
          self.success = User()
5809 
          self.success.read(iprot)
5810 
        else:
5811 
          iprot.skip(ftype)
5812 
      elif fid == 1:
5813 
        if ftype == TType.STRUCT:
5814 
          self.ucex = UserContextException()
5815 
          self.ucex.read(iprot)
5816 
        else:
5817 
          iprot.skip(ftype)
5818 
      else:
5819 
        iprot.skip(ftype)
5820 
      iprot.readFieldEnd()
5821 
    iprot.readStructEnd()
5822 
 
5823 
  def write(self, oprot):
5824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5826 
      return
5326 rajveer 5827 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5828 
    if self.success is not None:
3032 mandeep.dh 5829 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5830 
      self.success.write(oprot)
5831 
      oprot.writeFieldEnd()
3431 rajveer 5832 
    if self.ucex is not None:
3032 mandeep.dh 5833 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5834 
      self.ucex.write(oprot)
5835 
      oprot.writeFieldEnd()
5836 
    oprot.writeFieldStop()
5837 
    oprot.writeStructEnd()
5838 
 
3431 rajveer 5839 
  def validate(self):
5840 
    return
5841 
 
5842 
 
3032 mandeep.dh 5843 
  def __repr__(self):
5844 
    L = ['%s=%r' % (key, value)
5845 
      for key, value in self.__dict__.iteritems()]
5846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5847 
 
5848 
  def __eq__(self, other):
5849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5850 
 
5851 
  def __ne__(self, other):
5852 
    return not (self == other)
5853 
 
5326 rajveer 5854 
class getUserByMobileNumber_args:
94 ashish 5855 
  """
5856 
  Attributes:
5326 rajveer 5857 
   - mobileNumber
94 ashish 5858 
  """
5859 
 
5860 
  thrift_spec = (
5861 
    None, # 0
5326 rajveer 5862 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5863 
  )
5864 
 
5326 rajveer 5865 
  def __init__(self, mobileNumber=None,):
5866 
    self.mobileNumber = mobileNumber
94 ashish 5867 
 
5868 
  def read(self, iprot):
5869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5871 
      return
5872 
    iprot.readStructBegin()
5873 
    while True:
5874 
      (fname, ftype, fid) = iprot.readFieldBegin()
5875 
      if ftype == TType.STOP:
5876 
        break
5877 
      if fid == 1:
5326 rajveer 5878 
        if ftype == TType.I64:
5879 
          self.mobileNumber = iprot.readI64();
94 ashish 5880 
        else:
5881 
          iprot.skip(ftype)
5882 
      else:
5883 
        iprot.skip(ftype)
5884 
      iprot.readFieldEnd()
5885 
    iprot.readStructEnd()
5886 
 
5887 
  def write(self, oprot):
5888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5890 
      return
5326 rajveer 5891 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5892 
    if self.mobileNumber is not None:
5893 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5894 
      oprot.writeI64(self.mobileNumber)
94 ashish 5895 
      oprot.writeFieldEnd()
5896 
    oprot.writeFieldStop()
5897 
    oprot.writeStructEnd()
5898 
 
3431 rajveer 5899 
  def validate(self):
5900 
    return
5901 
 
5902 
 
94 ashish 5903 
  def __repr__(self):
5904 
    L = ['%s=%r' % (key, value)
5905 
      for key, value in self.__dict__.iteritems()]
5906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5907 
 
5908 
  def __eq__(self, other):
5909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5910 
 
5911 
  def __ne__(self, other):
5912 
    return not (self == other)
5913 
 
5326 rajveer 5914 
class getUserByMobileNumber_result:
94 ashish 5915 
  """
5916 
  Attributes:
5917 
   - success
559 chandransh 5918 
   - ucex
94 ashish 5919 
  """
5920 
 
5921 
  thrift_spec = (
559 chandransh 5922 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5923 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5924 
  )
5925 
 
559 chandransh 5926 
  def __init__(self, success=None, ucex=None,):
94 ashish 5927 
    self.success = success
559 chandransh 5928 
    self.ucex = ucex
94 ashish 5929 
 
5930 
  def read(self, iprot):
5931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5933 
      return
5934 
    iprot.readStructBegin()
5935 
    while True:
5936 
      (fname, ftype, fid) = iprot.readFieldBegin()
5937 
      if ftype == TType.STOP:
5938 
        break
5939 
      if fid == 0:
5940 
        if ftype == TType.STRUCT:
559 chandransh 5941 
          self.success = User()
94 ashish 5942 
          self.success.read(iprot)
5943 
        else:
5944 
          iprot.skip(ftype)
5945 
      elif fid == 1:
5946 
        if ftype == TType.STRUCT:
559 chandransh 5947 
          self.ucex = UserContextException()
5948 
          self.ucex.read(iprot)
94 ashish 5949 
        else:
5950 
          iprot.skip(ftype)
5951 
      else:
5952 
        iprot.skip(ftype)
5953 
      iprot.readFieldEnd()
5954 
    iprot.readStructEnd()
5955 
 
5956 
  def write(self, oprot):
5957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5959 
      return
5326 rajveer 5960 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5961 
    if self.success is not None:
94 ashish 5962 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5963 
      self.success.write(oprot)
5964 
      oprot.writeFieldEnd()
3431 rajveer 5965 
    if self.ucex is not None:
559 chandransh 5966 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5967 
      self.ucex.write(oprot)
94 ashish 5968 
      oprot.writeFieldEnd()
5969 
    oprot.writeFieldStop()
5970 
    oprot.writeStructEnd()
5971 
 
3431 rajveer 5972 
  def validate(self):
5973 
    return
5974 
 
5975 
 
94 ashish 5976 
  def __repr__(self):
5977 
    L = ['%s=%r' % (key, value)
5978 
      for key, value in self.__dict__.iteritems()]
5979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5980 
 
5981 
  def __eq__(self, other):
5982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5983 
 
5984 
  def __ne__(self, other):
5985 
    return not (self == other)
5986 
 
5326 rajveer 5987 
class createUser_args:
94 ashish 5988 
  """
5989 
  Attributes:
559 chandransh 5990 
   - user
94 ashish 5991 
  """
5992 
 
5993 
  thrift_spec = (
5994 
    None, # 0
559 chandransh 5995 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5996 
  )
5997 
 
559 chandransh 5998 
  def __init__(self, user=None,):
5999 
    self.user = user
94 ashish 6000 
 
6001 
  def read(self, iprot):
6002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6004 
      return
6005 
    iprot.readStructBegin()
6006 
    while True:
6007 
      (fname, ftype, fid) = iprot.readFieldBegin()
6008 
      if ftype == TType.STOP:
6009 
        break
6010 
      if fid == 1:
559 chandransh 6011 
        if ftype == TType.STRUCT:
6012 
          self.user = User()
6013 
          self.user.read(iprot)
94 ashish 6014 
        else:
6015 
          iprot.skip(ftype)
6016 
      else:
6017 
        iprot.skip(ftype)
6018 
      iprot.readFieldEnd()
6019 
    iprot.readStructEnd()
6020 
 
6021 
  def write(self, oprot):
6022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6024 
      return
5326 rajveer 6025 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 6026 
    if self.user is not None:
559 chandransh 6027 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6028 
      self.user.write(oprot)
94 ashish 6029 
      oprot.writeFieldEnd()
6030 
    oprot.writeFieldStop()
6031 
    oprot.writeStructEnd()
6032 
 
3431 rajveer 6033 
  def validate(self):
6034 
    return
6035 
 
6036 
 
94 ashish 6037 
  def __repr__(self):
6038 
    L = ['%s=%r' % (key, value)
6039 
      for key, value in self.__dict__.iteritems()]
6040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6041 
 
6042 
  def __eq__(self, other):
6043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6044 
 
6045 
  def __ne__(self, other):
6046 
    return not (self == other)
6047 
 
5326 rajveer 6048 
class createUser_result:
94 ashish 6049 
  """
6050 
  Attributes:
6051 
   - success
559 chandransh 6052 
   - ucex
94 ashish 6053 
  """
6054 
 
6055 
  thrift_spec = (
559 chandransh 6056 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6057 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6058 
  )
6059 
 
559 chandransh 6060 
  def __init__(self, success=None, ucex=None,):
94 ashish 6061 
    self.success = success
559 chandransh 6062 
    self.ucex = ucex
94 ashish 6063 
 
6064 
  def read(self, iprot):
6065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6067 
      return
6068 
    iprot.readStructBegin()
6069 
    while True:
6070 
      (fname, ftype, fid) = iprot.readFieldBegin()
6071 
      if ftype == TType.STOP:
6072 
        break
6073 
      if fid == 0:
6074 
        if ftype == TType.STRUCT:
559 chandransh 6075 
          self.success = User()
94 ashish 6076 
          self.success.read(iprot)
6077 
        else:
6078 
          iprot.skip(ftype)
6079 
      elif fid == 1:
6080 
        if ftype == TType.STRUCT:
559 chandransh 6081 
          self.ucex = UserContextException()
6082 
          self.ucex.read(iprot)
94 ashish 6083 
        else:
6084 
          iprot.skip(ftype)
6085 
      else:
6086 
        iprot.skip(ftype)
6087 
      iprot.readFieldEnd()
6088 
    iprot.readStructEnd()
6089 
 
6090 
  def write(self, oprot):
6091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6093 
      return
5326 rajveer 6094 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 6095 
    if self.success is not None:
94 ashish 6096 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6097 
      self.success.write(oprot)
6098 
      oprot.writeFieldEnd()
3431 rajveer 6099 
    if self.ucex is not None:
559 chandransh 6100 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6101 
      self.ucex.write(oprot)
94 ashish 6102 
      oprot.writeFieldEnd()
6103 
    oprot.writeFieldStop()
6104 
    oprot.writeStructEnd()
6105 
 
3431 rajveer 6106 
  def validate(self):
6107 
    return
6108 
 
6109 
 
94 ashish 6110 
  def __repr__(self):
6111 
    L = ['%s=%r' % (key, value)
6112 
      for key, value in self.__dict__.iteritems()]
6113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6114 
 
6115 
  def __eq__(self, other):
6116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6117 
 
6118 
  def __ne__(self, other):
6119 
    return not (self == other)
6120 
 
5326 rajveer 6121 
class updateUser_args:
94 ashish 6122 
  """
6123 
  Attributes:
5326 rajveer 6124 
   - user
94 ashish 6125 
  """
6126 
 
6127 
  thrift_spec = (
6128 
    None, # 0
5326 rajveer 6129 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6130 
  )
6131 
 
5326 rajveer 6132 
  def __init__(self, user=None,):
6133 
    self.user = user
94 ashish 6134 
 
6135 
  def read(self, iprot):
6136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6138 
      return
6139 
    iprot.readStructBegin()
6140 
    while True:
6141 
      (fname, ftype, fid) = iprot.readFieldBegin()
6142 
      if ftype == TType.STOP:
6143 
        break
6144 
      if fid == 1:
5326 rajveer 6145 
        if ftype == TType.STRUCT:
6146 
          self.user = User()
6147 
          self.user.read(iprot)
94 ashish 6148 
        else:
6149 
          iprot.skip(ftype)
6150 
      else:
6151 
        iprot.skip(ftype)
6152 
      iprot.readFieldEnd()
6153 
    iprot.readStructEnd()
6154 
 
6155 
  def write(self, oprot):
6156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6158 
      return
5326 rajveer 6159 
    oprot.writeStructBegin('updateUser_args')
6160 
    if self.user is not None:
6161 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6162 
      self.user.write(oprot)
94 ashish 6163 
      oprot.writeFieldEnd()
6164 
    oprot.writeFieldStop()
6165 
    oprot.writeStructEnd()
6166 
 
3431 rajveer 6167 
  def validate(self):
6168 
    return
6169 
 
6170 
 
94 ashish 6171 
  def __repr__(self):
6172 
    L = ['%s=%r' % (key, value)
6173 
      for key, value in self.__dict__.iteritems()]
6174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6175 
 
6176 
  def __eq__(self, other):
6177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6178 
 
6179 
  def __ne__(self, other):
6180 
    return not (self == other)
6181 
 
5326 rajveer 6182 
class updateUser_result:
94 ashish 6183 
  """
6184 
  Attributes:
6185 
   - success
559 chandransh 6186 
   - ucex
94 ashish 6187 
  """
6188 
 
6189 
  thrift_spec = (
5326 rajveer 6190 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6191 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6192 
  )
6193 
 
559 chandransh 6194 
  def __init__(self, success=None, ucex=None,):
94 ashish 6195 
    self.success = success
559 chandransh 6196 
    self.ucex = ucex
94 ashish 6197 
 
6198 
  def read(self, iprot):
6199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6201 
      return
6202 
    iprot.readStructBegin()
6203 
    while True:
6204 
      (fname, ftype, fid) = iprot.readFieldBegin()
6205 
      if ftype == TType.STOP:
6206 
        break
6207 
      if fid == 0:
5326 rajveer 6208 
        if ftype == TType.STRUCT:
6209 
          self.success = User()
6210 
          self.success.read(iprot)
94 ashish 6211 
        else:
6212 
          iprot.skip(ftype)
6213 
      elif fid == 1:
6214 
        if ftype == TType.STRUCT:
559 chandransh 6215 
          self.ucex = UserContextException()
6216 
          self.ucex.read(iprot)
94 ashish 6217 
        else:
6218 
          iprot.skip(ftype)
6219 
      else:
6220 
        iprot.skip(ftype)
6221 
      iprot.readFieldEnd()
6222 
    iprot.readStructEnd()
6223 
 
6224 
  def write(self, oprot):
6225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6227 
      return
5326 rajveer 6228 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6229 
    if self.success is not None:
5326 rajveer 6230 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6231 
      self.success.write(oprot)
94 ashish 6232 
      oprot.writeFieldEnd()
3431 rajveer 6233 
    if self.ucex is not None:
559 chandransh 6234 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6235 
      self.ucex.write(oprot)
94 ashish 6236 
      oprot.writeFieldEnd()
6237 
    oprot.writeFieldStop()
6238 
    oprot.writeStructEnd()
6239 
 
3431 rajveer 6240 
  def validate(self):
6241 
    return
6242 
 
6243 
 
94 ashish 6244 
  def __repr__(self):
6245 
    L = ['%s=%r' % (key, value)
6246 
      for key, value in self.__dict__.iteritems()]
6247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6248 
 
6249 
  def __eq__(self, other):
6250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6251 
 
6252 
  def __ne__(self, other):
6253 
    return not (self == other)
6254 
 
559 chandransh 6255 
class authenticateUser_args:
94 ashish 6256 
  """
6257 
  Attributes:
6258 
   - email
6259 
   - password
6260 
  """
6261 
 
6262 
  thrift_spec = (
6263 
    None, # 0
6264 
    (1, TType.STRING, 'email', None, None, ), # 1
6265 
    (2, TType.STRING, 'password', None, None, ), # 2
6266 
  )
6267 
 
6268 
  def __init__(self, email=None, password=None,):
6269 
    self.email = email
6270 
    self.password = password
6271 
 
6272 
  def read(self, iprot):
6273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6275 
      return
6276 
    iprot.readStructBegin()
6277 
    while True:
6278 
      (fname, ftype, fid) = iprot.readFieldBegin()
6279 
      if ftype == TType.STOP:
6280 
        break
6281 
      if fid == 1:
6282 
        if ftype == TType.STRING:
6283 
          self.email = iprot.readString();
6284 
        else:
6285 
          iprot.skip(ftype)
6286 
      elif fid == 2:
6287 
        if ftype == TType.STRING:
6288 
          self.password = iprot.readString();
6289 
        else:
6290 
          iprot.skip(ftype)
6291 
      else:
6292 
        iprot.skip(ftype)
6293 
      iprot.readFieldEnd()
6294 
    iprot.readStructEnd()
6295 
 
6296 
  def write(self, oprot):
6297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6299 
      return
559 chandransh 6300 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6301 
    if self.email is not None:
94 ashish 6302 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6303 
      oprot.writeString(self.email)
6304 
      oprot.writeFieldEnd()
3431 rajveer 6305 
    if self.password is not None:
94 ashish 6306 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6307 
      oprot.writeString(self.password)
6308 
      oprot.writeFieldEnd()
6309 
    oprot.writeFieldStop()
6310 
    oprot.writeStructEnd()
6311 
 
3431 rajveer 6312 
  def validate(self):
6313 
    return
6314 
 
6315 
 
94 ashish 6316 
  def __repr__(self):
6317 
    L = ['%s=%r' % (key, value)
6318 
      for key, value in self.__dict__.iteritems()]
6319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6320 
 
6321 
  def __eq__(self, other):
6322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6323 
 
6324 
  def __ne__(self, other):
6325 
    return not (self == other)
6326 
 
559 chandransh 6327 
class authenticateUser_result:
94 ashish 6328 
  """
6329 
  Attributes:
6330 
   - success
559 chandransh 6331 
   - auex
94 ashish 6332 
  """
6333 
 
6334 
  thrift_spec = (
559 chandransh 6335 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6336 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6337 
  )
6338 
 
559 chandransh 6339 
  def __init__(self, success=None, auex=None,):
94 ashish 6340 
    self.success = success
559 chandransh 6341 
    self.auex = auex
94 ashish 6342 
 
6343 
  def read(self, iprot):
6344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6346 
      return
6347 
    iprot.readStructBegin()
6348 
    while True:
6349 
      (fname, ftype, fid) = iprot.readFieldBegin()
6350 
      if ftype == TType.STOP:
6351 
        break
6352 
      if fid == 0:
6353 
        if ftype == TType.STRUCT:
559 chandransh 6354 
          self.success = User()
94 ashish 6355 
          self.success.read(iprot)
6356 
        else:
6357 
          iprot.skip(ftype)
6358 
      elif fid == 1:
6359 
        if ftype == TType.STRUCT:
559 chandransh 6360 
          self.auex = AuthenticationException()
6361 
          self.auex.read(iprot)
94 ashish 6362 
        else:
6363 
          iprot.skip(ftype)
6364 
      else:
6365 
        iprot.skip(ftype)
6366 
      iprot.readFieldEnd()
6367 
    iprot.readStructEnd()
6368 
 
6369 
  def write(self, oprot):
6370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6372 
      return
559 chandransh 6373 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6374 
    if self.success is not None:
94 ashish 6375 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6376 
      self.success.write(oprot)
6377 
      oprot.writeFieldEnd()
3431 rajveer 6378 
    if self.auex is not None:
559 chandransh 6379 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6380 
      self.auex.write(oprot)
94 ashish 6381 
      oprot.writeFieldEnd()
6382 
    oprot.writeFieldStop()
6383 
    oprot.writeStructEnd()
6384 
 
3431 rajveer 6385 
  def validate(self):
6386 
    return
6387 
 
6388 
 
94 ashish 6389 
  def __repr__(self):
6390 
    L = ['%s=%r' % (key, value)
6391 
      for key, value in self.__dict__.iteritems()]
6392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6393 
 
6394 
  def __eq__(self, other):
6395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6396 
 
6397 
  def __ne__(self, other):
6398 
    return not (self == other)
6399 
 
559 chandransh 6400 
class userExists_args:
122 ashish 6401 
  """
6402 
  Attributes:
559 chandransh 6403 
   - email
122 ashish 6404 
  """
6405 
 
6406 
  thrift_spec = (
6407 
    None, # 0
559 chandransh 6408 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6409 
  )
6410 
 
559 chandransh 6411 
  def __init__(self, email=None,):
6412 
    self.email = email
122 ashish 6413 
 
6414 
  def read(self, iprot):
6415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6417 
      return
6418 
    iprot.readStructBegin()
6419 
    while True:
6420 
      (fname, ftype, fid) = iprot.readFieldBegin()
6421 
      if ftype == TType.STOP:
6422 
        break
6423 
      if fid == 1:
6424 
        if ftype == TType.STRING:
559 chandransh 6425 
          self.email = iprot.readString();
122 ashish 6426 
        else:
6427 
          iprot.skip(ftype)
559 chandransh 6428 
      else:
6429 
        iprot.skip(ftype)
6430 
      iprot.readFieldEnd()
6431 
    iprot.readStructEnd()
6432 
 
6433 
  def write(self, oprot):
6434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6436 
      return
6437 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6438 
    if self.email is not None:
559 chandransh 6439 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6440 
      oprot.writeString(self.email)
6441 
      oprot.writeFieldEnd()
6442 
    oprot.writeFieldStop()
6443 
    oprot.writeStructEnd()
6444 
 
3431 rajveer 6445 
  def validate(self):
6446 
    return
6447 
 
6448 
 
559 chandransh 6449 
  def __repr__(self):
6450 
    L = ['%s=%r' % (key, value)
6451 
      for key, value in self.__dict__.iteritems()]
6452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6453 
 
6454 
  def __eq__(self, other):
6455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6456 
 
6457 
  def __ne__(self, other):
6458 
    return not (self == other)
6459 
 
6460 
class userExists_result:
6461 
  """
6462 
  Attributes:
6463 
   - success
6464 
   - ucx
6465 
  """
6466 
 
6467 
  thrift_spec = (
6468 
    (0, TType.BOOL, 'success', None, None, ), # 0
6469 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6470 
  )
6471 
 
6472 
  def __init__(self, success=None, ucx=None,):
6473 
    self.success = success
6474 
    self.ucx = ucx
6475 
 
6476 
  def read(self, iprot):
6477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6479 
      return
6480 
    iprot.readStructBegin()
6481 
    while True:
6482 
      (fname, ftype, fid) = iprot.readFieldBegin()
6483 
      if ftype == TType.STOP:
6484 
        break
6485 
      if fid == 0:
6486 
        if ftype == TType.BOOL:
6487 
          self.success = iprot.readBool();
6488 
        else:
6489 
          iprot.skip(ftype)
6490 
      elif fid == 1:
6491 
        if ftype == TType.STRUCT:
6492 
          self.ucx = UserContextException()
6493 
          self.ucx.read(iprot)
6494 
        else:
6495 
          iprot.skip(ftype)
6496 
      else:
6497 
        iprot.skip(ftype)
6498 
      iprot.readFieldEnd()
6499 
    iprot.readStructEnd()
6500 
 
6501 
  def write(self, oprot):
6502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6504 
      return
6505 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6506 
    if self.success is not None:
559 chandransh 6507 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6508 
      oprot.writeBool(self.success)
6509 
      oprot.writeFieldEnd()
3431 rajveer 6510 
    if self.ucx is not None:
559 chandransh 6511 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6512 
      self.ucx.write(oprot)
6513 
      oprot.writeFieldEnd()
6514 
    oprot.writeFieldStop()
6515 
    oprot.writeStructEnd()
6516 
 
3431 rajveer 6517 
  def validate(self):
6518 
    return
6519 
 
6520 
 
559 chandransh 6521 
  def __repr__(self):
6522 
    L = ['%s=%r' % (key, value)
6523 
      for key, value in self.__dict__.iteritems()]
6524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6525 
 
6526 
  def __eq__(self, other):
6527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6528 
 
6529 
  def __ne__(self, other):
6530 
    return not (self == other)
6531 
 
6532 
class addAddressForUser_args:
6533 
  """
6534 
  Attributes:
6535 
   - userId
6536 
   - address
6537 
   - setDefault
6538 
  """
6539 
 
6540 
  thrift_spec = (
6541 
    None, # 0
6542 
    (1, TType.I64, 'userId', None, None, ), # 1
6543 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6544 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6545 
  )
6546 
 
567 rajveer 6547 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6548 
    self.userId = userId
6549 
    self.address = address
6550 
    self.setDefault = setDefault
6551 
 
6552 
  def read(self, iprot):
6553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6555 
      return
6556 
    iprot.readStructBegin()
6557 
    while True:
6558 
      (fname, ftype, fid) = iprot.readFieldBegin()
6559 
      if ftype == TType.STOP:
6560 
        break
6561 
      if fid == 1:
6562 
        if ftype == TType.I64:
6563 
          self.userId = iprot.readI64();
6564 
        else:
6565 
          iprot.skip(ftype)
122 ashish 6566 
      elif fid == 2:
559 chandransh 6567 
        if ftype == TType.STRUCT:
6568 
          self.address = Address()
6569 
          self.address.read(iprot)
122 ashish 6570 
        else:
6571 
          iprot.skip(ftype)
6572 
      elif fid == 3:
6573 
        if ftype == TType.BOOL:
559 chandransh 6574 
          self.setDefault = iprot.readBool();
122 ashish 6575 
        else:
6576 
          iprot.skip(ftype)
6577 
      else:
6578 
        iprot.skip(ftype)
6579 
      iprot.readFieldEnd()
6580 
    iprot.readStructEnd()
6581 
 
6582 
  def write(self, oprot):
6583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6585 
      return
559 chandransh 6586 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6587 
    if self.userId is not None:
559 chandransh 6588 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6589 
      oprot.writeI64(self.userId)
122 ashish 6590 
      oprot.writeFieldEnd()
3431 rajveer 6591 
    if self.address is not None:
559 chandransh 6592 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6593 
      self.address.write(oprot)
122 ashish 6594 
      oprot.writeFieldEnd()
3431 rajveer 6595 
    if self.setDefault is not None:
567 rajveer 6596 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6597 
      oprot.writeBool(self.setDefault)
6598 
      oprot.writeFieldEnd()
122 ashish 6599 
    oprot.writeFieldStop()
6600 
    oprot.writeStructEnd()
6601 
 
3431 rajveer 6602 
  def validate(self):
6603 
    return
6604 
 
6605 
 
122 ashish 6606 
  def __repr__(self):
6607 
    L = ['%s=%r' % (key, value)
6608 
      for key, value in self.__dict__.iteritems()]
6609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6610 
 
6611 
  def __eq__(self, other):
6612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6613 
 
6614 
  def __ne__(self, other):
6615 
    return not (self == other)
6616 
 
559 chandransh 6617 
class addAddressForUser_result:
122 ashish 6618 
  """
6619 
  Attributes:
6620 
   - success
559 chandransh 6621 
   - ucx
122 ashish 6622 
  """
6623 
 
6624 
  thrift_spec = (
567 rajveer 6625 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6626 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6627 
  )
6628 
 
559 chandransh 6629 
  def __init__(self, success=None, ucx=None,):
122 ashish 6630 
    self.success = success
559 chandransh 6631 
    self.ucx = ucx
122 ashish 6632 
 
6633 
  def read(self, iprot):
6634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6636 
      return
6637 
    iprot.readStructBegin()
6638 
    while True:
6639 
      (fname, ftype, fid) = iprot.readFieldBegin()
6640 
      if ftype == TType.STOP:
6641 
        break
6642 
      if fid == 0:
567 rajveer 6643 
        if ftype == TType.I64:
6644 
          self.success = iprot.readI64();
122 ashish 6645 
        else:
6646 
          iprot.skip(ftype)
6647 
      elif fid == 1:
6648 
        if ftype == TType.STRUCT:
559 chandransh 6649 
          self.ucx = UserContextException()
6650 
          self.ucx.read(iprot)
122 ashish 6651 
        else:
6652 
          iprot.skip(ftype)
6653 
      else:
6654 
        iprot.skip(ftype)
6655 
      iprot.readFieldEnd()
6656 
    iprot.readStructEnd()
6657 
 
6658 
  def write(self, oprot):
6659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6661 
      return
559 chandransh 6662 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6663 
    if self.success is not None:
567 rajveer 6664 
      oprot.writeFieldBegin('success', TType.I64, 0)
6665 
      oprot.writeI64(self.success)
122 ashish 6666 
      oprot.writeFieldEnd()
3431 rajveer 6667 
    if self.ucx is not None:
559 chandransh 6668 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6669 
      self.ucx.write(oprot)
122 ashish 6670 
      oprot.writeFieldEnd()
6671 
    oprot.writeFieldStop()
6672 
    oprot.writeStructEnd()
6673 
 
3431 rajveer 6674 
  def validate(self):
6675 
    return
6676 
 
6677 
 
122 ashish 6678 
  def __repr__(self):
6679 
    L = ['%s=%r' % (key, value)
6680 
      for key, value in self.__dict__.iteritems()]
6681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6682 
 
6683 
  def __eq__(self, other):
6684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6685 
 
6686 
  def __ne__(self, other):
6687 
    return not (self == other)
6688 
 
559 chandransh 6689 
class removeAddressForUser_args:
94 ashish 6690 
  """
6691 
  Attributes:
559 chandransh 6692 
   - userid
6693 
   - addressId
94 ashish 6694 
  """
6695 
 
6696 
  thrift_spec = (
6697 
    None, # 0
559 chandransh 6698 
    (1, TType.I64, 'userid', None, None, ), # 1
6699 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6700 
  )
6701 
 
559 chandransh 6702 
  def __init__(self, userid=None, addressId=None,):
6703 
    self.userid = userid
6704 
    self.addressId = addressId
94 ashish 6705 
 
6706 
  def read(self, iprot):
6707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6709 
      return
6710 
    iprot.readStructBegin()
6711 
    while True:
6712 
      (fname, ftype, fid) = iprot.readFieldBegin()
6713 
      if ftype == TType.STOP:
6714 
        break
6715 
      if fid == 1:
559 chandransh 6716 
        if ftype == TType.I64:
6717 
          self.userid = iprot.readI64();
94 ashish 6718 
        else:
6719 
          iprot.skip(ftype)
559 chandransh 6720 
      elif fid == 2:
6721 
        if ftype == TType.I64:
6722 
          self.addressId = iprot.readI64();
6723 
        else:
6724 
          iprot.skip(ftype)
94 ashish 6725 
      else:
6726 
        iprot.skip(ftype)
6727 
      iprot.readFieldEnd()
6728 
    iprot.readStructEnd()
6729 
 
6730 
  def write(self, oprot):
6731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6733 
      return
559 chandransh 6734 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6735 
    if self.userid is not None:
559 chandransh 6736 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6737 
      oprot.writeI64(self.userid)
94 ashish 6738 
      oprot.writeFieldEnd()
3431 rajveer 6739 
    if self.addressId is not None:
559 chandransh 6740 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6741 
      oprot.writeI64(self.addressId)
6742 
      oprot.writeFieldEnd()
94 ashish 6743 
    oprot.writeFieldStop()
6744 
    oprot.writeStructEnd()
6745 
 
3431 rajveer 6746 
  def validate(self):
6747 
    return
6748 
 
6749 
 
94 ashish 6750 
  def __repr__(self):
6751 
    L = ['%s=%r' % (key, value)
6752 
      for key, value in self.__dict__.iteritems()]
6753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6754 
 
6755 
  def __eq__(self, other):
6756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6757 
 
6758 
  def __ne__(self, other):
6759 
    return not (self == other)
6760 
 
559 chandransh 6761 
class removeAddressForUser_result:
94 ashish 6762 
  """
6763 
  Attributes:
6764 
   - success
6765 
   - ucx
6766 
  """
6767 
 
6768 
  thrift_spec = (
6769 
    (0, TType.BOOL, 'success', None, None, ), # 0
6770 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6771 
  )
6772 
 
6773 
  def __init__(self, success=None, ucx=None,):
6774 
    self.success = success
6775 
    self.ucx = ucx
6776 
 
6777 
  def read(self, iprot):
6778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6780 
      return
6781 
    iprot.readStructBegin()
6782 
    while True:
6783 
      (fname, ftype, fid) = iprot.readFieldBegin()
6784 
      if ftype == TType.STOP:
6785 
        break
6786 
      if fid == 0:
6787 
        if ftype == TType.BOOL:
6788 
          self.success = iprot.readBool();
6789 
        else:
6790 
          iprot.skip(ftype)
6791 
      elif fid == 1:
6792 
        if ftype == TType.STRUCT:
6793 
          self.ucx = UserContextException()
6794 
          self.ucx.read(iprot)
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      else:
6798 
        iprot.skip(ftype)
6799 
      iprot.readFieldEnd()
6800 
    iprot.readStructEnd()
6801 
 
6802 
  def write(self, oprot):
6803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6805 
      return
559 chandransh 6806 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6807 
    if self.success is not None:
94 ashish 6808 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6809 
      oprot.writeBool(self.success)
6810 
      oprot.writeFieldEnd()
3431 rajveer 6811 
    if self.ucx is not None:
94 ashish 6812 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6813 
      self.ucx.write(oprot)
6814 
      oprot.writeFieldEnd()
6815 
    oprot.writeFieldStop()
6816 
    oprot.writeStructEnd()
6817 
 
3431 rajveer 6818 
  def validate(self):
6819 
    return
6820 
 
6821 
 
94 ashish 6822 
  def __repr__(self):
6823 
    L = ['%s=%r' % (key, value)
6824 
      for key, value in self.__dict__.iteritems()]
6825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6826 
 
6827 
  def __eq__(self, other):
6828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6829 
 
6830 
  def __ne__(self, other):
6831 
    return not (self == other)
6832 
 
22358 ashik.ali 6833 
class updateAddress_args:
6834 
  """
6835 
  Attributes:
6836 
   - address
6837 
  """
6838 
 
6839 
  thrift_spec = (
6840 
    None, # 0
6841 
    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
6842 
  )
6843 
 
6844 
  def __init__(self, address=None,):
6845 
    self.address = address
6846 
 
6847 
  def read(self, iprot):
6848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6850 
      return
6851 
    iprot.readStructBegin()
6852 
    while True:
6853 
      (fname, ftype, fid) = iprot.readFieldBegin()
6854 
      if ftype == TType.STOP:
6855 
        break
6856 
      if fid == 1:
6857 
        if ftype == TType.STRUCT:
6858 
          self.address = Address()
6859 
          self.address.read(iprot)
6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      else:
6863 
        iprot.skip(ftype)
6864 
      iprot.readFieldEnd()
6865 
    iprot.readStructEnd()
6866 
 
6867 
  def write(self, oprot):
6868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6870 
      return
6871 
    oprot.writeStructBegin('updateAddress_args')
6872 
    if self.address is not None:
6873 
      oprot.writeFieldBegin('address', TType.STRUCT, 1)
6874 
      self.address.write(oprot)
6875 
      oprot.writeFieldEnd()
6876 
    oprot.writeFieldStop()
6877 
    oprot.writeStructEnd()
6878 
 
6879 
  def validate(self):
6880 
    return
6881 
 
6882 
 
6883 
  def __repr__(self):
6884 
    L = ['%s=%r' % (key, value)
6885 
      for key, value in self.__dict__.iteritems()]
6886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6887 
 
6888 
  def __eq__(self, other):
6889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6890 
 
6891 
  def __ne__(self, other):
6892 
    return not (self == other)
6893 
 
6894 
class updateAddress_result:
6895 
  """
6896 
  Attributes:
6897 
   - success
6898 
   - ucx
6899 
  """
6900 
 
6901 
  thrift_spec = (
6902 
    (0, TType.BOOL, 'success', None, None, ), # 0
6903 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6904 
  )
6905 
 
6906 
  def __init__(self, success=None, ucx=None,):
6907 
    self.success = success
6908 
    self.ucx = ucx
6909 
 
6910 
  def read(self, iprot):
6911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6913 
      return
6914 
    iprot.readStructBegin()
6915 
    while True:
6916 
      (fname, ftype, fid) = iprot.readFieldBegin()
6917 
      if ftype == TType.STOP:
6918 
        break
6919 
      if fid == 0:
6920 
        if ftype == TType.BOOL:
6921 
          self.success = iprot.readBool();
6922 
        else:
6923 
          iprot.skip(ftype)
6924 
      elif fid == 1:
6925 
        if ftype == TType.STRUCT:
6926 
          self.ucx = UserContextException()
6927 
          self.ucx.read(iprot)
6928 
        else:
6929 
          iprot.skip(ftype)
6930 
      else:
6931 
        iprot.skip(ftype)
6932 
      iprot.readFieldEnd()
6933 
    iprot.readStructEnd()
6934 
 
6935 
  def write(self, oprot):
6936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6938 
      return
6939 
    oprot.writeStructBegin('updateAddress_result')
6940 
    if self.success is not None:
6941 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6942 
      oprot.writeBool(self.success)
6943 
      oprot.writeFieldEnd()
6944 
    if self.ucx is not None:
6945 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6946 
      self.ucx.write(oprot)
6947 
      oprot.writeFieldEnd()
6948 
    oprot.writeFieldStop()
6949 
    oprot.writeStructEnd()
6950 
 
6951 
  def validate(self):
6952 
    return
6953 
 
6954 
 
6955 
  def __repr__(self):
6956 
    L = ['%s=%r' % (key, value)
6957 
      for key, value in self.__dict__.iteritems()]
6958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6959 
 
6960 
  def __eq__(self, other):
6961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6962 
 
6963 
  def __ne__(self, other):
6964 
    return not (self == other)
6965 
 
559 chandransh 6966 
class setUserAsLoggedIn_args:
94 ashish 6967 
  """
6968 
  Attributes:
559 chandransh 6969 
   - userId
94 ashish 6970 
   - timestamp
6971 
  """
6972 
 
6973 
  thrift_spec = (
6974 
    None, # 0
559 chandransh 6975 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6976 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6977 
  )
6978 
 
559 chandransh 6979 
  def __init__(self, userId=None, timestamp=None,):
6980 
    self.userId = userId
94 ashish 6981 
    self.timestamp = timestamp
6982 
 
6983 
  def read(self, iprot):
6984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6986 
      return
6987 
    iprot.readStructBegin()
6988 
    while True:
6989 
      (fname, ftype, fid) = iprot.readFieldBegin()
6990 
      if ftype == TType.STOP:
6991 
        break
6992 
      if fid == 1:
559 chandransh 6993 
        if ftype == TType.I64:
6994 
          self.userId = iprot.readI64();
94 ashish 6995 
        else:
6996 
          iprot.skip(ftype)
6997 
      elif fid == 2:
6998 
        if ftype == TType.I64:
6999 
          self.timestamp = iprot.readI64();
7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      else:
7003 
        iprot.skip(ftype)
7004 
      iprot.readFieldEnd()
7005 
    iprot.readStructEnd()
7006 
 
7007 
  def write(self, oprot):
7008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7010 
      return
559 chandransh 7011 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 7012 
    if self.userId is not None:
559 chandransh 7013 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7014 
      oprot.writeI64(self.userId)
94 ashish 7015 
      oprot.writeFieldEnd()
3431 rajveer 7016 
    if self.timestamp is not None:
94 ashish 7017 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7018 
      oprot.writeI64(self.timestamp)
7019 
      oprot.writeFieldEnd()
7020 
    oprot.writeFieldStop()
7021 
    oprot.writeStructEnd()
7022 
 
3431 rajveer 7023 
  def validate(self):
7024 
    return
7025 
 
7026 
 
94 ashish 7027 
  def __repr__(self):
7028 
    L = ['%s=%r' % (key, value)
7029 
      for key, value in self.__dict__.iteritems()]
7030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7031 
 
7032 
  def __eq__(self, other):
7033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7034 
 
7035 
  def __ne__(self, other):
7036 
    return not (self == other)
7037 
 
559 chandransh 7038 
class setUserAsLoggedIn_result:
94 ashish 7039 
  """
7040 
  Attributes:
7041 
   - success
7042 
   - ucx
7043 
  """
7044 
 
7045 
  thrift_spec = (
7046 
    (0, TType.BOOL, 'success', None, None, ), # 0
7047 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7048 
  )
7049 
 
7050 
  def __init__(self, success=None, ucx=None,):
7051 
    self.success = success
7052 
    self.ucx = ucx
7053 
 
7054 
  def read(self, iprot):
7055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7057 
      return
7058 
    iprot.readStructBegin()
7059 
    while True:
7060 
      (fname, ftype, fid) = iprot.readFieldBegin()
7061 
      if ftype == TType.STOP:
7062 
        break
7063 
      if fid == 0:
7064 
        if ftype == TType.BOOL:
7065 
          self.success = iprot.readBool();
7066 
        else:
7067 
          iprot.skip(ftype)
7068 
      elif fid == 1:
7069 
        if ftype == TType.STRUCT:
7070 
          self.ucx = UserContextException()
7071 
          self.ucx.read(iprot)
7072 
        else:
7073 
          iprot.skip(ftype)
7074 
      else:
7075 
        iprot.skip(ftype)
7076 
      iprot.readFieldEnd()
7077 
    iprot.readStructEnd()
7078 
 
7079 
  def write(self, oprot):
7080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7082 
      return
559 chandransh 7083 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 7084 
    if self.success is not None:
94 ashish 7085 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7086 
      oprot.writeBool(self.success)
7087 
      oprot.writeFieldEnd()
3431 rajveer 7088 
    if self.ucx is not None:
94 ashish 7089 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7090 
      self.ucx.write(oprot)
7091 
      oprot.writeFieldEnd()
7092 
    oprot.writeFieldStop()
7093 
    oprot.writeStructEnd()
7094 
 
3431 rajveer 7095 
  def validate(self):
7096 
    return
7097 
 
7098 
 
94 ashish 7099 
  def __repr__(self):
7100 
    L = ['%s=%r' % (key, value)
7101 
      for key, value in self.__dict__.iteritems()]
7102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7103 
 
7104 
  def __eq__(self, other):
7105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7106 
 
7107 
  def __ne__(self, other):
7108 
    return not (self == other)
7109 
 
559 chandransh 7110 
class setUserAsLoggedOut_args:
94 ashish 7111 
  """
7112 
  Attributes:
7113 
   - userid
7114 
   - timestamp
7115 
  """
7116 
 
7117 
  thrift_spec = (
7118 
    None, # 0
559 chandransh 7119 
    (1, TType.I64, 'userid', None, None, ), # 1
7120 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 7121 
  )
7122 
 
559 chandransh 7123 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 7124 
    self.userid = userid
7125 
    self.timestamp = timestamp
7126 
 
7127 
  def read(self, iprot):
7128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7130 
      return
7131 
    iprot.readStructBegin()
7132 
    while True:
7133 
      (fname, ftype, fid) = iprot.readFieldBegin()
7134 
      if ftype == TType.STOP:
7135 
        break
7136 
      if fid == 1:
7137 
        if ftype == TType.I64:
7138 
          self.userid = iprot.readI64();
7139 
        else:
7140 
          iprot.skip(ftype)
559 chandransh 7141 
      elif fid == 2:
94 ashish 7142 
        if ftype == TType.I64:
7143 
          self.timestamp = iprot.readI64();
7144 
        else:
7145 
          iprot.skip(ftype)
7146 
      else:
7147 
        iprot.skip(ftype)
7148 
      iprot.readFieldEnd()
7149 
    iprot.readStructEnd()
7150 
 
7151 
  def write(self, oprot):
7152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7154 
      return
559 chandransh 7155 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 7156 
    if self.userid is not None:
559 chandransh 7157 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 7158 
      oprot.writeI64(self.userid)
7159 
      oprot.writeFieldEnd()
3431 rajveer 7160 
    if self.timestamp is not None:
559 chandransh 7161 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 7162 
      oprot.writeI64(self.timestamp)
7163 
      oprot.writeFieldEnd()
7164 
    oprot.writeFieldStop()
7165 
    oprot.writeStructEnd()
7166 
 
3431 rajveer 7167 
  def validate(self):
7168 
    return
7169 
 
7170 
 
94 ashish 7171 
  def __repr__(self):
7172 
    L = ['%s=%r' % (key, value)
7173 
      for key, value in self.__dict__.iteritems()]
7174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7175 
 
7176 
  def __eq__(self, other):
7177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7178 
 
7179 
  def __ne__(self, other):
7180 
    return not (self == other)
7181 
 
559 chandransh 7182 
class setUserAsLoggedOut_result:
94 ashish 7183 
  """
7184 
  Attributes:
7185 
   - success
7186 
   - ucx
7187 
  """
7188 
 
7189 
  thrift_spec = (
7190 
    (0, TType.BOOL, 'success', None, None, ), # 0
7191 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7192 
  )
7193 
 
7194 
  def __init__(self, success=None, ucx=None,):
7195 
    self.success = success
7196 
    self.ucx = ucx
7197 
 
7198 
  def read(self, iprot):
7199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7201 
      return
7202 
    iprot.readStructBegin()
7203 
    while True:
7204 
      (fname, ftype, fid) = iprot.readFieldBegin()
7205 
      if ftype == TType.STOP:
7206 
        break
7207 
      if fid == 0:
7208 
        if ftype == TType.BOOL:
7209 
          self.success = iprot.readBool();
7210 
        else:
7211 
          iprot.skip(ftype)
7212 
      elif fid == 1:
7213 
        if ftype == TType.STRUCT:
7214 
          self.ucx = UserContextException()
7215 
          self.ucx.read(iprot)
7216 
        else:
7217 
          iprot.skip(ftype)
7218 
      else:
7219 
        iprot.skip(ftype)
7220 
      iprot.readFieldEnd()
7221 
    iprot.readStructEnd()
7222 
 
7223 
  def write(self, oprot):
7224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7226 
      return
559 chandransh 7227 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 7228 
    if self.success is not None:
94 ashish 7229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7230 
      oprot.writeBool(self.success)
7231 
      oprot.writeFieldEnd()
3431 rajveer 7232 
    if self.ucx is not None:
94 ashish 7233 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7234 
      self.ucx.write(oprot)
7235 
      oprot.writeFieldEnd()
7236 
    oprot.writeFieldStop()
7237 
    oprot.writeStructEnd()
7238 
 
3431 rajveer 7239 
  def validate(self):
7240 
    return
7241 
 
7242 
 
94 ashish 7243 
  def __repr__(self):
7244 
    L = ['%s=%r' % (key, value)
7245 
      for key, value in self.__dict__.iteritems()]
7246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7247 
 
7248 
  def __eq__(self, other):
7249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7250 
 
7251 
  def __ne__(self, other):
7252 
    return not (self == other)
7253 
 
559 chandransh 7254 
class setDefaultAddress_args:
94 ashish 7255 
  """
7256 
  Attributes:
7257 
   - userid
7258 
   - addressId
7259 
  """
7260 
 
7261 
  thrift_spec = (
7262 
    None, # 0
7263 
    (1, TType.I64, 'userid', None, None, ), # 1
7264 
    (2, TType.I64, 'addressId', None, None, ), # 2
7265 
  )
7266 
 
7267 
  def __init__(self, userid=None, addressId=None,):
7268 
    self.userid = userid
7269 
    self.addressId = addressId
7270 
 
7271 
  def read(self, iprot):
7272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7274 
      return
7275 
    iprot.readStructBegin()
7276 
    while True:
7277 
      (fname, ftype, fid) = iprot.readFieldBegin()
7278 
      if ftype == TType.STOP:
7279 
        break
7280 
      if fid == 1:
7281 
        if ftype == TType.I64:
7282 
          self.userid = iprot.readI64();
7283 
        else:
7284 
          iprot.skip(ftype)
7285 
      elif fid == 2:
7286 
        if ftype == TType.I64:
7287 
          self.addressId = iprot.readI64();
7288 
        else:
7289 
          iprot.skip(ftype)
7290 
      else:
7291 
        iprot.skip(ftype)
7292 
      iprot.readFieldEnd()
7293 
    iprot.readStructEnd()
7294 
 
7295 
  def write(self, oprot):
7296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7298 
      return
559 chandransh 7299 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7300 
    if self.userid is not None:
94 ashish 7301 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7302 
      oprot.writeI64(self.userid)
7303 
      oprot.writeFieldEnd()
3431 rajveer 7304 
    if self.addressId is not None:
94 ashish 7305 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7306 
      oprot.writeI64(self.addressId)
7307 
      oprot.writeFieldEnd()
7308 
    oprot.writeFieldStop()
7309 
    oprot.writeStructEnd()
7310 
 
3431 rajveer 7311 
  def validate(self):
7312 
    return
7313 
 
7314 
 
94 ashish 7315 
  def __repr__(self):
7316 
    L = ['%s=%r' % (key, value)
7317 
      for key, value in self.__dict__.iteritems()]
7318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7319 
 
7320 
  def __eq__(self, other):
7321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7322 
 
7323 
  def __ne__(self, other):
7324 
    return not (self == other)
7325 
 
559 chandransh 7326 
class setDefaultAddress_result:
94 ashish 7327 
  """
7328 
  Attributes:
7329 
   - success
7330 
   - ucx
7331 
  """
7332 
 
7333 
  thrift_spec = (
7334 
    (0, TType.BOOL, 'success', None, None, ), # 0
7335 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7336 
  )
7337 
 
7338 
  def __init__(self, success=None, ucx=None,):
7339 
    self.success = success
7340 
    self.ucx = ucx
7341 
 
7342 
  def read(self, iprot):
7343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7345 
      return
7346 
    iprot.readStructBegin()
7347 
    while True:
7348 
      (fname, ftype, fid) = iprot.readFieldBegin()
7349 
      if ftype == TType.STOP:
7350 
        break
7351 
      if fid == 0:
7352 
        if ftype == TType.BOOL:
7353 
          self.success = iprot.readBool();
7354 
        else:
7355 
          iprot.skip(ftype)
7356 
      elif fid == 1:
7357 
        if ftype == TType.STRUCT:
7358 
          self.ucx = UserContextException()
7359 
          self.ucx.read(iprot)
7360 
        else:
7361 
          iprot.skip(ftype)
7362 
      else:
7363 
        iprot.skip(ftype)
7364 
      iprot.readFieldEnd()
7365 
    iprot.readStructEnd()
7366 
 
7367 
  def write(self, oprot):
7368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7370 
      return
559 chandransh 7371 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7372 
    if self.success is not None:
94 ashish 7373 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7374 
      oprot.writeBool(self.success)
7375 
      oprot.writeFieldEnd()
3431 rajveer 7376 
    if self.ucx is not None:
94 ashish 7377 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7378 
      self.ucx.write(oprot)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
3431 rajveer 7383 
  def validate(self):
7384 
    return
7385 
 
7386 
 
94 ashish 7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
559 chandransh 7398 
class updatePassword_args:
94 ashish 7399 
  """
7400 
  Attributes:
559 chandransh 7401 
   - userid
594 rajveer 7402 
   - oldPassword
7403 
   - newPassword
94 ashish 7404 
  """
7405 
 
7406 
  thrift_spec = (
7407 
    None, # 0
559 chandransh 7408 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7409 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7410 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7411 
  )
7412 
 
594 rajveer 7413 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7414 
    self.userid = userid
594 rajveer 7415 
    self.oldPassword = oldPassword
7416 
    self.newPassword = newPassword
94 ashish 7417 
 
7418 
  def read(self, iprot):
7419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7421 
      return
7422 
    iprot.readStructBegin()
7423 
    while True:
7424 
      (fname, ftype, fid) = iprot.readFieldBegin()
7425 
      if ftype == TType.STOP:
7426 
        break
7427 
      if fid == 1:
7428 
        if ftype == TType.I64:
559 chandransh 7429 
          self.userid = iprot.readI64();
94 ashish 7430 
        else:
7431 
          iprot.skip(ftype)
7432 
      elif fid == 2:
559 chandransh 7433 
        if ftype == TType.STRING:
594 rajveer 7434 
          self.oldPassword = iprot.readString();
94 ashish 7435 
        else:
7436 
          iprot.skip(ftype)
594 rajveer 7437 
      elif fid == 3:
7438 
        if ftype == TType.STRING:
7439 
          self.newPassword = iprot.readString();
7440 
        else:
7441 
          iprot.skip(ftype)
94 ashish 7442 
      else:
7443 
        iprot.skip(ftype)
7444 
      iprot.readFieldEnd()
7445 
    iprot.readStructEnd()
7446 
 
7447 
  def write(self, oprot):
7448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7450 
      return
559 chandransh 7451 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7452 
    if self.userid is not None:
559 chandransh 7453 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7454 
      oprot.writeI64(self.userid)
94 ashish 7455 
      oprot.writeFieldEnd()
3431 rajveer 7456 
    if self.oldPassword is not None:
594 rajveer 7457 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7458 
      oprot.writeString(self.oldPassword)
94 ashish 7459 
      oprot.writeFieldEnd()
3431 rajveer 7460 
    if self.newPassword is not None:
594 rajveer 7461 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7462 
      oprot.writeString(self.newPassword)
7463 
      oprot.writeFieldEnd()
94 ashish 7464 
    oprot.writeFieldStop()
7465 
    oprot.writeStructEnd()
7466 
 
3431 rajveer 7467 
  def validate(self):
7468 
    return
7469 
 
7470 
 
94 ashish 7471 
  def __repr__(self):
7472 
    L = ['%s=%r' % (key, value)
7473 
      for key, value in self.__dict__.iteritems()]
7474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7475 
 
7476 
  def __eq__(self, other):
7477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7478 
 
7479 
  def __ne__(self, other):
7480 
    return not (self == other)
7481 
 
559 chandransh 7482 
class updatePassword_result:
94 ashish 7483 
  """
7484 
  Attributes:
7485 
   - success
7486 
   - ucx
7487 
  """
7488 
 
7489 
  thrift_spec = (
7490 
    (0, TType.BOOL, 'success', None, None, ), # 0
7491 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7492 
  )
7493 
 
7494 
  def __init__(self, success=None, ucx=None,):
7495 
    self.success = success
7496 
    self.ucx = ucx
7497 
 
7498 
  def read(self, iprot):
7499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7501 
      return
7502 
    iprot.readStructBegin()
7503 
    while True:
7504 
      (fname, ftype, fid) = iprot.readFieldBegin()
7505 
      if ftype == TType.STOP:
7506 
        break
7507 
      if fid == 0:
7508 
        if ftype == TType.BOOL:
7509 
          self.success = iprot.readBool();
7510 
        else:
7511 
          iprot.skip(ftype)
7512 
      elif fid == 1:
7513 
        if ftype == TType.STRUCT:
7514 
          self.ucx = UserContextException()
7515 
          self.ucx.read(iprot)
7516 
        else:
7517 
          iprot.skip(ftype)
7518 
      else:
7519 
        iprot.skip(ftype)
7520 
      iprot.readFieldEnd()
7521 
    iprot.readStructEnd()
7522 
 
7523 
  def write(self, oprot):
7524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7526 
      return
559 chandransh 7527 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7528 
    if self.success is not None:
94 ashish 7529 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7530 
      oprot.writeBool(self.success)
7531 
      oprot.writeFieldEnd()
3431 rajveer 7532 
    if self.ucx is not None:
94 ashish 7533 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7534 
      self.ucx.write(oprot)
7535 
      oprot.writeFieldEnd()
7536 
    oprot.writeFieldStop()
7537 
    oprot.writeStructEnd()
7538 
 
3431 rajveer 7539 
  def validate(self):
7540 
    return
7541 
 
7542 
 
94 ashish 7543 
  def __repr__(self):
7544 
    L = ['%s=%r' % (key, value)
7545 
      for key, value in self.__dict__.iteritems()]
7546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7547 
 
7548 
  def __eq__(self, other):
7549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7550 
 
7551 
  def __ne__(self, other):
7552 
    return not (self == other)
7553 
 
581 rajveer 7554 
class forgotPassword_args:
7555 
  """
7556 
  Attributes:
7557 
   - email
884 rajveer 7558 
   - newPassword
581 rajveer 7559 
  """
7560 
 
7561 
  thrift_spec = (
7562 
    None, # 0
7563 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7564 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7565 
  )
7566 
 
884 rajveer 7567 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7568 
    self.email = email
884 rajveer 7569 
    self.newPassword = newPassword
581 rajveer 7570 
 
7571 
  def read(self, iprot):
7572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7574 
      return
7575 
    iprot.readStructBegin()
7576 
    while True:
7577 
      (fname, ftype, fid) = iprot.readFieldBegin()
7578 
      if ftype == TType.STOP:
7579 
        break
7580 
      if fid == 1:
7581 
        if ftype == TType.STRING:
7582 
          self.email = iprot.readString();
7583 
        else:
7584 
          iprot.skip(ftype)
884 rajveer 7585 
      elif fid == 2:
7586 
        if ftype == TType.STRING:
7587 
          self.newPassword = iprot.readString();
7588 
        else:
7589 
          iprot.skip(ftype)
581 rajveer 7590 
      else:
7591 
        iprot.skip(ftype)
7592 
      iprot.readFieldEnd()
7593 
    iprot.readStructEnd()
7594 
 
7595 
  def write(self, oprot):
7596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7598 
      return
7599 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7600 
    if self.email is not None:
581 rajveer 7601 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7602 
      oprot.writeString(self.email)
7603 
      oprot.writeFieldEnd()
3431 rajveer 7604 
    if self.newPassword is not None:
884 rajveer 7605 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7606 
      oprot.writeString(self.newPassword)
7607 
      oprot.writeFieldEnd()
581 rajveer 7608 
    oprot.writeFieldStop()
7609 
    oprot.writeStructEnd()
7610 
 
3431 rajveer 7611 
  def validate(self):
7612 
    return
7613 
 
7614 
 
581 rajveer 7615 
  def __repr__(self):
7616 
    L = ['%s=%r' % (key, value)
7617 
      for key, value in self.__dict__.iteritems()]
7618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7619 
 
7620 
  def __eq__(self, other):
7621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7622 
 
7623 
  def __ne__(self, other):
7624 
    return not (self == other)
7625 
 
7626 
class forgotPassword_result:
7627 
  """
7628 
  Attributes:
7629 
   - success
7630 
   - ucx
7631 
  """
7632 
 
7633 
  thrift_spec = (
7634 
    (0, TType.BOOL, 'success', None, None, ), # 0
7635 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7636 
  )
7637 
 
7638 
  def __init__(self, success=None, ucx=None,):
7639 
    self.success = success
7640 
    self.ucx = ucx
7641 
 
7642 
  def read(self, iprot):
7643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7645 
      return
7646 
    iprot.readStructBegin()
7647 
    while True:
7648 
      (fname, ftype, fid) = iprot.readFieldBegin()
7649 
      if ftype == TType.STOP:
7650 
        break
7651 
      if fid == 0:
7652 
        if ftype == TType.BOOL:
7653 
          self.success = iprot.readBool();
7654 
        else:
7655 
          iprot.skip(ftype)
7656 
      elif fid == 1:
7657 
        if ftype == TType.STRUCT:
7658 
          self.ucx = UserContextException()
7659 
          self.ucx.read(iprot)
7660 
        else:
7661 
          iprot.skip(ftype)
7662 
      else:
7663 
        iprot.skip(ftype)
7664 
      iprot.readFieldEnd()
7665 
    iprot.readStructEnd()
7666 
 
7667 
  def write(self, oprot):
7668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7670 
      return
7671 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7672 
    if self.success is not None:
581 rajveer 7673 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7674 
      oprot.writeBool(self.success)
7675 
      oprot.writeFieldEnd()
3431 rajveer 7676 
    if self.ucx is not None:
581 rajveer 7677 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7678 
      self.ucx.write(oprot)
7679 
      oprot.writeFieldEnd()
7680 
    oprot.writeFieldStop()
7681 
    oprot.writeStructEnd()
7682 
 
3431 rajveer 7683 
  def validate(self):
7684 
    return
7685 
 
7686 
 
581 rajveer 7687 
  def __repr__(self):
7688 
    L = ['%s=%r' % (key, value)
7689 
      for key, value in self.__dict__.iteritems()]
7690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7691 
 
7692 
  def __eq__(self, other):
7693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7694 
 
7695 
  def __ne__(self, other):
7696 
    return not (self == other)
7697 
 
594 rajveer 7698 
class getAllAddressesForUser_args:
7699 
  """
7700 
  Attributes:
7701 
   - userId
7702 
  """
7703 
 
7704 
  thrift_spec = (
7705 
    None, # 0
7706 
    (1, TType.I64, 'userId', None, None, ), # 1
7707 
  )
7708 
 
7709 
  def __init__(self, userId=None,):
7710 
    self.userId = userId
7711 
 
7712 
  def read(self, iprot):
7713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7715 
      return
7716 
    iprot.readStructBegin()
7717 
    while True:
7718 
      (fname, ftype, fid) = iprot.readFieldBegin()
7719 
      if ftype == TType.STOP:
7720 
        break
7721 
      if fid == 1:
7722 
        if ftype == TType.I64:
7723 
          self.userId = iprot.readI64();
7724 
        else:
7725 
          iprot.skip(ftype)
7726 
      else:
7727 
        iprot.skip(ftype)
7728 
      iprot.readFieldEnd()
7729 
    iprot.readStructEnd()
7730 
 
7731 
  def write(self, oprot):
7732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7734 
      return
7735 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7736 
    if self.userId is not None:
594 rajveer 7737 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7738 
      oprot.writeI64(self.userId)
7739 
      oprot.writeFieldEnd()
7740 
    oprot.writeFieldStop()
7741 
    oprot.writeStructEnd()
7742 
 
3431 rajveer 7743 
  def validate(self):
7744 
    return
7745 
 
7746 
 
594 rajveer 7747 
  def __repr__(self):
7748 
    L = ['%s=%r' % (key, value)
7749 
      for key, value in self.__dict__.iteritems()]
7750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7751 
 
7752 
  def __eq__(self, other):
7753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7754 
 
7755 
  def __ne__(self, other):
7756 
    return not (self == other)
7757 
 
7758 
class getAllAddressesForUser_result:
7759 
  """
7760 
  Attributes:
7761 
   - success
7762 
   - ucx
7763 
  """
7764 
 
7765 
  thrift_spec = (
7766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7767 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7768 
  )
7769 
 
7770 
  def __init__(self, success=None, ucx=None,):
7771 
    self.success = success
7772 
    self.ucx = ucx
7773 
 
7774 
  def read(self, iprot):
7775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7777 
      return
7778 
    iprot.readStructBegin()
7779 
    while True:
7780 
      (fname, ftype, fid) = iprot.readFieldBegin()
7781 
      if ftype == TType.STOP:
7782 
        break
7783 
      if fid == 0:
7784 
        if ftype == TType.LIST:
7785 
          self.success = []
11592 amit.gupta 7786 
          (_etype100, _size97) = iprot.readListBegin()
7787 
          for _i101 in xrange(_size97):
7788 
            _elem102 = Address()
7789 
            _elem102.read(iprot)
7790 
            self.success.append(_elem102)
594 rajveer 7791 
          iprot.readListEnd()
7792 
        else:
7793 
          iprot.skip(ftype)
7794 
      elif fid == 1:
7795 
        if ftype == TType.STRUCT:
7796 
          self.ucx = UserContextException()
7797 
          self.ucx.read(iprot)
7798 
        else:
7799 
          iprot.skip(ftype)
7800 
      else:
7801 
        iprot.skip(ftype)
7802 
      iprot.readFieldEnd()
7803 
    iprot.readStructEnd()
7804 
 
7805 
  def write(self, oprot):
7806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7808 
      return
7809 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7810 
    if self.success is not None:
594 rajveer 7811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7812 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7813 
      for iter103 in self.success:
7814 
        iter103.write(oprot)
594 rajveer 7815 
      oprot.writeListEnd()
7816 
      oprot.writeFieldEnd()
3431 rajveer 7817 
    if self.ucx is not None:
594 rajveer 7818 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7819 
      self.ucx.write(oprot)
7820 
      oprot.writeFieldEnd()
7821 
    oprot.writeFieldStop()
7822 
    oprot.writeStructEnd()
7823 
 
3431 rajveer 7824 
  def validate(self):
7825 
    return
7826 
 
7827 
 
594 rajveer 7828 
  def __repr__(self):
7829 
    L = ['%s=%r' % (key, value)
7830 
      for key, value in self.__dict__.iteritems()]
7831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7832 
 
7833 
  def __eq__(self, other):
7834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7835 
 
7836 
  def __ne__(self, other):
7837 
    return not (self == other)
7838 
 
1894 vikas 7839 
class getAddressById_args:
7840 
  """
7841 
  Attributes:
7842 
   - addressId
7843 
  """
7844 
 
7845 
  thrift_spec = (
7846 
    None, # 0
7847 
    (1, TType.I64, 'addressId', None, None, ), # 1
7848 
  )
7849 
 
7850 
  def __init__(self, addressId=None,):
7851 
    self.addressId = addressId
7852 
 
7853 
  def read(self, iprot):
7854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7856 
      return
7857 
    iprot.readStructBegin()
7858 
    while True:
7859 
      (fname, ftype, fid) = iprot.readFieldBegin()
7860 
      if ftype == TType.STOP:
7861 
        break
7862 
      if fid == 1:
7863 
        if ftype == TType.I64:
7864 
          self.addressId = iprot.readI64();
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      else:
7868 
        iprot.skip(ftype)
7869 
      iprot.readFieldEnd()
7870 
    iprot.readStructEnd()
7871 
 
7872 
  def write(self, oprot):
7873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7875 
      return
7876 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7877 
    if self.addressId is not None:
1894 vikas 7878 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7879 
      oprot.writeI64(self.addressId)
7880 
      oprot.writeFieldEnd()
7881 
    oprot.writeFieldStop()
7882 
    oprot.writeStructEnd()
7883 
 
3431 rajveer 7884 
  def validate(self):
7885 
    return
7886 
 
7887 
 
1894 vikas 7888 
  def __repr__(self):
7889 
    L = ['%s=%r' % (key, value)
7890 
      for key, value in self.__dict__.iteritems()]
7891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7892 
 
7893 
  def __eq__(self, other):
7894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7895 
 
7896 
  def __ne__(self, other):
7897 
    return not (self == other)
7898 
 
7899 
class getAddressById_result:
7900 
  """
7901 
  Attributes:
7902 
   - success
7903 
   - ucx
7904 
  """
7905 
 
7906 
  thrift_spec = (
7907 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7908 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7909 
  )
7910 
 
7911 
  def __init__(self, success=None, ucx=None,):
7912 
    self.success = success
7913 
    self.ucx = ucx
7914 
 
7915 
  def read(self, iprot):
7916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7918 
      return
7919 
    iprot.readStructBegin()
7920 
    while True:
7921 
      (fname, ftype, fid) = iprot.readFieldBegin()
7922 
      if ftype == TType.STOP:
7923 
        break
7924 
      if fid == 0:
7925 
        if ftype == TType.STRUCT:
7926 
          self.success = Address()
7927 
          self.success.read(iprot)
7928 
        else:
7929 
          iprot.skip(ftype)
7930 
      elif fid == 1:
7931 
        if ftype == TType.STRUCT:
7932 
          self.ucx = UserContextException()
7933 
          self.ucx.read(iprot)
7934 
        else:
7935 
          iprot.skip(ftype)
7936 
      else:
7937 
        iprot.skip(ftype)
7938 
      iprot.readFieldEnd()
7939 
    iprot.readStructEnd()
7940 
 
7941 
  def write(self, oprot):
7942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7944 
      return
7945 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7946 
    if self.success is not None:
1894 vikas 7947 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7948 
      self.success.write(oprot)
7949 
      oprot.writeFieldEnd()
3431 rajveer 7950 
    if self.ucx is not None:
1894 vikas 7951 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7952 
      self.ucx.write(oprot)
7953 
      oprot.writeFieldEnd()
7954 
    oprot.writeFieldStop()
7955 
    oprot.writeStructEnd()
7956 
 
3431 rajveer 7957 
  def validate(self):
7958 
    return
7959 
 
7960 
 
1894 vikas 7961 
  def __repr__(self):
7962 
    L = ['%s=%r' % (key, value)
7963 
      for key, value in self.__dict__.iteritems()]
7964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7965 
 
7966 
  def __eq__(self, other):
7967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7968 
 
7969 
  def __ne__(self, other):
7970 
    return not (self == other)
7971 
 
594 rajveer 7972 
class getDefaultAddressId_args:
7973 
  """
7974 
  Attributes:
7975 
   - userId
7976 
  """
7977 
 
7978 
  thrift_spec = (
7979 
    None, # 0
7980 
    (1, TType.I64, 'userId', None, None, ), # 1
7981 
  )
7982 
 
7983 
  def __init__(self, userId=None,):
7984 
    self.userId = userId
7985 
 
7986 
  def read(self, iprot):
7987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7989 
      return
7990 
    iprot.readStructBegin()
7991 
    while True:
7992 
      (fname, ftype, fid) = iprot.readFieldBegin()
7993 
      if ftype == TType.STOP:
7994 
        break
7995 
      if fid == 1:
7996 
        if ftype == TType.I64:
7997 
          self.userId = iprot.readI64();
7998 
        else:
7999 
          iprot.skip(ftype)
8000 
      else:
8001 
        iprot.skip(ftype)
8002 
      iprot.readFieldEnd()
8003 
    iprot.readStructEnd()
8004 
 
8005 
  def write(self, oprot):
8006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8008 
      return
8009 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 8010 
    if self.userId is not None:
594 rajveer 8011 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8012 
      oprot.writeI64(self.userId)
8013 
      oprot.writeFieldEnd()
8014 
    oprot.writeFieldStop()
8015 
    oprot.writeStructEnd()
8016 
 
3431 rajveer 8017 
  def validate(self):
8018 
    return
8019 
 
8020 
 
594 rajveer 8021 
  def __repr__(self):
8022 
    L = ['%s=%r' % (key, value)
8023 
      for key, value in self.__dict__.iteritems()]
8024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8025 
 
8026 
  def __eq__(self, other):
8027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8028 
 
8029 
  def __ne__(self, other):
8030 
    return not (self == other)
8031 
 
8032 
class getDefaultAddressId_result:
8033 
  """
8034 
  Attributes:
8035 
   - success
8036 
   - ucx
8037 
  """
8038 
 
8039 
  thrift_spec = (
8040 
    (0, TType.I64, 'success', None, None, ), # 0
8041 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8042 
  )
8043 
 
8044 
  def __init__(self, success=None, ucx=None,):
8045 
    self.success = success
8046 
    self.ucx = ucx
8047 
 
8048 
  def read(self, iprot):
8049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8051 
      return
8052 
    iprot.readStructBegin()
8053 
    while True:
8054 
      (fname, ftype, fid) = iprot.readFieldBegin()
8055 
      if ftype == TType.STOP:
8056 
        break
8057 
      if fid == 0:
8058 
        if ftype == TType.I64:
8059 
          self.success = iprot.readI64();
8060 
        else:
8061 
          iprot.skip(ftype)
8062 
      elif fid == 1:
8063 
        if ftype == TType.STRUCT:
8064 
          self.ucx = UserContextException()
8065 
          self.ucx.read(iprot)
8066 
        else:
8067 
          iprot.skip(ftype)
8068 
      else:
8069 
        iprot.skip(ftype)
8070 
      iprot.readFieldEnd()
8071 
    iprot.readStructEnd()
8072 
 
8073 
  def write(self, oprot):
8074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8076 
      return
8077 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 8078 
    if self.success is not None:
594 rajveer 8079 
      oprot.writeFieldBegin('success', TType.I64, 0)
8080 
      oprot.writeI64(self.success)
8081 
      oprot.writeFieldEnd()
3431 rajveer 8082 
    if self.ucx is not None:
594 rajveer 8083 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8084 
      self.ucx.write(oprot)
8085 
      oprot.writeFieldEnd()
8086 
    oprot.writeFieldStop()
8087 
    oprot.writeStructEnd()
8088 
 
3431 rajveer 8089 
  def validate(self):
8090 
    return
8091 
 
8092 
 
594 rajveer 8093 
  def __repr__(self):
8094 
    L = ['%s=%r' % (key, value)
8095 
      for key, value in self.__dict__.iteritems()]
8096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8097 
 
8098 
  def __eq__(self, other):
8099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8100 
 
8101 
  def __ne__(self, other):
8102 
    return not (self == other)
8103 
 
785 rajveer 8104 
class getDefaultPincode_args:
8105 
  """
8106 
  Attributes:
8107 
   - userId
8108 
  """
8109 
 
8110 
  thrift_spec = (
8111 
    None, # 0
8112 
    (1, TType.I64, 'userId', None, None, ), # 1
8113 
  )
8114 
 
8115 
  def __init__(self, userId=None,):
8116 
    self.userId = userId
8117 
 
8118 
  def read(self, iprot):
8119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8121 
      return
8122 
    iprot.readStructBegin()
8123 
    while True:
8124 
      (fname, ftype, fid) = iprot.readFieldBegin()
8125 
      if ftype == TType.STOP:
8126 
        break
8127 
      if fid == 1:
8128 
        if ftype == TType.I64:
8129 
          self.userId = iprot.readI64();
8130 
        else:
8131 
          iprot.skip(ftype)
8132 
      else:
8133 
        iprot.skip(ftype)
8134 
      iprot.readFieldEnd()
8135 
    iprot.readStructEnd()
8136 
 
8137 
  def write(self, oprot):
8138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8140 
      return
8141 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 8142 
    if self.userId is not None:
785 rajveer 8143 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8144 
      oprot.writeI64(self.userId)
8145 
      oprot.writeFieldEnd()
8146 
    oprot.writeFieldStop()
8147 
    oprot.writeStructEnd()
8148 
 
3431 rajveer 8149 
  def validate(self):
8150 
    return
8151 
 
8152 
 
785 rajveer 8153 
  def __repr__(self):
8154 
    L = ['%s=%r' % (key, value)
8155 
      for key, value in self.__dict__.iteritems()]
8156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8157 
 
8158 
  def __eq__(self, other):
8159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8160 
 
8161 
  def __ne__(self, other):
8162 
    return not (self == other)
8163 
 
8164 
class getDefaultPincode_result:
8165 
  """
8166 
  Attributes:
8167 
   - success
8168 
   - ucx
8169 
  """
8170 
 
8171 
  thrift_spec = (
8172 
    (0, TType.STRING, 'success', None, None, ), # 0
8173 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8174 
  )
8175 
 
8176 
  def __init__(self, success=None, ucx=None,):
8177 
    self.success = success
8178 
    self.ucx = ucx
8179 
 
8180 
  def read(self, iprot):
8181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8183 
      return
8184 
    iprot.readStructBegin()
8185 
    while True:
8186 
      (fname, ftype, fid) = iprot.readFieldBegin()
8187 
      if ftype == TType.STOP:
8188 
        break
8189 
      if fid == 0:
8190 
        if ftype == TType.STRING:
8191 
          self.success = iprot.readString();
8192 
        else:
8193 
          iprot.skip(ftype)
8194 
      elif fid == 1:
8195 
        if ftype == TType.STRUCT:
8196 
          self.ucx = UserContextException()
8197 
          self.ucx.read(iprot)
8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      else:
8201 
        iprot.skip(ftype)
8202 
      iprot.readFieldEnd()
8203 
    iprot.readStructEnd()
8204 
 
8205 
  def write(self, oprot):
8206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8208 
      return
8209 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 8210 
    if self.success is not None:
785 rajveer 8211 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8212 
      oprot.writeString(self.success)
8213 
      oprot.writeFieldEnd()
3431 rajveer 8214 
    if self.ucx is not None:
785 rajveer 8215 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8216 
      self.ucx.write(oprot)
8217 
      oprot.writeFieldEnd()
8218 
    oprot.writeFieldStop()
8219 
    oprot.writeStructEnd()
8220 
 
3431 rajveer 8221 
  def validate(self):
8222 
    return
8223 
 
8224 
 
785 rajveer 8225 
  def __repr__(self):
8226 
    L = ['%s=%r' % (key, value)
8227 
      for key, value in self.__dict__.iteritems()]
8228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8229 
 
8230 
  def __eq__(self, other):
8231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8232 
 
8233 
  def __ne__(self, other):
8234 
    return not (self == other)
8235 
 
1274 varun.gupt 8236 
class saveUserCommunication_args:
8237 
  """
8238 
  Attributes:
8239 
   - userId
8240 
   - replyTo
8241 
   - communicationType
8242 
   - orderId
8243 
   - airwaybillNo
8244 
   - productName
8245 
   - subject
8246 
   - message
8247 
  """
8248 
 
8249 
  thrift_spec = (
8250 
    None, # 0
8251 
    (1, TType.I64, 'userId', None, None, ), # 1
8252 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
8253 
    (3, TType.I64, 'communicationType', None, None, ), # 3
8254 
    (4, TType.I64, 'orderId', None, None, ), # 4
8255 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
8256 
    (6, TType.STRING, 'productName', None, None, ), # 6
8257 
    (7, TType.STRING, 'subject', None, None, ), # 7
8258 
    (8, TType.STRING, 'message', None, None, ), # 8
8259 
  )
8260 
 
8261 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
8262 
    self.userId = userId
8263 
    self.replyTo = replyTo
8264 
    self.communicationType = communicationType
8265 
    self.orderId = orderId
8266 
    self.airwaybillNo = airwaybillNo
8267 
    self.productName = productName
8268 
    self.subject = subject
8269 
    self.message = message
8270 
 
8271 
  def read(self, iprot):
8272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8274 
      return
8275 
    iprot.readStructBegin()
8276 
    while True:
8277 
      (fname, ftype, fid) = iprot.readFieldBegin()
8278 
      if ftype == TType.STOP:
8279 
        break
8280 
      if fid == 1:
8281 
        if ftype == TType.I64:
8282 
          self.userId = iprot.readI64();
8283 
        else:
8284 
          iprot.skip(ftype)
8285 
      elif fid == 2:
8286 
        if ftype == TType.STRING:
8287 
          self.replyTo = iprot.readString();
8288 
        else:
8289 
          iprot.skip(ftype)
8290 
      elif fid == 3:
8291 
        if ftype == TType.I64:
8292 
          self.communicationType = iprot.readI64();
8293 
        else:
8294 
          iprot.skip(ftype)
8295 
      elif fid == 4:
8296 
        if ftype == TType.I64:
8297 
          self.orderId = iprot.readI64();
8298 
        else:
8299 
          iprot.skip(ftype)
8300 
      elif fid == 5:
8301 
        if ftype == TType.STRING:
8302 
          self.airwaybillNo = iprot.readString();
8303 
        else:
8304 
          iprot.skip(ftype)
8305 
      elif fid == 6:
8306 
        if ftype == TType.STRING:
8307 
          self.productName = iprot.readString();
8308 
        else:
8309 
          iprot.skip(ftype)
8310 
      elif fid == 7:
8311 
        if ftype == TType.STRING:
8312 
          self.subject = iprot.readString();
8313 
        else:
8314 
          iprot.skip(ftype)
8315 
      elif fid == 8:
8316 
        if ftype == TType.STRING:
8317 
          self.message = iprot.readString();
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      else:
8321 
        iprot.skip(ftype)
8322 
      iprot.readFieldEnd()
8323 
    iprot.readStructEnd()
8324 
 
8325 
  def write(self, oprot):
8326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8328 
      return
8329 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 8330 
    if self.userId is not None:
1274 varun.gupt 8331 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8332 
      oprot.writeI64(self.userId)
8333 
      oprot.writeFieldEnd()
3431 rajveer 8334 
    if self.replyTo is not None:
1274 varun.gupt 8335 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8336 
      oprot.writeString(self.replyTo)
8337 
      oprot.writeFieldEnd()
3431 rajveer 8338 
    if self.communicationType is not None:
1274 varun.gupt 8339 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8340 
      oprot.writeI64(self.communicationType)
8341 
      oprot.writeFieldEnd()
3431 rajveer 8342 
    if self.orderId is not None:
1274 varun.gupt 8343 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8344 
      oprot.writeI64(self.orderId)
8345 
      oprot.writeFieldEnd()
3431 rajveer 8346 
    if self.airwaybillNo is not None:
1274 varun.gupt 8347 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8348 
      oprot.writeString(self.airwaybillNo)
8349 
      oprot.writeFieldEnd()
3431 rajveer 8350 
    if self.productName is not None:
1274 varun.gupt 8351 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8352 
      oprot.writeString(self.productName)
8353 
      oprot.writeFieldEnd()
3431 rajveer 8354 
    if self.subject is not None:
1274 varun.gupt 8355 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8356 
      oprot.writeString(self.subject)
8357 
      oprot.writeFieldEnd()
3431 rajveer 8358 
    if self.message is not None:
1274 varun.gupt 8359 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8360 
      oprot.writeString(self.message)
8361 
      oprot.writeFieldEnd()
8362 
    oprot.writeFieldStop()
8363 
    oprot.writeStructEnd()
8364 
 
3431 rajveer 8365 
  def validate(self):
8366 
    return
8367 
 
8368 
 
1274 varun.gupt 8369 
  def __repr__(self):
8370 
    L = ['%s=%r' % (key, value)
8371 
      for key, value in self.__dict__.iteritems()]
8372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8373 
 
8374 
  def __eq__(self, other):
8375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8376 
 
8377 
  def __ne__(self, other):
8378 
    return not (self == other)
8379 
 
8380 
class saveUserCommunication_result:
8381 
  """
8382 
  Attributes:
8383 
   - success
8384 
   - ucx
8385 
  """
8386 
 
8387 
  thrift_spec = (
8388 
    (0, TType.BOOL, 'success', None, None, ), # 0
8389 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8390 
  )
8391 
 
8392 
  def __init__(self, success=None, ucx=None,):
8393 
    self.success = success
8394 
    self.ucx = ucx
8395 
 
8396 
  def read(self, iprot):
8397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8399 
      return
8400 
    iprot.readStructBegin()
8401 
    while True:
8402 
      (fname, ftype, fid) = iprot.readFieldBegin()
8403 
      if ftype == TType.STOP:
8404 
        break
8405 
      if fid == 0:
8406 
        if ftype == TType.BOOL:
8407 
          self.success = iprot.readBool();
8408 
        else:
8409 
          iprot.skip(ftype)
8410 
      elif fid == 1:
8411 
        if ftype == TType.STRUCT:
8412 
          self.ucx = UserCommunicationException()
8413 
          self.ucx.read(iprot)
8414 
        else:
8415 
          iprot.skip(ftype)
8416 
      else:
8417 
        iprot.skip(ftype)
8418 
      iprot.readFieldEnd()
8419 
    iprot.readStructEnd()
8420 
 
8421 
  def write(self, oprot):
8422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8424 
      return
8425 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8426 
    if self.success is not None:
1274 varun.gupt 8427 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8428 
      oprot.writeBool(self.success)
8429 
      oprot.writeFieldEnd()
3431 rajveer 8430 
    if self.ucx is not None:
1274 varun.gupt 8431 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8432 
      self.ucx.write(oprot)
8433 
      oprot.writeFieldEnd()
8434 
    oprot.writeFieldStop()
8435 
    oprot.writeStructEnd()
8436 
 
3431 rajveer 8437 
  def validate(self):
8438 
    return
8439 
 
8440 
 
1274 varun.gupt 8441 
  def __repr__(self):
8442 
    L = ['%s=%r' % (key, value)
8443 
      for key, value in self.__dict__.iteritems()]
8444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8445 
 
8446 
  def __eq__(self, other):
8447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8448 
 
8449 
  def __ne__(self, other):
8450 
    return not (self == other)
8451 
 
1590 varun.gupt 8452 
class getUserCommunicationById_args:
8453 
  """
8454 
  Attributes:
8455 
   - id
8456 
  """
8457 
 
8458 
  thrift_spec = (
8459 
    None, # 0
8460 
    (1, TType.I64, 'id', None, None, ), # 1
8461 
  )
8462 
 
8463 
  def __init__(self, id=None,):
8464 
    self.id = id
8465 
 
8466 
  def read(self, iprot):
8467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8469 
      return
8470 
    iprot.readStructBegin()
8471 
    while True:
8472 
      (fname, ftype, fid) = iprot.readFieldBegin()
8473 
      if ftype == TType.STOP:
8474 
        break
8475 
      if fid == 1:
8476 
        if ftype == TType.I64:
8477 
          self.id = iprot.readI64();
8478 
        else:
8479 
          iprot.skip(ftype)
8480 
      else:
8481 
        iprot.skip(ftype)
8482 
      iprot.readFieldEnd()
8483 
    iprot.readStructEnd()
8484 
 
8485 
  def write(self, oprot):
8486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8488 
      return
8489 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8490 
    if self.id is not None:
1590 varun.gupt 8491 
      oprot.writeFieldBegin('id', TType.I64, 1)
8492 
      oprot.writeI64(self.id)
8493 
      oprot.writeFieldEnd()
8494 
    oprot.writeFieldStop()
8495 
    oprot.writeStructEnd()
8496 
 
3431 rajveer 8497 
  def validate(self):
8498 
    return
8499 
 
8500 
 
1590 varun.gupt 8501 
  def __repr__(self):
8502 
    L = ['%s=%r' % (key, value)
8503 
      for key, value in self.__dict__.iteritems()]
8504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8505 
 
8506 
  def __eq__(self, other):
8507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8508 
 
8509 
  def __ne__(self, other):
8510 
    return not (self == other)
8511 
 
8512 
class getUserCommunicationById_result:
8513 
  """
8514 
  Attributes:
8515 
   - success
8516 
   - ucx
8517 
  """
8518 
 
8519 
  thrift_spec = (
8520 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8521 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8522 
  )
8523 
 
8524 
  def __init__(self, success=None, ucx=None,):
8525 
    self.success = success
8526 
    self.ucx = ucx
8527 
 
8528 
  def read(self, iprot):
8529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8531 
      return
8532 
    iprot.readStructBegin()
8533 
    while True:
8534 
      (fname, ftype, fid) = iprot.readFieldBegin()
8535 
      if ftype == TType.STOP:
8536 
        break
8537 
      if fid == 0:
8538 
        if ftype == TType.STRUCT:
8539 
          self.success = UserCommunication()
8540 
          self.success.read(iprot)
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 1:
8544 
        if ftype == TType.STRUCT:
8545 
          self.ucx = UserCommunicationException()
8546 
          self.ucx.read(iprot)
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      else:
8550 
        iprot.skip(ftype)
8551 
      iprot.readFieldEnd()
8552 
    iprot.readStructEnd()
8553 
 
8554 
  def write(self, oprot):
8555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8557 
      return
8558 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8559 
    if self.success is not None:
1590 varun.gupt 8560 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8561 
      self.success.write(oprot)
8562 
      oprot.writeFieldEnd()
3431 rajveer 8563 
    if self.ucx is not None:
1590 varun.gupt 8564 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8565 
      self.ucx.write(oprot)
8566 
      oprot.writeFieldEnd()
8567 
    oprot.writeFieldStop()
8568 
    oprot.writeStructEnd()
8569 
 
3431 rajveer 8570 
  def validate(self):
8571 
    return
8572 
 
8573 
 
1590 varun.gupt 8574 
  def __repr__(self):
8575 
    L = ['%s=%r' % (key, value)
8576 
      for key, value in self.__dict__.iteritems()]
8577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8578 
 
8579 
  def __eq__(self, other):
8580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8581 
 
8582 
  def __ne__(self, other):
8583 
    return not (self == other)
8584 
 
8585 
class getUserCommunicationByUser_args:
8586 
  """
8587 
  Attributes:
8588 
   - userId
8589 
  """
8590 
 
8591 
  thrift_spec = (
8592 
    None, # 0
8593 
    (1, TType.I64, 'userId', None, None, ), # 1
8594 
  )
8595 
 
8596 
  def __init__(self, userId=None,):
8597 
    self.userId = userId
8598 
 
8599 
  def read(self, iprot):
8600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8602 
      return
8603 
    iprot.readStructBegin()
8604 
    while True:
8605 
      (fname, ftype, fid) = iprot.readFieldBegin()
8606 
      if ftype == TType.STOP:
8607 
        break
8608 
      if fid == 1:
8609 
        if ftype == TType.I64:
8610 
          self.userId = iprot.readI64();
8611 
        else:
8612 
          iprot.skip(ftype)
8613 
      else:
8614 
        iprot.skip(ftype)
8615 
      iprot.readFieldEnd()
8616 
    iprot.readStructEnd()
8617 
 
8618 
  def write(self, oprot):
8619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8621 
      return
8622 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8623 
    if self.userId is not None:
1590 varun.gupt 8624 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8625 
      oprot.writeI64(self.userId)
8626 
      oprot.writeFieldEnd()
8627 
    oprot.writeFieldStop()
8628 
    oprot.writeStructEnd()
8629 
 
3431 rajveer 8630 
  def validate(self):
8631 
    return
8632 
 
8633 
 
1590 varun.gupt 8634 
  def __repr__(self):
8635 
    L = ['%s=%r' % (key, value)
8636 
      for key, value in self.__dict__.iteritems()]
8637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8638 
 
8639 
  def __eq__(self, other):
8640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8641 
 
8642 
  def __ne__(self, other):
8643 
    return not (self == other)
8644 
 
8645 
class getUserCommunicationByUser_result:
8646 
  """
8647 
  Attributes:
8648 
   - success
8649 
   - ucx
8650 
  """
8651 
 
8652 
  thrift_spec = (
8653 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8654 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8655 
  )
8656 
 
8657 
  def __init__(self, success=None, ucx=None,):
8658 
    self.success = success
8659 
    self.ucx = ucx
8660 
 
8661 
  def read(self, iprot):
8662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8664 
      return
8665 
    iprot.readStructBegin()
8666 
    while True:
8667 
      (fname, ftype, fid) = iprot.readFieldBegin()
8668 
      if ftype == TType.STOP:
8669 
        break
8670 
      if fid == 0:
8671 
        if ftype == TType.LIST:
8672 
          self.success = []
11592 amit.gupta 8673 
          (_etype107, _size104) = iprot.readListBegin()
8674 
          for _i108 in xrange(_size104):
8675 
            _elem109 = UserCommunication()
8676 
            _elem109.read(iprot)
8677 
            self.success.append(_elem109)
1590 varun.gupt 8678 
          iprot.readListEnd()
8679 
        else:
8680 
          iprot.skip(ftype)
8681 
      elif fid == 1:
8682 
        if ftype == TType.STRUCT:
8683 
          self.ucx = UserCommunicationException()
8684 
          self.ucx.read(iprot)
8685 
        else:
8686 
          iprot.skip(ftype)
8687 
      else:
8688 
        iprot.skip(ftype)
8689 
      iprot.readFieldEnd()
8690 
    iprot.readStructEnd()
8691 
 
8692 
  def write(self, oprot):
8693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8695 
      return
8696 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8697 
    if self.success is not None:
1590 varun.gupt 8698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8700 
      for iter110 in self.success:
8701 
        iter110.write(oprot)
1590 varun.gupt 8702 
      oprot.writeListEnd()
8703 
      oprot.writeFieldEnd()
3431 rajveer 8704 
    if self.ucx is not None:
1590 varun.gupt 8705 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8706 
      self.ucx.write(oprot)
8707 
      oprot.writeFieldEnd()
8708 
    oprot.writeFieldStop()
8709 
    oprot.writeStructEnd()
8710 
 
3431 rajveer 8711 
  def validate(self):
8712 
    return
8713 
 
8714 
 
1590 varun.gupt 8715 
  def __repr__(self):
8716 
    L = ['%s=%r' % (key, value)
8717 
      for key, value in self.__dict__.iteritems()]
8718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8719 
 
8720 
  def __eq__(self, other):
8721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8722 
 
8723 
  def __ne__(self, other):
8724 
    return not (self == other)
8725 
 
8726 
class getAllUserCommunications_args:
8727 
 
8728 
  thrift_spec = (
8729 
  )
8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      else:
8741 
        iprot.skip(ftype)
8742 
      iprot.readFieldEnd()
8743 
    iprot.readStructEnd()
8744 
 
8745 
  def write(self, oprot):
8746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8748 
      return
8749 
    oprot.writeStructBegin('getAllUserCommunications_args')
8750 
    oprot.writeFieldStop()
8751 
    oprot.writeStructEnd()
8752 
 
3431 rajveer 8753 
  def validate(self):
8754 
    return
8755 
 
8756 
 
1590 varun.gupt 8757 
  def __repr__(self):
8758 
    L = ['%s=%r' % (key, value)
8759 
      for key, value in self.__dict__.iteritems()]
8760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8761 
 
8762 
  def __eq__(self, other):
8763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8764 
 
8765 
  def __ne__(self, other):
8766 
    return not (self == other)
8767 
 
8768 
class getAllUserCommunications_result:
8769 
  """
8770 
  Attributes:
8771 
   - success
8772 
   - ucx
8773 
  """
8774 
 
8775 
  thrift_spec = (
8776 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8777 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8778 
  )
8779 
 
8780 
  def __init__(self, success=None, ucx=None,):
8781 
    self.success = success
8782 
    self.ucx = ucx
8783 
 
8784 
  def read(self, iprot):
8785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8787 
      return
8788 
    iprot.readStructBegin()
8789 
    while True:
8790 
      (fname, ftype, fid) = iprot.readFieldBegin()
8791 
      if ftype == TType.STOP:
8792 
        break
8793 
      if fid == 0:
8794 
        if ftype == TType.LIST:
8795 
          self.success = []
11592 amit.gupta 8796 
          (_etype114, _size111) = iprot.readListBegin()
8797 
          for _i115 in xrange(_size111):
8798 
            _elem116 = UserCommunication()
8799 
            _elem116.read(iprot)
8800 
            self.success.append(_elem116)
1590 varun.gupt 8801 
          iprot.readListEnd()
8802 
        else:
8803 
          iprot.skip(ftype)
8804 
      elif fid == 1:
8805 
        if ftype == TType.STRUCT:
8806 
          self.ucx = UserCommunicationException()
8807 
          self.ucx.read(iprot)
8808 
        else:
8809 
          iprot.skip(ftype)
8810 
      else:
8811 
        iprot.skip(ftype)
8812 
      iprot.readFieldEnd()
8813 
    iprot.readStructEnd()
8814 
 
8815 
  def write(self, oprot):
8816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8818 
      return
8819 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8820 
    if self.success is not None:
1590 varun.gupt 8821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8823 
      for iter117 in self.success:
8824 
        iter117.write(oprot)
1590 varun.gupt 8825 
      oprot.writeListEnd()
8826 
      oprot.writeFieldEnd()
3431 rajveer 8827 
    if self.ucx is not None:
1590 varun.gupt 8828 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8829 
      self.ucx.write(oprot)
8830 
      oprot.writeFieldEnd()
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
3431 rajveer 8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
1590 varun.gupt 8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
5407 amar.kumar 8849 
class removeUserCommunication_args:
8850 
  """
8851 
  Attributes:
8852 
   - id
8853 
  """
8854 
 
8855 
  thrift_spec = (
8856 
    None, # 0
8857 
    (1, TType.I64, 'id', None, None, ), # 1
8858 
  )
8859 
 
8860 
  def __init__(self, id=None,):
8861 
    self.id = id
8862 
 
8863 
  def read(self, iprot):
8864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8866 
      return
8867 
    iprot.readStructBegin()
8868 
    while True:
8869 
      (fname, ftype, fid) = iprot.readFieldBegin()
8870 
      if ftype == TType.STOP:
8871 
        break
8872 
      if fid == 1:
8873 
        if ftype == TType.I64:
8874 
          self.id = iprot.readI64();
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      else:
8878 
        iprot.skip(ftype)
8879 
      iprot.readFieldEnd()
8880 
    iprot.readStructEnd()
8881 
 
8882 
  def write(self, oprot):
8883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8885 
      return
8886 
    oprot.writeStructBegin('removeUserCommunication_args')
8887 
    if self.id is not None:
8888 
      oprot.writeFieldBegin('id', TType.I64, 1)
8889 
      oprot.writeI64(self.id)
8890 
      oprot.writeFieldEnd()
8891 
    oprot.writeFieldStop()
8892 
    oprot.writeStructEnd()
8893 
 
8894 
  def validate(self):
8895 
    return
8896 
 
8897 
 
8898 
  def __repr__(self):
8899 
    L = ['%s=%r' % (key, value)
8900 
      for key, value in self.__dict__.iteritems()]
8901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8902 
 
8903 
  def __eq__(self, other):
8904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8905 
 
8906 
  def __ne__(self, other):
8907 
    return not (self == other)
8908 
 
8909 
class removeUserCommunication_result:
8910 
  """
8911 
  Attributes:
8912 
   - ucx
8913 
  """
8914 
 
8915 
  thrift_spec = (
8916 
    None, # 0
8917 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8918 
  )
8919 
 
8920 
  def __init__(self, ucx=None,):
8921 
    self.ucx = ucx
8922 
 
8923 
  def read(self, iprot):
8924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8926 
      return
8927 
    iprot.readStructBegin()
8928 
    while True:
8929 
      (fname, ftype, fid) = iprot.readFieldBegin()
8930 
      if ftype == TType.STOP:
8931 
        break
8932 
      if fid == 1:
8933 
        if ftype == TType.STRUCT:
8934 
          self.ucx = UserCommunicationException()
8935 
          self.ucx.read(iprot)
8936 
        else:
8937 
          iprot.skip(ftype)
8938 
      else:
8939 
        iprot.skip(ftype)
8940 
      iprot.readFieldEnd()
8941 
    iprot.readStructEnd()
8942 
 
8943 
  def write(self, oprot):
8944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8946 
      return
8947 
    oprot.writeStructBegin('removeUserCommunication_result')
8948 
    if self.ucx is not None:
8949 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8950 
      self.ucx.write(oprot)
8951 
      oprot.writeFieldEnd()
8952 
    oprot.writeFieldStop()
8953 
    oprot.writeStructEnd()
8954 
 
8955 
  def validate(self):
8956 
    return
8957 
 
8958 
 
8959 
  def __repr__(self):
8960 
    L = ['%s=%r' % (key, value)
8961 
      for key, value in self.__dict__.iteritems()]
8962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8963 
 
8964 
  def __eq__(self, other):
8965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8966 
 
8967 
  def __ne__(self, other):
8968 
    return not (self == other)
8969 
 
1845 vikas 8970 
class createMasterAffiliate_args:
8971 
  """
8972 
  Attributes:
8973 
   - name
1859 vikas 8974 
   - addedOn
1845 vikas 8975 
  """
8976 
 
8977 
  thrift_spec = (
8978 
    None, # 0
8979 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8980 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8981 
  )
8982 
 
1859 vikas 8983 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8984 
    self.name = name
1859 vikas 8985 
    self.addedOn = addedOn
1845 vikas 8986 
 
8987 
  def read(self, iprot):
8988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8990 
      return
8991 
    iprot.readStructBegin()
8992 
    while True:
8993 
      (fname, ftype, fid) = iprot.readFieldBegin()
8994 
      if ftype == TType.STOP:
8995 
        break
8996 
      if fid == 1:
8997 
        if ftype == TType.STRING:
8998 
          self.name = iprot.readString();
8999 
        else:
9000 
          iprot.skip(ftype)
1859 vikas 9001 
      elif fid == 2:
9002 
        if ftype == TType.I64:
9003 
          self.addedOn = iprot.readI64();
9004 
        else:
9005 
          iprot.skip(ftype)
1845 vikas 9006 
      else:
9007 
        iprot.skip(ftype)
9008 
      iprot.readFieldEnd()
9009 
    iprot.readStructEnd()
9010 
 
9011 
  def write(self, oprot):
9012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9014 
      return
9015 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 9016 
    if self.name is not None:
1845 vikas 9017 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9018 
      oprot.writeString(self.name)
9019 
      oprot.writeFieldEnd()
3431 rajveer 9020 
    if self.addedOn is not None:
1859 vikas 9021 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
9022 
      oprot.writeI64(self.addedOn)
9023 
      oprot.writeFieldEnd()
1845 vikas 9024 
    oprot.writeFieldStop()
9025 
    oprot.writeStructEnd()
9026 
 
3431 rajveer 9027 
  def validate(self):
9028 
    return
9029 
 
9030 
 
1845 vikas 9031 
  def __repr__(self):
9032 
    L = ['%s=%r' % (key, value)
9033 
      for key, value in self.__dict__.iteritems()]
9034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9035 
 
9036 
  def __eq__(self, other):
9037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9038 
 
9039 
  def __ne__(self, other):
9040 
    return not (self == other)
9041 
 
9042 
class createMasterAffiliate_result:
9043 
  """
9044 
  Attributes:
9045 
   - success
9046 
   - utx
9047 
  """
9048 
 
9049 
  thrift_spec = (
9050 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9051 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9052 
  )
9053 
 
9054 
  def __init__(self, success=None, utx=None,):
9055 
    self.success = success
9056 
    self.utx = utx
9057 
 
9058 
  def read(self, iprot):
9059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9061 
      return
9062 
    iprot.readStructBegin()
9063 
    while True:
9064 
      (fname, ftype, fid) = iprot.readFieldBegin()
9065 
      if ftype == TType.STOP:
9066 
        break
9067 
      if fid == 0:
9068 
        if ftype == TType.STRUCT:
9069 
          self.success = MasterAffiliate()
9070 
          self.success.read(iprot)
9071 
        else:
9072 
          iprot.skip(ftype)
9073 
      elif fid == 1:
9074 
        if ftype == TType.STRUCT:
1996 vikas 9075 
          self.utx = UserAffiliateException()
1845 vikas 9076 
          self.utx.read(iprot)
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      else:
9080 
        iprot.skip(ftype)
9081 
      iprot.readFieldEnd()
9082 
    iprot.readStructEnd()
9083 
 
9084 
  def write(self, oprot):
9085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9087 
      return
9088 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 9089 
    if self.success is not None:
1845 vikas 9090 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9091 
      self.success.write(oprot)
9092 
      oprot.writeFieldEnd()
3431 rajveer 9093 
    if self.utx is not None:
1845 vikas 9094 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9095 
      self.utx.write(oprot)
9096 
      oprot.writeFieldEnd()
9097 
    oprot.writeFieldStop()
9098 
    oprot.writeStructEnd()
9099 
 
3431 rajveer 9100 
  def validate(self):
9101 
    return
9102 
 
9103 
 
1845 vikas 9104 
  def __repr__(self):
9105 
    L = ['%s=%r' % (key, value)
9106 
      for key, value in self.__dict__.iteritems()]
9107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9108 
 
9109 
  def __eq__(self, other):
9110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9111 
 
9112 
  def __ne__(self, other):
9113 
    return not (self == other)
9114 
 
1899 vikas 9115 
class getAllMasterAffiliates_args:
9116 
 
9117 
  thrift_spec = (
9118 
  )
9119 
 
9120 
  def read(self, iprot):
9121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9123 
      return
9124 
    iprot.readStructBegin()
9125 
    while True:
9126 
      (fname, ftype, fid) = iprot.readFieldBegin()
9127 
      if ftype == TType.STOP:
9128 
        break
9129 
      else:
9130 
        iprot.skip(ftype)
9131 
      iprot.readFieldEnd()
9132 
    iprot.readStructEnd()
9133 
 
9134 
  def write(self, oprot):
9135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9137 
      return
9138 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
9139 
    oprot.writeFieldStop()
9140 
    oprot.writeStructEnd()
9141 
 
3431 rajveer 9142 
  def validate(self):
9143 
    return
9144 
 
9145 
 
1899 vikas 9146 
  def __repr__(self):
9147 
    L = ['%s=%r' % (key, value)
9148 
      for key, value in self.__dict__.iteritems()]
9149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9150 
 
9151 
  def __eq__(self, other):
9152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9153 
 
9154 
  def __ne__(self, other):
9155 
    return not (self == other)
9156 
 
9157 
class getAllMasterAffiliates_result:
9158 
  """
9159 
  Attributes:
9160 
   - success
9161 
   - utx
9162 
  """
9163 
 
9164 
  thrift_spec = (
9165 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 9166 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 9167 
  )
9168 
 
9169 
  def __init__(self, success=None, utx=None,):
9170 
    self.success = success
9171 
    self.utx = utx
9172 
 
9173 
  def read(self, iprot):
9174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9176 
      return
9177 
    iprot.readStructBegin()
9178 
    while True:
9179 
      (fname, ftype, fid) = iprot.readFieldBegin()
9180 
      if ftype == TType.STOP:
9181 
        break
9182 
      if fid == 0:
9183 
        if ftype == TType.LIST:
9184 
          self.success = []
11592 amit.gupta 9185 
          (_etype121, _size118) = iprot.readListBegin()
9186 
          for _i122 in xrange(_size118):
9187 
            _elem123 = MasterAffiliate()
9188 
            _elem123.read(iprot)
9189 
            self.success.append(_elem123)
1899 vikas 9190 
          iprot.readListEnd()
9191 
        else:
9192 
          iprot.skip(ftype)
9193 
      elif fid == 1:
9194 
        if ftype == TType.STRUCT:
1996 vikas 9195 
          self.utx = UserAffiliateException()
1899 vikas 9196 
          self.utx.read(iprot)
9197 
        else:
9198 
          iprot.skip(ftype)
9199 
      else:
9200 
        iprot.skip(ftype)
9201 
      iprot.readFieldEnd()
9202 
    iprot.readStructEnd()
9203 
 
9204 
  def write(self, oprot):
9205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9207 
      return
9208 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 9209 
    if self.success is not None:
1899 vikas 9210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9212 
      for iter124 in self.success:
9213 
        iter124.write(oprot)
1899 vikas 9214 
      oprot.writeListEnd()
9215 
      oprot.writeFieldEnd()
3431 rajveer 9216 
    if self.utx is not None:
1899 vikas 9217 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9218 
      self.utx.write(oprot)
9219 
      oprot.writeFieldEnd()
9220 
    oprot.writeFieldStop()
9221 
    oprot.writeStructEnd()
9222 
 
3431 rajveer 9223 
  def validate(self):
9224 
    return
9225 
 
9226 
 
1899 vikas 9227 
  def __repr__(self):
9228 
    L = ['%s=%r' % (key, value)
9229 
      for key, value in self.__dict__.iteritems()]
9230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9231 
 
9232 
  def __eq__(self, other):
9233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9234 
 
9235 
  def __ne__(self, other):
9236 
    return not (self == other)
9237 
 
1845 vikas 9238 
class getMasterAffiliateById_args:
9239 
  """
9240 
  Attributes:
9241 
   - id
9242 
  """
9243 
 
9244 
  thrift_spec = (
9245 
    None, # 0
9246 
    (1, TType.I64, 'id', None, None, ), # 1
9247 
  )
9248 
 
9249 
  def __init__(self, id=None,):
9250 
    self.id = id
9251 
 
9252 
  def read(self, iprot):
9253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9255 
      return
9256 
    iprot.readStructBegin()
9257 
    while True:
9258 
      (fname, ftype, fid) = iprot.readFieldBegin()
9259 
      if ftype == TType.STOP:
9260 
        break
9261 
      if fid == 1:
9262 
        if ftype == TType.I64:
9263 
          self.id = iprot.readI64();
9264 
        else:
9265 
          iprot.skip(ftype)
9266 
      else:
9267 
        iprot.skip(ftype)
9268 
      iprot.readFieldEnd()
9269 
    iprot.readStructEnd()
9270 
 
9271 
  def write(self, oprot):
9272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9274 
      return
9275 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 9276 
    if self.id is not None:
1845 vikas 9277 
      oprot.writeFieldBegin('id', TType.I64, 1)
9278 
      oprot.writeI64(self.id)
9279 
      oprot.writeFieldEnd()
9280 
    oprot.writeFieldStop()
9281 
    oprot.writeStructEnd()
9282 
 
3431 rajveer 9283 
  def validate(self):
9284 
    return
9285 
 
9286 
 
1845 vikas 9287 
  def __repr__(self):
9288 
    L = ['%s=%r' % (key, value)
9289 
      for key, value in self.__dict__.iteritems()]
9290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9291 
 
9292 
  def __eq__(self, other):
9293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9294 
 
9295 
  def __ne__(self, other):
9296 
    return not (self == other)
9297 
 
9298 
class getMasterAffiliateById_result:
9299 
  """
9300 
  Attributes:
9301 
   - success
9302 
   - utx
9303 
  """
9304 
 
9305 
  thrift_spec = (
9306 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9307 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9308 
  )
9309 
 
9310 
  def __init__(self, success=None, utx=None,):
9311 
    self.success = success
9312 
    self.utx = utx
9313 
 
9314 
  def read(self, iprot):
9315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9317 
      return
9318 
    iprot.readStructBegin()
9319 
    while True:
9320 
      (fname, ftype, fid) = iprot.readFieldBegin()
9321 
      if ftype == TType.STOP:
9322 
        break
9323 
      if fid == 0:
9324 
        if ftype == TType.STRUCT:
9325 
          self.success = MasterAffiliate()
9326 
          self.success.read(iprot)
9327 
        else:
9328 
          iprot.skip(ftype)
9329 
      elif fid == 1:
9330 
        if ftype == TType.STRUCT:
1996 vikas 9331 
          self.utx = UserAffiliateException()
1845 vikas 9332 
          self.utx.read(iprot)
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      else:
9336 
        iprot.skip(ftype)
9337 
      iprot.readFieldEnd()
9338 
    iprot.readStructEnd()
9339 
 
9340 
  def write(self, oprot):
9341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9343 
      return
9344 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9345 
    if self.success is not None:
1845 vikas 9346 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9347 
      self.success.write(oprot)
9348 
      oprot.writeFieldEnd()
3431 rajveer 9349 
    if self.utx is not None:
1845 vikas 9350 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9351 
      self.utx.write(oprot)
9352 
      oprot.writeFieldEnd()
9353 
    oprot.writeFieldStop()
9354 
    oprot.writeStructEnd()
9355 
 
3431 rajveer 9356 
  def validate(self):
9357 
    return
9358 
 
9359 
 
1845 vikas 9360 
  def __repr__(self):
9361 
    L = ['%s=%r' % (key, value)
9362 
      for key, value in self.__dict__.iteritems()]
9363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9364 
 
9365 
  def __eq__(self, other):
9366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9367 
 
9368 
  def __ne__(self, other):
9369 
    return not (self == other)
9370 
 
9371 
class getMasterAffiliateByName_args:
9372 
  """
9373 
  Attributes:
9374 
   - name
9375 
  """
9376 
 
9377 
  thrift_spec = (
9378 
    None, # 0
9379 
    (1, TType.STRING, 'name', None, None, ), # 1
9380 
  )
9381 
 
9382 
  def __init__(self, name=None,):
9383 
    self.name = name
9384 
 
9385 
  def read(self, iprot):
9386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9388 
      return
9389 
    iprot.readStructBegin()
9390 
    while True:
9391 
      (fname, ftype, fid) = iprot.readFieldBegin()
9392 
      if ftype == TType.STOP:
9393 
        break
9394 
      if fid == 1:
9395 
        if ftype == TType.STRING:
9396 
          self.name = iprot.readString();
9397 
        else:
9398 
          iprot.skip(ftype)
9399 
      else:
9400 
        iprot.skip(ftype)
9401 
      iprot.readFieldEnd()
9402 
    iprot.readStructEnd()
9403 
 
9404 
  def write(self, oprot):
9405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9407 
      return
9408 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9409 
    if self.name is not None:
1845 vikas 9410 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9411 
      oprot.writeString(self.name)
9412 
      oprot.writeFieldEnd()
9413 
    oprot.writeFieldStop()
9414 
    oprot.writeStructEnd()
9415 
 
3431 rajveer 9416 
  def validate(self):
9417 
    return
9418 
 
9419 
 
1845 vikas 9420 
  def __repr__(self):
9421 
    L = ['%s=%r' % (key, value)
9422 
      for key, value in self.__dict__.iteritems()]
9423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9424 
 
9425 
  def __eq__(self, other):
9426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9427 
 
9428 
  def __ne__(self, other):
9429 
    return not (self == other)
9430 
 
9431 
class getMasterAffiliateByName_result:
9432 
  """
9433 
  Attributes:
9434 
   - success
9435 
   - utx
9436 
  """
9437 
 
9438 
  thrift_spec = (
9439 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9440 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9441 
  )
9442 
 
9443 
  def __init__(self, success=None, utx=None,):
9444 
    self.success = success
9445 
    self.utx = utx
9446 
 
9447 
  def read(self, iprot):
9448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9450 
      return
9451 
    iprot.readStructBegin()
9452 
    while True:
9453 
      (fname, ftype, fid) = iprot.readFieldBegin()
9454 
      if ftype == TType.STOP:
9455 
        break
9456 
      if fid == 0:
9457 
        if ftype == TType.STRUCT:
9458 
          self.success = MasterAffiliate()
9459 
          self.success.read(iprot)
9460 
        else:
9461 
          iprot.skip(ftype)
9462 
      elif fid == 1:
9463 
        if ftype == TType.STRUCT:
1996 vikas 9464 
          self.utx = UserAffiliateException()
1845 vikas 9465 
          self.utx.read(iprot)
9466 
        else:
9467 
          iprot.skip(ftype)
9468 
      else:
9469 
        iprot.skip(ftype)
9470 
      iprot.readFieldEnd()
9471 
    iprot.readStructEnd()
9472 
 
9473 
  def write(self, oprot):
9474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9476 
      return
9477 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9478 
    if self.success is not None:
1845 vikas 9479 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9480 
      self.success.write(oprot)
9481 
      oprot.writeFieldEnd()
3431 rajveer 9482 
    if self.utx is not None:
1845 vikas 9483 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9484 
      self.utx.write(oprot)
9485 
      oprot.writeFieldEnd()
9486 
    oprot.writeFieldStop()
9487 
    oprot.writeStructEnd()
9488 
 
3431 rajveer 9489 
  def validate(self):
9490 
    return
9491 
 
9492 
 
1845 vikas 9493 
  def __repr__(self):
9494 
    L = ['%s=%r' % (key, value)
9495 
      for key, value in self.__dict__.iteritems()]
9496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9497 
 
9498 
  def __eq__(self, other):
9499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9500 
 
9501 
  def __ne__(self, other):
9502 
    return not (self == other)
9503 
 
9504 
class createAffiliate_args:
9505 
  """
9506 
  Attributes:
9507 
   - name
9508 
   - url
9509 
   - masterAffiliateId
1859 vikas 9510 
   - addedOn
1845 vikas 9511 
  """
9512 
 
9513 
  thrift_spec = (
9514 
    None, # 0
9515 
    (1, TType.STRING, 'name', None, None, ), # 1
9516 
    (2, TType.STRING, 'url', None, None, ), # 2
9517 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9518 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9519 
  )
9520 
 
1859 vikas 9521 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9522 
    self.name = name
9523 
    self.url = url
9524 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9525 
    self.addedOn = addedOn
1845 vikas 9526 
 
9527 
  def read(self, iprot):
9528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9530 
      return
9531 
    iprot.readStructBegin()
9532 
    while True:
9533 
      (fname, ftype, fid) = iprot.readFieldBegin()
9534 
      if ftype == TType.STOP:
9535 
        break
9536 
      if fid == 1:
9537 
        if ftype == TType.STRING:
9538 
          self.name = iprot.readString();
9539 
        else:
9540 
          iprot.skip(ftype)
9541 
      elif fid == 2:
9542 
        if ftype == TType.STRING:
9543 
          self.url = iprot.readString();
9544 
        else:
9545 
          iprot.skip(ftype)
9546 
      elif fid == 3:
9547 
        if ftype == TType.I64:
9548 
          self.masterAffiliateId = iprot.readI64();
9549 
        else:
9550 
          iprot.skip(ftype)
1859 vikas 9551 
      elif fid == 4:
9552 
        if ftype == TType.I64:
9553 
          self.addedOn = iprot.readI64();
9554 
        else:
9555 
          iprot.skip(ftype)
1845 vikas 9556 
      else:
9557 
        iprot.skip(ftype)
9558 
      iprot.readFieldEnd()
9559 
    iprot.readStructEnd()
9560 
 
9561 
  def write(self, oprot):
9562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9564 
      return
9565 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9566 
    if self.name is not None:
1845 vikas 9567 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9568 
      oprot.writeString(self.name)
9569 
      oprot.writeFieldEnd()
3431 rajveer 9570 
    if self.url is not None:
1845 vikas 9571 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9572 
      oprot.writeString(self.url)
9573 
      oprot.writeFieldEnd()
3431 rajveer 9574 
    if self.masterAffiliateId is not None:
1845 vikas 9575 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9576 
      oprot.writeI64(self.masterAffiliateId)
9577 
      oprot.writeFieldEnd()
3431 rajveer 9578 
    if self.addedOn is not None:
1859 vikas 9579 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9580 
      oprot.writeI64(self.addedOn)
9581 
      oprot.writeFieldEnd()
1845 vikas 9582 
    oprot.writeFieldStop()
9583 
    oprot.writeStructEnd()
9584 
 
3431 rajveer 9585 
  def validate(self):
9586 
    return
9587 
 
9588 
 
1845 vikas 9589 
  def __repr__(self):
9590 
    L = ['%s=%r' % (key, value)
9591 
      for key, value in self.__dict__.iteritems()]
9592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9593 
 
9594 
  def __eq__(self, other):
9595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9596 
 
9597 
  def __ne__(self, other):
9598 
    return not (self == other)
9599 
 
9600 
class createAffiliate_result:
9601 
  """
9602 
  Attributes:
9603 
   - success
9604 
   - utx
9605 
  """
9606 
 
9607 
  thrift_spec = (
9608 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9609 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9610 
  )
9611 
 
9612 
  def __init__(self, success=None, utx=None,):
9613 
    self.success = success
9614 
    self.utx = utx
9615 
 
9616 
  def read(self, iprot):
9617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9619 
      return
9620 
    iprot.readStructBegin()
9621 
    while True:
9622 
      (fname, ftype, fid) = iprot.readFieldBegin()
9623 
      if ftype == TType.STOP:
9624 
        break
9625 
      if fid == 0:
9626 
        if ftype == TType.STRUCT:
9627 
          self.success = Affiliate()
9628 
          self.success.read(iprot)
9629 
        else:
9630 
          iprot.skip(ftype)
9631 
      elif fid == 1:
9632 
        if ftype == TType.STRUCT:
1996 vikas 9633 
          self.utx = UserAffiliateException()
1845 vikas 9634 
          self.utx.read(iprot)
9635 
        else:
9636 
          iprot.skip(ftype)
9637 
      else:
9638 
        iprot.skip(ftype)
9639 
      iprot.readFieldEnd()
9640 
    iprot.readStructEnd()
9641 
 
9642 
  def write(self, oprot):
9643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9645 
      return
9646 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9647 
    if self.success is not None:
1845 vikas 9648 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9649 
      self.success.write(oprot)
9650 
      oprot.writeFieldEnd()
3431 rajveer 9651 
    if self.utx is not None:
1845 vikas 9652 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9653 
      self.utx.write(oprot)
9654 
      oprot.writeFieldEnd()
9655 
    oprot.writeFieldStop()
9656 
    oprot.writeStructEnd()
9657 
 
3431 rajveer 9658 
  def validate(self):
9659 
    return
9660 
 
9661 
 
1845 vikas 9662 
  def __repr__(self):
9663 
    L = ['%s=%r' % (key, value)
9664 
      for key, value in self.__dict__.iteritems()]
9665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9666 
 
9667 
  def __eq__(self, other):
9668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9669 
 
9670 
  def __ne__(self, other):
9671 
    return not (self == other)
9672 
 
9673 
class getAffiliateById_args:
9674 
  """
9675 
  Attributes:
9676 
   - id
9677 
  """
9678 
 
9679 
  thrift_spec = (
9680 
    None, # 0
9681 
    (1, TType.I64, 'id', None, None, ), # 1
9682 
  )
9683 
 
9684 
  def __init__(self, id=None,):
9685 
    self.id = id
9686 
 
9687 
  def read(self, iprot):
9688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9690 
      return
9691 
    iprot.readStructBegin()
9692 
    while True:
9693 
      (fname, ftype, fid) = iprot.readFieldBegin()
9694 
      if ftype == TType.STOP:
9695 
        break
9696 
      if fid == 1:
9697 
        if ftype == TType.I64:
9698 
          self.id = iprot.readI64();
9699 
        else:
9700 
          iprot.skip(ftype)
9701 
      else:
9702 
        iprot.skip(ftype)
9703 
      iprot.readFieldEnd()
9704 
    iprot.readStructEnd()
9705 
 
9706 
  def write(self, oprot):
9707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9709 
      return
9710 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9711 
    if self.id is not None:
1845 vikas 9712 
      oprot.writeFieldBegin('id', TType.I64, 1)
9713 
      oprot.writeI64(self.id)
9714 
      oprot.writeFieldEnd()
9715 
    oprot.writeFieldStop()
9716 
    oprot.writeStructEnd()
9717 
 
3431 rajveer 9718 
  def validate(self):
9719 
    return
9720 
 
9721 
 
1845 vikas 9722 
  def __repr__(self):
9723 
    L = ['%s=%r' % (key, value)
9724 
      for key, value in self.__dict__.iteritems()]
9725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9726 
 
9727 
  def __eq__(self, other):
9728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9729 
 
9730 
  def __ne__(self, other):
9731 
    return not (self == other)
9732 
 
9733 
class getAffiliateById_result:
9734 
  """
9735 
  Attributes:
9736 
   - success
9737 
   - utx
9738 
  """
9739 
 
9740 
  thrift_spec = (
9741 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9742 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9743 
  )
9744 
 
9745 
  def __init__(self, success=None, utx=None,):
9746 
    self.success = success
9747 
    self.utx = utx
9748 
 
9749 
  def read(self, iprot):
9750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9752 
      return
9753 
    iprot.readStructBegin()
9754 
    while True:
9755 
      (fname, ftype, fid) = iprot.readFieldBegin()
9756 
      if ftype == TType.STOP:
9757 
        break
9758 
      if fid == 0:
9759 
        if ftype == TType.STRUCT:
9760 
          self.success = Affiliate()
9761 
          self.success.read(iprot)
9762 
        else:
9763 
          iprot.skip(ftype)
9764 
      elif fid == 1:
9765 
        if ftype == TType.STRUCT:
1996 vikas 9766 
          self.utx = UserAffiliateException()
1845 vikas 9767 
          self.utx.read(iprot)
9768 
        else:
9769 
          iprot.skip(ftype)
9770 
      else:
9771 
        iprot.skip(ftype)
9772 
      iprot.readFieldEnd()
9773 
    iprot.readStructEnd()
9774 
 
9775 
  def write(self, oprot):
9776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9778 
      return
9779 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9780 
    if self.success is not None:
1845 vikas 9781 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9782 
      self.success.write(oprot)
9783 
      oprot.writeFieldEnd()
3431 rajveer 9784 
    if self.utx is not None:
1845 vikas 9785 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9786 
      self.utx.write(oprot)
9787 
      oprot.writeFieldEnd()
9788 
    oprot.writeFieldStop()
9789 
    oprot.writeStructEnd()
9790 
 
3431 rajveer 9791 
  def validate(self):
9792 
    return
9793 
 
9794 
 
1845 vikas 9795 
  def __repr__(self):
9796 
    L = ['%s=%r' % (key, value)
9797 
      for key, value in self.__dict__.iteritems()]
9798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9799 
 
9800 
  def __eq__(self, other):
9801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9802 
 
9803 
  def __ne__(self, other):
9804 
    return not (self == other)
9805 
 
9806 
class getAffiliateByName_args:
9807 
  """
9808 
  Attributes:
9809 
   - name
9810 
  """
9811 
 
9812 
  thrift_spec = (
9813 
    None, # 0
9814 
    (1, TType.STRING, 'name', None, None, ), # 1
9815 
  )
9816 
 
9817 
  def __init__(self, name=None,):
9818 
    self.name = name
9819 
 
9820 
  def read(self, iprot):
9821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9823 
      return
9824 
    iprot.readStructBegin()
9825 
    while True:
9826 
      (fname, ftype, fid) = iprot.readFieldBegin()
9827 
      if ftype == TType.STOP:
9828 
        break
9829 
      if fid == 1:
9830 
        if ftype == TType.STRING:
9831 
          self.name = iprot.readString();
9832 
        else:
9833 
          iprot.skip(ftype)
9834 
      else:
9835 
        iprot.skip(ftype)
9836 
      iprot.readFieldEnd()
9837 
    iprot.readStructEnd()
9838 
 
9839 
  def write(self, oprot):
9840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9842 
      return
9843 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9844 
    if self.name is not None:
1845 vikas 9845 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9846 
      oprot.writeString(self.name)
9847 
      oprot.writeFieldEnd()
9848 
    oprot.writeFieldStop()
9849 
    oprot.writeStructEnd()
9850 
 
3431 rajveer 9851 
  def validate(self):
9852 
    return
9853 
 
9854 
 
1845 vikas 9855 
  def __repr__(self):
9856 
    L = ['%s=%r' % (key, value)
9857 
      for key, value in self.__dict__.iteritems()]
9858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9859 
 
9860 
  def __eq__(self, other):
9861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9862 
 
9863 
  def __ne__(self, other):
9864 
    return not (self == other)
9865 
 
9866 
class getAffiliateByName_result:
9867 
  """
9868 
  Attributes:
9869 
   - success
9870 
   - utx
9871 
  """
9872 
 
9873 
  thrift_spec = (
9874 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9875 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9876 
  )
9877 
 
9878 
  def __init__(self, success=None, utx=None,):
9879 
    self.success = success
9880 
    self.utx = utx
9881 
 
9882 
  def read(self, iprot):
9883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9885 
      return
9886 
    iprot.readStructBegin()
9887 
    while True:
9888 
      (fname, ftype, fid) = iprot.readFieldBegin()
9889 
      if ftype == TType.STOP:
9890 
        break
9891 
      if fid == 0:
9892 
        if ftype == TType.STRUCT:
9893 
          self.success = Affiliate()
9894 
          self.success.read(iprot)
9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      elif fid == 1:
9898 
        if ftype == TType.STRUCT:
1996 vikas 9899 
          self.utx = UserAffiliateException()
1845 vikas 9900 
          self.utx.read(iprot)
9901 
        else:
9902 
          iprot.skip(ftype)
9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
9912 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9913 
    if self.success is not None:
1845 vikas 9914 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9915 
      self.success.write(oprot)
9916 
      oprot.writeFieldEnd()
3431 rajveer 9917 
    if self.utx is not None:
1845 vikas 9918 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9919 
      self.utx.write(oprot)
9920 
      oprot.writeFieldEnd()
9921 
    oprot.writeFieldStop()
9922 
    oprot.writeStructEnd()
9923 
 
3431 rajveer 9924 
  def validate(self):
9925 
    return
9926 
 
9927 
 
1845 vikas 9928 
  def __repr__(self):
9929 
    L = ['%s=%r' % (key, value)
9930 
      for key, value in self.__dict__.iteritems()]
9931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9932 
 
9933 
  def __eq__(self, other):
9934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9935 
 
9936 
  def __ne__(self, other):
9937 
    return not (self == other)
9938 
 
1996 vikas 9939 
class getTrackerById_args:
1845 vikas 9940 
  """
9941 
  Attributes:
9942 
   - id
9943 
  """
9944 
 
9945 
  thrift_spec = (
9946 
    None, # 0
9947 
    (1, TType.I64, 'id', None, None, ), # 1
9948 
  )
9949 
 
9950 
  def __init__(self, id=None,):
9951 
    self.id = id
9952 
 
9953 
  def read(self, iprot):
9954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9956 
      return
9957 
    iprot.readStructBegin()
9958 
    while True:
9959 
      (fname, ftype, fid) = iprot.readFieldBegin()
9960 
      if ftype == TType.STOP:
9961 
        break
9962 
      if fid == 1:
9963 
        if ftype == TType.I64:
9964 
          self.id = iprot.readI64();
9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      else:
9968 
        iprot.skip(ftype)
9969 
      iprot.readFieldEnd()
9970 
    iprot.readStructEnd()
9971 
 
9972 
  def write(self, oprot):
9973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9975 
      return
1996 vikas 9976 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9977 
    if self.id is not None:
1845 vikas 9978 
      oprot.writeFieldBegin('id', TType.I64, 1)
9979 
      oprot.writeI64(self.id)
9980 
      oprot.writeFieldEnd()
9981 
    oprot.writeFieldStop()
9982 
    oprot.writeStructEnd()
9983 
 
3431 rajveer 9984 
  def validate(self):
9985 
    return
9986 
 
9987 
 
1845 vikas 9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
9999 
class getTrackerById_result:
10000 
  """
10001 
  Attributes:
10002 
   - success
10003 
   - utx
10004 
  """
10005 
 
10006 
  thrift_spec = (
10007 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 10008 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10009 
  )
10010 
 
10011 
  def __init__(self, success=None, utx=None,):
10012 
    self.success = success
10013 
    self.utx = utx
10014 
 
10015 
  def read(self, iprot):
10016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10018 
      return
10019 
    iprot.readStructBegin()
10020 
    while True:
10021 
      (fname, ftype, fid) = iprot.readFieldBegin()
10022 
      if ftype == TType.STOP:
10023 
        break
10024 
      if fid == 0:
10025 
        if ftype == TType.STRUCT:
10026 
          self.success = Tracker()
10027 
          self.success.read(iprot)
10028 
        else:
10029 
          iprot.skip(ftype)
10030 
      elif fid == 1:
10031 
        if ftype == TType.STRUCT:
1996 vikas 10032 
          self.utx = UserAffiliateException()
1845 vikas 10033 
          self.utx.read(iprot)
10034 
        else:
10035 
          iprot.skip(ftype)
10036 
      else:
10037 
        iprot.skip(ftype)
10038 
      iprot.readFieldEnd()
10039 
    iprot.readStructEnd()
10040 
 
10041 
  def write(self, oprot):
10042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10044 
      return
10045 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 10046 
    if self.success is not None:
1845 vikas 10047 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10048 
      self.success.write(oprot)
10049 
      oprot.writeFieldEnd()
3431 rajveer 10050 
    if self.utx is not None:
1845 vikas 10051 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10052 
      self.utx.write(oprot)
10053 
      oprot.writeFieldEnd()
10054 
    oprot.writeFieldStop()
10055 
    oprot.writeStructEnd()
10056 
 
3431 rajveer 10057 
  def validate(self):
10058 
    return
10059 
 
10060 
 
1845 vikas 10061 
  def __repr__(self):
10062 
    L = ['%s=%r' % (key, value)
10063 
      for key, value in self.__dict__.iteritems()]
10064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10065 
 
10066 
  def __eq__(self, other):
10067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10068 
 
10069 
  def __ne__(self, other):
10070 
    return not (self == other)
10071 
 
1996 vikas 10072 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 10073 
  """
10074 
  Attributes:
1996 vikas 10075 
   - id
1845 vikas 10076 
  """
10077 
 
10078 
  thrift_spec = (
10079 
    None, # 0
1996 vikas 10080 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 10081 
  )
10082 
 
1996 vikas 10083 
  def __init__(self, id=None,):
10084 
    self.id = id
1845 vikas 10085 
 
10086 
  def read(self, iprot):
10087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10089 
      return
10090 
    iprot.readStructBegin()
10091 
    while True:
10092 
      (fname, ftype, fid) = iprot.readFieldBegin()
10093 
      if ftype == TType.STOP:
10094 
        break
10095 
      if fid == 1:
10096 
        if ftype == TType.I64:
1996 vikas 10097 
          self.id = iprot.readI64();
1845 vikas 10098 
        else:
10099 
          iprot.skip(ftype)
10100 
      else:
10101 
        iprot.skip(ftype)
10102 
      iprot.readFieldEnd()
10103 
    iprot.readStructEnd()
10104 
 
10105 
  def write(self, oprot):
10106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10108 
      return
1996 vikas 10109 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 10110 
    if self.id is not None:
1996 vikas 10111 
      oprot.writeFieldBegin('id', TType.I64, 1)
10112 
      oprot.writeI64(self.id)
1845 vikas 10113 
      oprot.writeFieldEnd()
10114 
    oprot.writeFieldStop()
10115 
    oprot.writeStructEnd()
10116 
 
3431 rajveer 10117 
  def validate(self):
10118 
    return
10119 
 
10120 
 
1845 vikas 10121 
  def __repr__(self):
10122 
    L = ['%s=%r' % (key, value)
10123 
      for key, value in self.__dict__.iteritems()]
10124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10125 
 
10126 
  def __eq__(self, other):
10127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10128 
 
10129 
  def __ne__(self, other):
10130 
    return not (self == other)
10131 
 
1996 vikas 10132 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 10133 
  """
10134 
  Attributes:
10135 
   - success
10136 
   - utx
10137 
  """
10138 
 
10139 
  thrift_spec = (
1996 vikas 10140 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
10141 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10142 
  )
10143 
 
10144 
  def __init__(self, success=None, utx=None,):
10145 
    self.success = success
10146 
    self.utx = utx
10147 
 
10148 
  def read(self, iprot):
10149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10151 
      return
10152 
    iprot.readStructBegin()
10153 
    while True:
10154 
      (fname, ftype, fid) = iprot.readFieldBegin()
10155 
      if ftype == TType.STOP:
10156 
        break
10157 
      if fid == 0:
10158 
        if ftype == TType.LIST:
10159 
          self.success = []
11592 amit.gupta 10160 
          (_etype128, _size125) = iprot.readListBegin()
10161 
          for _i129 in xrange(_size125):
10162 
            _elem130 = Affiliate()
10163 
            _elem130.read(iprot)
10164 
            self.success.append(_elem130)
1845 vikas 10165 
          iprot.readListEnd()
10166 
        else:
10167 
          iprot.skip(ftype)
10168 
      elif fid == 1:
10169 
        if ftype == TType.STRUCT:
1996 vikas 10170 
          self.utx = UserAffiliateException()
1845 vikas 10171 
          self.utx.read(iprot)
10172 
        else:
10173 
          iprot.skip(ftype)
10174 
      else:
10175 
        iprot.skip(ftype)
10176 
      iprot.readFieldEnd()
10177 
    iprot.readStructEnd()
10178 
 
10179 
  def write(self, oprot):
10180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10182 
      return
1996 vikas 10183 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 10184 
    if self.success is not None:
1845 vikas 10185 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10186 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10187 
      for iter131 in self.success:
10188 
        iter131.write(oprot)
1845 vikas 10189 
      oprot.writeListEnd()
10190 
      oprot.writeFieldEnd()
3431 rajveer 10191 
    if self.utx is not None:
1845 vikas 10192 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10193 
      self.utx.write(oprot)
10194 
      oprot.writeFieldEnd()
10195 
    oprot.writeFieldStop()
10196 
    oprot.writeStructEnd()
10197 
 
3431 rajveer 10198 
  def validate(self):
10199 
    return
10200 
 
10201 
 
1845 vikas 10202 
  def __repr__(self):
10203 
    L = ['%s=%r' % (key, value)
10204 
      for key, value in self.__dict__.iteritems()]
10205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10206 
 
10207 
  def __eq__(self, other):
10208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10209 
 
10210 
  def __ne__(self, other):
10211 
    return not (self == other)
10212 
 
10213 
class addTrackLog_args:
10214 
  """
10215 
  Attributes:
1996 vikas 10216 
   - affiliateId
1845 vikas 10217 
   - userId
10218 
   - event
10219 
   - url
10220 
   - data
1859 vikas 10221 
   - addedOn
1845 vikas 10222 
  """
10223 
 
10224 
  thrift_spec = (
10225 
    None, # 0
1996 vikas 10226 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 10227 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 10228 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 10229 
    (4, TType.STRING, 'url', None, None, ), # 4
10230 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 10231 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 10232 
  )
10233 
 
1996 vikas 10234 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
10235 
    self.affiliateId = affiliateId
1845 vikas 10236 
    self.userId = userId
10237 
    self.event = event
10238 
    self.url = url
10239 
    self.data = data
1859 vikas 10240 
    self.addedOn = addedOn
1845 vikas 10241 
 
10242 
  def read(self, iprot):
10243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10245 
      return
10246 
    iprot.readStructBegin()
10247 
    while True:
10248 
      (fname, ftype, fid) = iprot.readFieldBegin()
10249 
      if ftype == TType.STOP:
10250 
        break
10251 
      if fid == 1:
10252 
        if ftype == TType.I64:
1996 vikas 10253 
          self.affiliateId = iprot.readI64();
1845 vikas 10254 
        else:
10255 
          iprot.skip(ftype)
10256 
      elif fid == 2:
10257 
        if ftype == TType.I64:
10258 
          self.userId = iprot.readI64();
10259 
        else:
10260 
          iprot.skip(ftype)
10261 
      elif fid == 3:
3378 vikas 10262 
        if ftype == TType.I32:
10263 
          self.event = iprot.readI32();
1845 vikas 10264 
        else:
10265 
          iprot.skip(ftype)
10266 
      elif fid == 4:
10267 
        if ftype == TType.STRING:
10268 
          self.url = iprot.readString();
10269 
        else:
10270 
          iprot.skip(ftype)
10271 
      elif fid == 5:
10272 
        if ftype == TType.STRING:
10273 
          self.data = iprot.readString();
10274 
        else:
10275 
          iprot.skip(ftype)
1859 vikas 10276 
      elif fid == 6:
10277 
        if ftype == TType.I64:
10278 
          self.addedOn = iprot.readI64();
10279 
        else:
10280 
          iprot.skip(ftype)
1845 vikas 10281 
      else:
10282 
        iprot.skip(ftype)
10283 
      iprot.readFieldEnd()
10284 
    iprot.readStructEnd()
10285 
 
10286 
  def write(self, oprot):
10287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10289 
      return
10290 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10291 
    if self.affiliateId is not None:
1996 vikas 10292 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10293 
      oprot.writeI64(self.affiliateId)
1845 vikas 10294 
      oprot.writeFieldEnd()
3431 rajveer 10295 
    if self.userId is not None:
1845 vikas 10296 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10297 
      oprot.writeI64(self.userId)
10298 
      oprot.writeFieldEnd()
3431 rajveer 10299 
    if self.event is not None:
3378 vikas 10300 
      oprot.writeFieldBegin('event', TType.I32, 3)
10301 
      oprot.writeI32(self.event)
1845 vikas 10302 
      oprot.writeFieldEnd()
3431 rajveer 10303 
    if self.url is not None:
1845 vikas 10304 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10305 
      oprot.writeString(self.url)
10306 
      oprot.writeFieldEnd()
3431 rajveer 10307 
    if self.data is not None:
1845 vikas 10308 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10309 
      oprot.writeString(self.data)
10310 
      oprot.writeFieldEnd()
3431 rajveer 10311 
    if self.addedOn is not None:
1859 vikas 10312 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10313 
      oprot.writeI64(self.addedOn)
10314 
      oprot.writeFieldEnd()
1845 vikas 10315 
    oprot.writeFieldStop()
10316 
    oprot.writeStructEnd()
10317 
 
3431 rajveer 10318 
  def validate(self):
10319 
    return
10320 
 
10321 
 
1845 vikas 10322 
  def __repr__(self):
10323 
    L = ['%s=%r' % (key, value)
10324 
      for key, value in self.__dict__.iteritems()]
10325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10326 
 
10327 
  def __eq__(self, other):
10328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10329 
 
10330 
  def __ne__(self, other):
10331 
    return not (self == other)
10332 
 
10333 
class addTrackLog_result:
10334 
  """
10335 
  Attributes:
10336 
   - success
10337 
   - utx
10338 
  """
10339 
 
10340 
  thrift_spec = (
10341 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10342 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10343 
  )
10344 
 
10345 
  def __init__(self, success=None, utx=None,):
10346 
    self.success = success
10347 
    self.utx = utx
10348 
 
10349 
  def read(self, iprot):
10350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10352 
      return
10353 
    iprot.readStructBegin()
10354 
    while True:
10355 
      (fname, ftype, fid) = iprot.readFieldBegin()
10356 
      if ftype == TType.STOP:
10357 
        break
10358 
      if fid == 0:
10359 
        if ftype == TType.I64:
10360 
          self.success = iprot.readI64();
10361 
        else:
10362 
          iprot.skip(ftype)
10363 
      elif fid == 1:
10364 
        if ftype == TType.STRUCT:
1996 vikas 10365 
          self.utx = UserAffiliateException()
1845 vikas 10366 
          self.utx.read(iprot)
10367 
        else:
10368 
          iprot.skip(ftype)
10369 
      else:
10370 
        iprot.skip(ftype)
10371 
      iprot.readFieldEnd()
10372 
    iprot.readStructEnd()
10373 
 
10374 
  def write(self, oprot):
10375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10377 
      return
10378 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10379 
    if self.success is not None:
1845 vikas 10380 
      oprot.writeFieldBegin('success', TType.I64, 0)
10381 
      oprot.writeI64(self.success)
10382 
      oprot.writeFieldEnd()
3431 rajveer 10383 
    if self.utx is not None:
1845 vikas 10384 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10385 
      self.utx.write(oprot)
10386 
      oprot.writeFieldEnd()
10387 
    oprot.writeFieldStop()
10388 
    oprot.writeStructEnd()
10389 
 
3431 rajveer 10390 
  def validate(self):
10391 
    return
10392 
 
10393 
 
1845 vikas 10394 
  def __repr__(self):
10395 
    L = ['%s=%r' % (key, value)
10396 
      for key, value in self.__dict__.iteritems()]
10397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10398 
 
10399 
  def __eq__(self, other):
10400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10401 
 
10402 
  def __ne__(self, other):
10403 
    return not (self == other)
10404 
 
10405 
class getTrackLogById_args:
10406 
  """
10407 
  Attributes:
10408 
   - id
10409 
  """
10410 
 
10411 
  thrift_spec = (
10412 
    None, # 0
10413 
    (1, TType.I64, 'id', None, None, ), # 1
10414 
  )
10415 
 
10416 
  def __init__(self, id=None,):
10417 
    self.id = id
10418 
 
10419 
  def read(self, iprot):
10420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10422 
      return
10423 
    iprot.readStructBegin()
10424 
    while True:
10425 
      (fname, ftype, fid) = iprot.readFieldBegin()
10426 
      if ftype == TType.STOP:
10427 
        break
10428 
      if fid == 1:
10429 
        if ftype == TType.I64:
10430 
          self.id = iprot.readI64();
10431 
        else:
10432 
          iprot.skip(ftype)
10433 
      else:
10434 
        iprot.skip(ftype)
10435 
      iprot.readFieldEnd()
10436 
    iprot.readStructEnd()
10437 
 
10438 
  def write(self, oprot):
10439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10441 
      return
10442 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10443 
    if self.id is not None:
1845 vikas 10444 
      oprot.writeFieldBegin('id', TType.I64, 1)
10445 
      oprot.writeI64(self.id)
10446 
      oprot.writeFieldEnd()
10447 
    oprot.writeFieldStop()
10448 
    oprot.writeStructEnd()
10449 
 
3431 rajveer 10450 
  def validate(self):
10451 
    return
10452 
 
10453 
 
1845 vikas 10454 
  def __repr__(self):
10455 
    L = ['%s=%r' % (key, value)
10456 
      for key, value in self.__dict__.iteritems()]
10457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10458 
 
10459 
  def __eq__(self, other):
10460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10461 
 
10462 
  def __ne__(self, other):
10463 
    return not (self == other)
10464 
 
10465 
class getTrackLogById_result:
10466 
  """
10467 
  Attributes:
10468 
   - success
10469 
   - utx
10470 
  """
10471 
 
10472 
  thrift_spec = (
10473 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10474 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10475 
  )
10476 
 
10477 
  def __init__(self, success=None, utx=None,):
10478 
    self.success = success
10479 
    self.utx = utx
10480 
 
10481 
  def read(self, iprot):
10482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10484 
      return
10485 
    iprot.readStructBegin()
10486 
    while True:
10487 
      (fname, ftype, fid) = iprot.readFieldBegin()
10488 
      if ftype == TType.STOP:
10489 
        break
10490 
      if fid == 0:
10491 
        if ftype == TType.STRUCT:
10492 
          self.success = TrackLog()
10493 
          self.success.read(iprot)
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      elif fid == 1:
10497 
        if ftype == TType.STRUCT:
1996 vikas 10498 
          self.utx = UserAffiliateException()
1845 vikas 10499 
          self.utx.read(iprot)
10500 
        else:
10501 
          iprot.skip(ftype)
10502 
      else:
10503 
        iprot.skip(ftype)
10504 
      iprot.readFieldEnd()
10505 
    iprot.readStructEnd()
10506 
 
10507 
  def write(self, oprot):
10508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10510 
      return
10511 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10512 
    if self.success is not None:
1845 vikas 10513 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10514 
      self.success.write(oprot)
10515 
      oprot.writeFieldEnd()
3431 rajveer 10516 
    if self.utx is not None:
1845 vikas 10517 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10518 
      self.utx.write(oprot)
10519 
      oprot.writeFieldEnd()
10520 
    oprot.writeFieldStop()
10521 
    oprot.writeStructEnd()
10522 
 
3431 rajveer 10523 
  def validate(self):
10524 
    return
10525 
 
10526 
 
1845 vikas 10527 
  def __repr__(self):
10528 
    L = ['%s=%r' % (key, value)
10529 
      for key, value in self.__dict__.iteritems()]
10530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10531 
 
10532 
  def __eq__(self, other):
10533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10534 
 
10535 
  def __ne__(self, other):
10536 
    return not (self == other)
10537 
 
1996 vikas 10538 
class getTrackLogsByAffiliate_args:
1845 vikas 10539 
  """
10540 
  Attributes:
1996 vikas 10541 
   - affiliateId
3293 vikas 10542 
   - startDate
10543 
   - endDate
1845 vikas 10544 
  """
10545 
 
10546 
  thrift_spec = (
10547 
    None, # 0
1996 vikas 10548 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10549 
    (2, TType.I64, 'startDate', None, None, ), # 2
10550 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10551 
  )
10552 
 
3293 vikas 10553 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10554 
    self.affiliateId = affiliateId
3293 vikas 10555 
    self.startDate = startDate
10556 
    self.endDate = endDate
1845 vikas 10557 
 
10558 
  def read(self, iprot):
10559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10561 
      return
10562 
    iprot.readStructBegin()
10563 
    while True:
10564 
      (fname, ftype, fid) = iprot.readFieldBegin()
10565 
      if ftype == TType.STOP:
10566 
        break
10567 
      if fid == 1:
10568 
        if ftype == TType.I64:
1996 vikas 10569 
          self.affiliateId = iprot.readI64();
1845 vikas 10570 
        else:
10571 
          iprot.skip(ftype)
3293 vikas 10572 
      elif fid == 2:
10573 
        if ftype == TType.I64:
10574 
          self.startDate = iprot.readI64();
10575 
        else:
10576 
          iprot.skip(ftype)
10577 
      elif fid == 3:
10578 
        if ftype == TType.I64:
10579 
          self.endDate = iprot.readI64();
10580 
        else:
10581 
          iprot.skip(ftype)
1845 vikas 10582 
      else:
10583 
        iprot.skip(ftype)
10584 
      iprot.readFieldEnd()
10585 
    iprot.readStructEnd()
10586 
 
10587 
  def write(self, oprot):
10588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10590 
      return
1996 vikas 10591 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10592 
    if self.affiliateId is not None:
1996 vikas 10593 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10594 
      oprot.writeI64(self.affiliateId)
1845 vikas 10595 
      oprot.writeFieldEnd()
3431 rajveer 10596 
    if self.startDate is not None:
3293 vikas 10597 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10598 
      oprot.writeI64(self.startDate)
10599 
      oprot.writeFieldEnd()
3431 rajveer 10600 
    if self.endDate is not None:
3293 vikas 10601 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10602 
      oprot.writeI64(self.endDate)
10603 
      oprot.writeFieldEnd()
1845 vikas 10604 
    oprot.writeFieldStop()
10605 
    oprot.writeStructEnd()
10606 
 
3431 rajveer 10607 
  def validate(self):
10608 
    return
10609 
 
10610 
 
1845 vikas 10611 
  def __repr__(self):
10612 
    L = ['%s=%r' % (key, value)
10613 
      for key, value in self.__dict__.iteritems()]
10614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10615 
 
10616 
  def __eq__(self, other):
10617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10618 
 
10619 
  def __ne__(self, other):
10620 
    return not (self == other)
10621 
 
1996 vikas 10622 
class getTrackLogsByAffiliate_result:
1845 vikas 10623 
  """
10624 
  Attributes:
10625 
   - success
10626 
   - utx
10627 
  """
10628 
 
10629 
  thrift_spec = (
10630 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10631 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10632 
  )
10633 
 
10634 
  def __init__(self, success=None, utx=None,):
10635 
    self.success = success
10636 
    self.utx = utx
10637 
 
10638 
  def read(self, iprot):
10639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10641 
      return
10642 
    iprot.readStructBegin()
10643 
    while True:
10644 
      (fname, ftype, fid) = iprot.readFieldBegin()
10645 
      if ftype == TType.STOP:
10646 
        break
10647 
      if fid == 0:
10648 
        if ftype == TType.LIST:
10649 
          self.success = []
11592 amit.gupta 10650 
          (_etype135, _size132) = iprot.readListBegin()
10651 
          for _i136 in xrange(_size132):
10652 
            _elem137 = TrackLog()
10653 
            _elem137.read(iprot)
10654 
            self.success.append(_elem137)
1845 vikas 10655 
          iprot.readListEnd()
10656 
        else:
10657 
          iprot.skip(ftype)
10658 
      elif fid == 1:
10659 
        if ftype == TType.STRUCT:
1996 vikas 10660 
          self.utx = UserAffiliateException()
1845 vikas 10661 
          self.utx.read(iprot)
10662 
        else:
10663 
          iprot.skip(ftype)
10664 
      else:
10665 
        iprot.skip(ftype)
10666 
      iprot.readFieldEnd()
10667 
    iprot.readStructEnd()
10668 
 
10669 
  def write(self, oprot):
10670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10672 
      return
1996 vikas 10673 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10674 
    if self.success is not None:
1845 vikas 10675 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10676 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10677 
      for iter138 in self.success:
10678 
        iter138.write(oprot)
1845 vikas 10679 
      oprot.writeListEnd()
10680 
      oprot.writeFieldEnd()
3431 rajveer 10681 
    if self.utx is not None:
1845 vikas 10682 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10683 
      self.utx.write(oprot)
10684 
      oprot.writeFieldEnd()
10685 
    oprot.writeFieldStop()
10686 
    oprot.writeStructEnd()
10687 
 
3431 rajveer 10688 
  def validate(self):
10689 
    return
10690 
 
10691 
 
1845 vikas 10692 
  def __repr__(self):
10693 
    L = ['%s=%r' % (key, value)
10694 
      for key, value in self.__dict__.iteritems()]
10695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10696 
 
10697 
  def __eq__(self, other):
10698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10699 
 
10700 
  def __ne__(self, other):
10701 
    return not (self == other)
10702 
 
10703 
class getTrackLogsByUser_args:
10704 
  """
10705 
  Attributes:
10706 
   - userId
10707 
  """
10708 
 
10709 
  thrift_spec = (
10710 
    None, # 0
10711 
    (1, TType.I64, 'userId', None, None, ), # 1
10712 
  )
10713 
 
10714 
  def __init__(self, userId=None,):
10715 
    self.userId = userId
10716 
 
10717 
  def read(self, iprot):
10718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10720 
      return
10721 
    iprot.readStructBegin()
10722 
    while True:
10723 
      (fname, ftype, fid) = iprot.readFieldBegin()
10724 
      if ftype == TType.STOP:
10725 
        break
10726 
      if fid == 1:
10727 
        if ftype == TType.I64:
10728 
          self.userId = iprot.readI64();
10729 
        else:
10730 
          iprot.skip(ftype)
10731 
      else:
10732 
        iprot.skip(ftype)
10733 
      iprot.readFieldEnd()
10734 
    iprot.readStructEnd()
10735 
 
10736 
  def write(self, oprot):
10737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10739 
      return
10740 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10741 
    if self.userId is not None:
1845 vikas 10742 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10743 
      oprot.writeI64(self.userId)
10744 
      oprot.writeFieldEnd()
10745 
    oprot.writeFieldStop()
10746 
    oprot.writeStructEnd()
10747 
 
3431 rajveer 10748 
  def validate(self):
10749 
    return
10750 
 
10751 
 
1845 vikas 10752 
  def __repr__(self):
10753 
    L = ['%s=%r' % (key, value)
10754 
      for key, value in self.__dict__.iteritems()]
10755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10756 
 
10757 
  def __eq__(self, other):
10758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10759 
 
10760 
  def __ne__(self, other):
10761 
    return not (self == other)
10762 
 
10763 
class getTrackLogsByUser_result:
10764 
  """
10765 
  Attributes:
10766 
   - success
10767 
   - utx
10768 
  """
10769 
 
10770 
  thrift_spec = (
10771 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10772 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10773 
  )
10774 
 
10775 
  def __init__(self, success=None, utx=None,):
10776 
    self.success = success
10777 
    self.utx = utx
10778 
 
10779 
  def read(self, iprot):
10780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10782 
      return
10783 
    iprot.readStructBegin()
10784 
    while True:
10785 
      (fname, ftype, fid) = iprot.readFieldBegin()
10786 
      if ftype == TType.STOP:
10787 
        break
10788 
      if fid == 0:
10789 
        if ftype == TType.LIST:
10790 
          self.success = []
11592 amit.gupta 10791 
          (_etype142, _size139) = iprot.readListBegin()
10792 
          for _i143 in xrange(_size139):
10793 
            _elem144 = TrackLog()
10794 
            _elem144.read(iprot)
10795 
            self.success.append(_elem144)
1845 vikas 10796 
          iprot.readListEnd()
10797 
        else:
10798 
          iprot.skip(ftype)
10799 
      elif fid == 1:
10800 
        if ftype == TType.STRUCT:
1996 vikas 10801 
          self.utx = UserAffiliateException()
1845 vikas 10802 
          self.utx.read(iprot)
10803 
        else:
10804 
          iprot.skip(ftype)
10805 
      else:
10806 
        iprot.skip(ftype)
10807 
      iprot.readFieldEnd()
10808 
    iprot.readStructEnd()
10809 
 
10810 
  def write(self, oprot):
10811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10813 
      return
10814 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10815 
    if self.success is not None:
1845 vikas 10816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10818 
      for iter145 in self.success:
10819 
        iter145.write(oprot)
1845 vikas 10820 
      oprot.writeListEnd()
10821 
      oprot.writeFieldEnd()
3431 rajveer 10822 
    if self.utx is not None:
1845 vikas 10823 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10824 
      self.utx.write(oprot)
10825 
      oprot.writeFieldEnd()
10826 
    oprot.writeFieldStop()
10827 
    oprot.writeStructEnd()
10828 
 
3431 rajveer 10829 
  def validate(self):
10830 
    return
10831 
 
10832 
 
1845 vikas 10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
10844 
class getTrackLogs_args:
10845 
  """
10846 
  Attributes:
10847 
   - userId
10848 
   - event
10849 
   - url
10850 
  """
10851 
 
10852 
  thrift_spec = (
10853 
    None, # 0
1996 vikas 10854 
    (1, TType.I64, 'userId', None, None, ), # 1
10855 
    (2, TType.STRING, 'event', None, None, ), # 2
10856 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10857 
  )
10858 
 
1996 vikas 10859 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10860 
    self.userId = userId
10861 
    self.event = event
10862 
    self.url = url
10863 
 
10864 
  def read(self, iprot):
10865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10867 
      return
10868 
    iprot.readStructBegin()
10869 
    while True:
10870 
      (fname, ftype, fid) = iprot.readFieldBegin()
10871 
      if ftype == TType.STOP:
10872 
        break
10873 
      if fid == 1:
10874 
        if ftype == TType.I64:
1996 vikas 10875 
          self.userId = iprot.readI64();
1845 vikas 10876 
        else:
10877 
          iprot.skip(ftype)
10878 
      elif fid == 2:
10879 
        if ftype == TType.STRING:
10880 
          self.event = iprot.readString();
10881 
        else:
10882 
          iprot.skip(ftype)
1996 vikas 10883 
      elif fid == 3:
1845 vikas 10884 
        if ftype == TType.STRING:
10885 
          self.url = iprot.readString();
10886 
        else:
10887 
          iprot.skip(ftype)
10888 
      else:
10889 
        iprot.skip(ftype)
10890 
      iprot.readFieldEnd()
10891 
    iprot.readStructEnd()
10892 
 
10893 
  def write(self, oprot):
10894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10896 
      return
10897 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10898 
    if self.userId is not None:
1996 vikas 10899 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10900 
      oprot.writeI64(self.userId)
10901 
      oprot.writeFieldEnd()
3431 rajveer 10902 
    if self.event is not None:
1996 vikas 10903 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10904 
      oprot.writeString(self.event)
10905 
      oprot.writeFieldEnd()
3431 rajveer 10906 
    if self.url is not None:
1996 vikas 10907 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10908 
      oprot.writeString(self.url)
10909 
      oprot.writeFieldEnd()
10910 
    oprot.writeFieldStop()
10911 
    oprot.writeStructEnd()
10912 
 
3431 rajveer 10913 
  def validate(self):
10914 
    return
10915 
 
10916 
 
1845 vikas 10917 
  def __repr__(self):
10918 
    L = ['%s=%r' % (key, value)
10919 
      for key, value in self.__dict__.iteritems()]
10920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10921 
 
10922 
  def __eq__(self, other):
10923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10924 
 
10925 
  def __ne__(self, other):
10926 
    return not (self == other)
10927 
 
10928 
class getTrackLogs_result:
10929 
  """
10930 
  Attributes:
10931 
   - success
10932 
   - utx
10933 
  """
10934 
 
10935 
  thrift_spec = (
10936 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10937 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10938 
  )
10939 
 
10940 
  def __init__(self, success=None, utx=None,):
10941 
    self.success = success
10942 
    self.utx = utx
10943 
 
10944 
  def read(self, iprot):
10945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10947 
      return
10948 
    iprot.readStructBegin()
10949 
    while True:
10950 
      (fname, ftype, fid) = iprot.readFieldBegin()
10951 
      if ftype == TType.STOP:
10952 
        break
10953 
      if fid == 0:
10954 
        if ftype == TType.LIST:
10955 
          self.success = []
11592 amit.gupta 10956 
          (_etype149, _size146) = iprot.readListBegin()
10957 
          for _i150 in xrange(_size146):
10958 
            _elem151 = TrackLog()
10959 
            _elem151.read(iprot)
10960 
            self.success.append(_elem151)
1845 vikas 10961 
          iprot.readListEnd()
10962 
        else:
10963 
          iprot.skip(ftype)
10964 
      elif fid == 1:
10965 
        if ftype == TType.STRUCT:
1996 vikas 10966 
          self.utx = UserAffiliateException()
1845 vikas 10967 
          self.utx.read(iprot)
10968 
        else:
10969 
          iprot.skip(ftype)
10970 
      else:
10971 
        iprot.skip(ftype)
10972 
      iprot.readFieldEnd()
10973 
    iprot.readStructEnd()
10974 
 
10975 
  def write(self, oprot):
10976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10978 
      return
10979 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10980 
    if self.success is not None:
1845 vikas 10981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10983 
      for iter152 in self.success:
10984 
        iter152.write(oprot)
1845 vikas 10985 
      oprot.writeListEnd()
10986 
      oprot.writeFieldEnd()
3431 rajveer 10987 
    if self.utx is not None:
1845 vikas 10988 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10989 
      self.utx.write(oprot)
10990 
      oprot.writeFieldEnd()
10991 
    oprot.writeFieldStop()
10992 
    oprot.writeStructEnd()
10993 
 
3431 rajveer 10994 
  def validate(self):
10995 
    return
10996 
 
10997 
 
1845 vikas 10998 
  def __repr__(self):
10999 
    L = ['%s=%r' % (key, value)
11000 
      for key, value in self.__dict__.iteritems()]
11001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11002 
 
11003 
  def __eq__(self, other):
11004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11005 
 
11006 
  def __ne__(self, other):
11007 
    return not (self == other)
11008 
 
559 chandransh 11009 
class getCurrentCart_args:
94 ashish 11010 
  """
11011 
  Attributes:
559 chandransh 11012 
   - userId
11013 
  """
11014 
 
11015 
  thrift_spec = (
11016 
    None, # 0
11017 
    (1, TType.I64, 'userId', None, None, ), # 1
11018 
  )
11019 
 
11020 
  def __init__(self, userId=None,):
11021 
    self.userId = userId
11022 
 
11023 
  def read(self, iprot):
11024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11026 
      return
11027 
    iprot.readStructBegin()
11028 
    while True:
11029 
      (fname, ftype, fid) = iprot.readFieldBegin()
11030 
      if ftype == TType.STOP:
11031 
        break
11032 
      if fid == 1:
11033 
        if ftype == TType.I64:
11034 
          self.userId = iprot.readI64();
11035 
        else:
11036 
          iprot.skip(ftype)
11037 
      else:
11038 
        iprot.skip(ftype)
11039 
      iprot.readFieldEnd()
11040 
    iprot.readStructEnd()
11041 
 
11042 
  def write(self, oprot):
11043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11045 
      return
11046 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 11047 
    if self.userId is not None:
559 chandransh 11048 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11049 
      oprot.writeI64(self.userId)
11050 
      oprot.writeFieldEnd()
11051 
    oprot.writeFieldStop()
11052 
    oprot.writeStructEnd()
11053 
 
3431 rajveer 11054 
  def validate(self):
11055 
    return
11056 
 
11057 
 
559 chandransh 11058 
  def __repr__(self):
11059 
    L = ['%s=%r' % (key, value)
11060 
      for key, value in self.__dict__.iteritems()]
11061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11062 
 
11063 
  def __eq__(self, other):
11064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11065 
 
11066 
  def __ne__(self, other):
11067 
    return not (self == other)
11068 
 
11069 
class getCurrentCart_result:
11070 
  """
11071 
  Attributes:
94 ashish 11072 
   - success
559 chandransh 11073 
   - scx
94 ashish 11074 
  """
11075 
 
11076 
  thrift_spec = (
559 chandransh 11077 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11078 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11079 
  )
11080 
 
559 chandransh 11081 
  def __init__(self, success=None, scx=None,):
94 ashish 11082 
    self.success = success
559 chandransh 11083 
    self.scx = scx
94 ashish 11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      if fid == 0:
559 chandransh 11095 
        if ftype == TType.STRUCT:
11096 
          self.success = Cart()
11097 
          self.success.read(iprot)
94 ashish 11098 
        else:
11099 
          iprot.skip(ftype)
11100 
      elif fid == 1:
11101 
        if ftype == TType.STRUCT:
559 chandransh 11102 
          self.scx = ShoppingCartException()
11103 
          self.scx.read(iprot)
94 ashish 11104 
        else:
11105 
          iprot.skip(ftype)
11106 
      else:
11107 
        iprot.skip(ftype)
11108 
      iprot.readFieldEnd()
11109 
    iprot.readStructEnd()
11110 
 
11111 
  def write(self, oprot):
11112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11114 
      return
559 chandransh 11115 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 11116 
    if self.success is not None:
559 chandransh 11117 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11118 
      self.success.write(oprot)
94 ashish 11119 
      oprot.writeFieldEnd()
3431 rajveer 11120 
    if self.scx is not None:
559 chandransh 11121 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11122 
      self.scx.write(oprot)
94 ashish 11123 
      oprot.writeFieldEnd()
11124 
    oprot.writeFieldStop()
11125 
    oprot.writeStructEnd()
11126 
 
3431 rajveer 11127 
  def validate(self):
11128 
    return
11129 
 
11130 
 
94 ashish 11131 
  def __repr__(self):
11132 
    L = ['%s=%r' % (key, value)
11133 
      for key, value in self.__dict__.iteritems()]
11134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11135 
 
11136 
  def __eq__(self, other):
11137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11138 
 
11139 
  def __ne__(self, other):
11140 
    return not (self == other)
11141 
 
559 chandransh 11142 
class getCart_args:
504 rajveer 11143 
  """
11144 
  Attributes:
559 chandransh 11145 
   - cartId
504 rajveer 11146 
  """
11147 
 
11148 
  thrift_spec = (
11149 
    None, # 0
559 chandransh 11150 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 11151 
  )
11152 
 
559 chandransh 11153 
  def __init__(self, cartId=None,):
11154 
    self.cartId = cartId
504 rajveer 11155 
 
11156 
  def read(self, iprot):
11157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11159 
      return
11160 
    iprot.readStructBegin()
11161 
    while True:
11162 
      (fname, ftype, fid) = iprot.readFieldBegin()
11163 
      if ftype == TType.STOP:
11164 
        break
11165 
      if fid == 1:
11166 
        if ftype == TType.I64:
559 chandransh 11167 
          self.cartId = iprot.readI64();
504 rajveer 11168 
        else:
11169 
          iprot.skip(ftype)
11170 
      else:
11171 
        iprot.skip(ftype)
11172 
      iprot.readFieldEnd()
11173 
    iprot.readStructEnd()
11174 
 
11175 
  def write(self, oprot):
11176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11178 
      return
559 chandransh 11179 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 11180 
    if self.cartId is not None:
559 chandransh 11181 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11182 
      oprot.writeI64(self.cartId)
504 rajveer 11183 
      oprot.writeFieldEnd()
11184 
    oprot.writeFieldStop()
11185 
    oprot.writeStructEnd()
11186 
 
3431 rajveer 11187 
  def validate(self):
11188 
    return
11189 
 
11190 
 
504 rajveer 11191 
  def __repr__(self):
11192 
    L = ['%s=%r' % (key, value)
11193 
      for key, value in self.__dict__.iteritems()]
11194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11195 
 
11196 
  def __eq__(self, other):
11197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11198 
 
11199 
  def __ne__(self, other):
11200 
    return not (self == other)
11201 
 
559 chandransh 11202 
class getCart_result:
504 rajveer 11203 
  """
11204 
  Attributes:
11205 
   - success
559 chandransh 11206 
   - scx
504 rajveer 11207 
  """
11208 
 
11209 
  thrift_spec = (
559 chandransh 11210 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11211 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 11212 
  )
11213 
 
559 chandransh 11214 
  def __init__(self, success=None, scx=None,):
504 rajveer 11215 
    self.success = success
559 chandransh 11216 
    self.scx = scx
504 rajveer 11217 
 
11218 
  def read(self, iprot):
11219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11221 
      return
11222 
    iprot.readStructBegin()
11223 
    while True:
11224 
      (fname, ftype, fid) = iprot.readFieldBegin()
11225 
      if ftype == TType.STOP:
11226 
        break
11227 
      if fid == 0:
559 chandransh 11228 
        if ftype == TType.STRUCT:
11229 
          self.success = Cart()
11230 
          self.success.read(iprot)
504 rajveer 11231 
        else:
11232 
          iprot.skip(ftype)
11233 
      elif fid == 1:
11234 
        if ftype == TType.STRUCT:
559 chandransh 11235 
          self.scx = ShoppingCartException()
11236 
          self.scx.read(iprot)
504 rajveer 11237 
        else:
11238 
          iprot.skip(ftype)
11239 
      else:
11240 
        iprot.skip(ftype)
11241 
      iprot.readFieldEnd()
11242 
    iprot.readStructEnd()
11243 
 
11244 
  def write(self, oprot):
11245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11247 
      return
559 chandransh 11248 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 11249 
    if self.success is not None:
559 chandransh 11250 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11251 
      self.success.write(oprot)
504 rajveer 11252 
      oprot.writeFieldEnd()
3431 rajveer 11253 
    if self.scx is not None:
559 chandransh 11254 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11255 
      self.scx.write(oprot)
504 rajveer 11256 
      oprot.writeFieldEnd()
11257 
    oprot.writeFieldStop()
11258 
    oprot.writeStructEnd()
11259 
 
3431 rajveer 11260 
  def validate(self):
11261 
    return
11262 
 
11263 
 
504 rajveer 11264 
  def __repr__(self):
11265 
    L = ['%s=%r' % (key, value)
11266 
      for key, value in self.__dict__.iteritems()]
11267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11268 
 
11269 
  def __eq__(self, other):
11270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11271 
 
11272 
  def __ne__(self, other):
11273 
    return not (self == other)
11274 
 
559 chandransh 11275 
class getCartsByTime_args:
11276 
  """
11277 
  Attributes:
11278 
   - from_time
11279 
   - to_time
11280 
   - status
11281 
  """
11282 
 
11283 
  thrift_spec = (
11284 
    None, # 0
11285 
    (1, TType.I64, 'from_time', None, None, ), # 1
11286 
    (2, TType.I64, 'to_time', None, None, ), # 2
11287 
    (3, TType.I32, 'status', None, None, ), # 3
11288 
  )
11289 
 
11290 
  def __init__(self, from_time=None, to_time=None, status=None,):
11291 
    self.from_time = from_time
11292 
    self.to_time = to_time
11293 
    self.status = status
11294 
 
11295 
  def read(self, iprot):
11296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11298 
      return
11299 
    iprot.readStructBegin()
11300 
    while True:
11301 
      (fname, ftype, fid) = iprot.readFieldBegin()
11302 
      if ftype == TType.STOP:
11303 
        break
11304 
      if fid == 1:
94 ashish 11305 
        if ftype == TType.I64:
559 chandransh 11306 
          self.from_time = iprot.readI64();
94 ashish 11307 
        else:
11308 
          iprot.skip(ftype)
122 ashish 11309 
      elif fid == 2:
559 chandransh 11310 
        if ftype == TType.I64:
11311 
          self.to_time = iprot.readI64();
122 ashish 11312 
        else:
11313 
          iprot.skip(ftype)
559 chandransh 11314 
      elif fid == 3:
11315 
        if ftype == TType.I32:
11316 
          self.status = iprot.readI32();
11317 
        else:
11318 
          iprot.skip(ftype)
94 ashish 11319 
      else:
11320 
        iprot.skip(ftype)
11321 
      iprot.readFieldEnd()
11322 
    iprot.readStructEnd()
11323 
 
11324 
  def write(self, oprot):
11325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11327 
      return
559 chandransh 11328 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11329 
    if self.from_time is not None:
559 chandransh 11330 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11331 
      oprot.writeI64(self.from_time)
94 ashish 11332 
      oprot.writeFieldEnd()
3431 rajveer 11333 
    if self.to_time is not None:
559 chandransh 11334 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11335 
      oprot.writeI64(self.to_time)
122 ashish 11336 
      oprot.writeFieldEnd()
3431 rajveer 11337 
    if self.status is not None:
559 chandransh 11338 
      oprot.writeFieldBegin('status', TType.I32, 3)
11339 
      oprot.writeI32(self.status)
11340 
      oprot.writeFieldEnd()
94 ashish 11341 
    oprot.writeFieldStop()
11342 
    oprot.writeStructEnd()
11343 
 
3431 rajveer 11344 
  def validate(self):
11345 
    return
11346 
 
11347 
 
94 ashish 11348 
  def __repr__(self):
11349 
    L = ['%s=%r' % (key, value)
11350 
      for key, value in self.__dict__.iteritems()]
11351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11352 
 
11353 
  def __eq__(self, other):
11354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11355 
 
11356 
  def __ne__(self, other):
11357 
    return not (self == other)
11358 
 
559 chandransh 11359 
class getCartsByTime_result:
94 ashish 11360 
  """
11361 
  Attributes:
11362 
   - success
559 chandransh 11363 
   - scx
94 ashish 11364 
  """
11365 
 
11366 
  thrift_spec = (
559 chandransh 11367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11368 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11369 
  )
11370 
 
559 chandransh 11371 
  def __init__(self, success=None, scx=None,):
94 ashish 11372 
    self.success = success
559 chandransh 11373 
    self.scx = scx
94 ashish 11374 
 
11375 
  def read(self, iprot):
11376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11378 
      return
11379 
    iprot.readStructBegin()
11380 
    while True:
11381 
      (fname, ftype, fid) = iprot.readFieldBegin()
11382 
      if ftype == TType.STOP:
11383 
        break
11384 
      if fid == 0:
559 chandransh 11385 
        if ftype == TType.LIST:
11386 
          self.success = []
11592 amit.gupta 11387 
          (_etype156, _size153) = iprot.readListBegin()
11388 
          for _i157 in xrange(_size153):
11389 
            _elem158 = Cart()
11390 
            _elem158.read(iprot)
11391 
            self.success.append(_elem158)
559 chandransh 11392 
          iprot.readListEnd()
94 ashish 11393 
        else:
11394 
          iprot.skip(ftype)
11395 
      elif fid == 1:
11396 
        if ftype == TType.STRUCT:
559 chandransh 11397 
          self.scx = ShoppingCartException()
11398 
          self.scx.read(iprot)
94 ashish 11399 
        else:
11400 
          iprot.skip(ftype)
11401 
      else:
11402 
        iprot.skip(ftype)
11403 
      iprot.readFieldEnd()
11404 
    iprot.readStructEnd()
11405 
 
11406 
  def write(self, oprot):
11407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11409 
      return
559 chandransh 11410 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11411 
    if self.success is not None:
559 chandransh 11412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11414 
      for iter159 in self.success:
11415 
        iter159.write(oprot)
559 chandransh 11416 
      oprot.writeListEnd()
94 ashish 11417 
      oprot.writeFieldEnd()
3431 rajveer 11418 
    if self.scx is not None:
559 chandransh 11419 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11420 
      self.scx.write(oprot)
94 ashish 11421 
      oprot.writeFieldEnd()
11422 
    oprot.writeFieldStop()
11423 
    oprot.writeStructEnd()
11424 
 
3431 rajveer 11425 
  def validate(self):
11426 
    return
11427 
 
11428 
 
94 ashish 11429 
  def __repr__(self):
11430 
    L = ['%s=%r' % (key, value)
11431 
      for key, value in self.__dict__.iteritems()]
11432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11433 
 
11434 
  def __eq__(self, other):
11435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11436 
 
11437 
  def __ne__(self, other):
11438 
    return not (self == other)
11439 
 
559 chandransh 11440 
class addItemToCart_args:
11441 
  """
11442 
  Attributes:
11443 
   - cartId
11444 
   - itemId
11445 
   - quantity
3557 rajveer 11446 
   - sourceId
559 chandransh 11447 
  """
11448 
 
11449 
  thrift_spec = (
11450 
    None, # 0
11451 
    (1, TType.I64, 'cartId', None, None, ), # 1
11452 
    (2, TType.I64, 'itemId', None, None, ), # 2
11453 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11454 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11455 
  )
11456 
 
3557 rajveer 11457 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11458 
    self.cartId = cartId
11459 
    self.itemId = itemId
11460 
    self.quantity = quantity
3557 rajveer 11461 
    self.sourceId = sourceId
559 chandransh 11462 
 
11463 
  def read(self, iprot):
11464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11466 
      return
11467 
    iprot.readStructBegin()
11468 
    while True:
11469 
      (fname, ftype, fid) = iprot.readFieldBegin()
11470 
      if ftype == TType.STOP:
11471 
        break
11472 
      if fid == 1:
11473 
        if ftype == TType.I64:
11474 
          self.cartId = iprot.readI64();
11475 
        else:
11476 
          iprot.skip(ftype)
11477 
      elif fid == 2:
11478 
        if ftype == TType.I64:
11479 
          self.itemId = iprot.readI64();
11480 
        else:
11481 
          iprot.skip(ftype)
11482 
      elif fid == 3:
11483 
        if ftype == TType.I64:
11484 
          self.quantity = iprot.readI64();
11485 
        else:
11486 
          iprot.skip(ftype)
3557 rajveer 11487 
      elif fid == 4:
11488 
        if ftype == TType.I64:
11489 
          self.sourceId = iprot.readI64();
11490 
        else:
11491 
          iprot.skip(ftype)
559 chandransh 11492 
      else:
11493 
        iprot.skip(ftype)
11494 
      iprot.readFieldEnd()
11495 
    iprot.readStructEnd()
11496 
 
11497 
  def write(self, oprot):
11498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11500 
      return
11501 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11502 
    if self.cartId is not None:
559 chandransh 11503 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11504 
      oprot.writeI64(self.cartId)
11505 
      oprot.writeFieldEnd()
3431 rajveer 11506 
    if self.itemId is not None:
559 chandransh 11507 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11508 
      oprot.writeI64(self.itemId)
11509 
      oprot.writeFieldEnd()
3431 rajveer 11510 
    if self.quantity is not None:
559 chandransh 11511 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11512 
      oprot.writeI64(self.quantity)
11513 
      oprot.writeFieldEnd()
3557 rajveer 11514 
    if self.sourceId is not None:
11515 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11516 
      oprot.writeI64(self.sourceId)
11517 
      oprot.writeFieldEnd()
559 chandransh 11518 
    oprot.writeFieldStop()
11519 
    oprot.writeStructEnd()
11520 
 
3431 rajveer 11521 
  def validate(self):
11522 
    return
11523 
 
11524 
 
559 chandransh 11525 
  def __repr__(self):
11526 
    L = ['%s=%r' % (key, value)
11527 
      for key, value in self.__dict__.iteritems()]
11528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11529 
 
11530 
  def __eq__(self, other):
11531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11532 
 
11533 
  def __ne__(self, other):
11534 
    return not (self == other)
11535 
 
11536 
class addItemToCart_result:
11537 
  """
11538 
  Attributes:
2035 rajveer 11539 
   - success
559 chandransh 11540 
   - scx
11541 
  """
11542 
 
11543 
  thrift_spec = (
2035 rajveer 11544 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11545 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11546 
  )
11547 
 
2035 rajveer 11548 
  def __init__(self, success=None, scx=None,):
11549 
    self.success = success
559 chandransh 11550 
    self.scx = scx
11551 
 
11552 
  def read(self, iprot):
11553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11555 
      return
11556 
    iprot.readStructBegin()
11557 
    while True:
11558 
      (fname, ftype, fid) = iprot.readFieldBegin()
11559 
      if ftype == TType.STOP:
11560 
        break
2035 rajveer 11561 
      if fid == 0:
11562 
        if ftype == TType.STRING:
11563 
          self.success = iprot.readString();
11564 
        else:
11565 
          iprot.skip(ftype)
11566 
      elif fid == 1:
559 chandransh 11567 
        if ftype == TType.STRUCT:
11568 
          self.scx = ShoppingCartException()
11569 
          self.scx.read(iprot)
11570 
        else:
11571 
          iprot.skip(ftype)
11572 
      else:
11573 
        iprot.skip(ftype)
11574 
      iprot.readFieldEnd()
11575 
    iprot.readStructEnd()
11576 
 
11577 
  def write(self, oprot):
11578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11580 
      return
11581 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11582 
    if self.success is not None:
2035 rajveer 11583 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11584 
      oprot.writeString(self.success)
11585 
      oprot.writeFieldEnd()
3431 rajveer 11586 
    if self.scx is not None:
559 chandransh 11587 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11588 
      self.scx.write(oprot)
11589 
      oprot.writeFieldEnd()
11590 
    oprot.writeFieldStop()
11591 
    oprot.writeStructEnd()
11592 
 
3431 rajveer 11593 
  def validate(self):
11594 
    return
11595 
 
11596 
 
559 chandransh 11597 
  def __repr__(self):
11598 
    L = ['%s=%r' % (key, value)
11599 
      for key, value in self.__dict__.iteritems()]
11600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11601 
 
11602 
  def __eq__(self, other):
11603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11604 
 
11605 
  def __ne__(self, other):
11606 
    return not (self == other)
11607 
 
11608 
class deleteItemFromCart_args:
11609 
  """
11610 
  Attributes:
11611 
   - cartId
11612 
   - itemId
11613 
  """
11614 
 
11615 
  thrift_spec = (
11616 
    None, # 0
11617 
    (1, TType.I64, 'cartId', None, None, ), # 1
11618 
    (2, TType.I64, 'itemId', None, None, ), # 2
11619 
  )
11620 
 
11621 
  def __init__(self, cartId=None, itemId=None,):
11622 
    self.cartId = cartId
11623 
    self.itemId = itemId
11624 
 
11625 
  def read(self, iprot):
11626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11628 
      return
11629 
    iprot.readStructBegin()
11630 
    while True:
11631 
      (fname, ftype, fid) = iprot.readFieldBegin()
11632 
      if ftype == TType.STOP:
11633 
        break
11634 
      if fid == 1:
11635 
        if ftype == TType.I64:
11636 
          self.cartId = iprot.readI64();
11637 
        else:
11638 
          iprot.skip(ftype)
11639 
      elif fid == 2:
11640 
        if ftype == TType.I64:
11641 
          self.itemId = iprot.readI64();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11654 
    if self.cartId is not None:
559 chandransh 11655 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11656 
      oprot.writeI64(self.cartId)
11657 
      oprot.writeFieldEnd()
3431 rajveer 11658 
    if self.itemId is not None:
559 chandransh 11659 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11660 
      oprot.writeI64(self.itemId)
11661 
      oprot.writeFieldEnd()
11662 
    oprot.writeFieldStop()
11663 
    oprot.writeStructEnd()
11664 
 
3431 rajveer 11665 
  def validate(self):
11666 
    return
11667 
 
11668 
 
559 chandransh 11669 
  def __repr__(self):
11670 
    L = ['%s=%r' % (key, value)
11671 
      for key, value in self.__dict__.iteritems()]
11672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11673 
 
11674 
  def __eq__(self, other):
11675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11676 
 
11677 
  def __ne__(self, other):
11678 
    return not (self == other)
11679 
 
11680 
class deleteItemFromCart_result:
11681 
  """
11682 
  Attributes:
11683 
   - scx
11684 
  """
11685 
 
11686 
  thrift_spec = (
11687 
    None, # 0
11688 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11689 
  )
11690 
 
11691 
  def __init__(self, scx=None,):
11692 
    self.scx = scx
11693 
 
11694 
  def read(self, iprot):
11695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11697 
      return
11698 
    iprot.readStructBegin()
11699 
    while True:
11700 
      (fname, ftype, fid) = iprot.readFieldBegin()
11701 
      if ftype == TType.STOP:
11702 
        break
11703 
      if fid == 1:
11704 
        if ftype == TType.STRUCT:
11705 
          self.scx = ShoppingCartException()
11706 
          self.scx.read(iprot)
11707 
        else:
11708 
          iprot.skip(ftype)
11709 
      else:
11710 
        iprot.skip(ftype)
11711 
      iprot.readFieldEnd()
11712 
    iprot.readStructEnd()
11713 
 
11714 
  def write(self, oprot):
11715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11717 
      return
11718 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11719 
    if self.scx is not None:
559 chandransh 11720 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11721 
      self.scx.write(oprot)
11722 
      oprot.writeFieldEnd()
11723 
    oprot.writeFieldStop()
11724 
    oprot.writeStructEnd()
11725 
 
3431 rajveer 11726 
  def validate(self):
11727 
    return
11728 
 
11729 
 
559 chandransh 11730 
  def __repr__(self):
11731 
    L = ['%s=%r' % (key, value)
11732 
      for key, value in self.__dict__.iteritems()]
11733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11734 
 
11735 
  def __eq__(self, other):
11736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11737 
 
11738 
  def __ne__(self, other):
11739 
    return not (self == other)
11740 
 
11741 
class addAddressToCart_args:
11742 
  """
11743 
  Attributes:
11744 
   - cartId
11745 
   - addressId
11746 
  """
11747 
 
11748 
  thrift_spec = (
11749 
    None, # 0
11750 
    (1, TType.I64, 'cartId', None, None, ), # 1
11751 
    (2, TType.I64, 'addressId', None, None, ), # 2
11752 
  )
11753 
 
11754 
  def __init__(self, cartId=None, addressId=None,):
11755 
    self.cartId = cartId
11756 
    self.addressId = addressId
11757 
 
11758 
  def read(self, iprot):
11759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11761 
      return
11762 
    iprot.readStructBegin()
11763 
    while True:
11764 
      (fname, ftype, fid) = iprot.readFieldBegin()
11765 
      if ftype == TType.STOP:
11766 
        break
11767 
      if fid == 1:
11768 
        if ftype == TType.I64:
11769 
          self.cartId = iprot.readI64();
11770 
        else:
11771 
          iprot.skip(ftype)
11772 
      elif fid == 2:
11773 
        if ftype == TType.I64:
11774 
          self.addressId = iprot.readI64();
11775 
        else:
11776 
          iprot.skip(ftype)
11777 
      else:
11778 
        iprot.skip(ftype)
11779 
      iprot.readFieldEnd()
11780 
    iprot.readStructEnd()
11781 
 
11782 
  def write(self, oprot):
11783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11785 
      return
11786 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11787 
    if self.cartId is not None:
559 chandransh 11788 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11789 
      oprot.writeI64(self.cartId)
11790 
      oprot.writeFieldEnd()
3431 rajveer 11791 
    if self.addressId is not None:
559 chandransh 11792 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11793 
      oprot.writeI64(self.addressId)
11794 
      oprot.writeFieldEnd()
11795 
    oprot.writeFieldStop()
11796 
    oprot.writeStructEnd()
11797 
 
3431 rajveer 11798 
  def validate(self):
11799 
    return
11800 
 
11801 
 
559 chandransh 11802 
  def __repr__(self):
11803 
    L = ['%s=%r' % (key, value)
11804 
      for key, value in self.__dict__.iteritems()]
11805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11806 
 
11807 
  def __eq__(self, other):
11808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11809 
 
11810 
  def __ne__(self, other):
11811 
    return not (self == other)
11812 
 
11813 
class addAddressToCart_result:
575 chandransh 11814 
  """
11815 
  Attributes:
11816 
   - scx
11817 
  """
559 chandransh 11818 
 
11819 
  thrift_spec = (
575 chandransh 11820 
    None, # 0
11821 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11822 
  )
11823 
 
575 chandransh 11824 
  def __init__(self, scx=None,):
11825 
    self.scx = scx
11826 
 
559 chandransh 11827 
  def read(self, iprot):
11828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11830 
      return
11831 
    iprot.readStructBegin()
11832 
    while True:
11833 
      (fname, ftype, fid) = iprot.readFieldBegin()
11834 
      if ftype == TType.STOP:
11835 
        break
575 chandransh 11836 
      if fid == 1:
11837 
        if ftype == TType.STRUCT:
11838 
          self.scx = ShoppingCartException()
11839 
          self.scx.read(iprot)
11840 
        else:
11841 
          iprot.skip(ftype)
559 chandransh 11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
11851 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11852 
    if self.scx is not None:
575 chandransh 11853 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11854 
      self.scx.write(oprot)
11855 
      oprot.writeFieldEnd()
559 chandransh 11856 
    oprot.writeFieldStop()
11857 
    oprot.writeStructEnd()
11858 
 
3431 rajveer 11859 
  def validate(self):
11860 
    return
11861 
 
11862 
 
559 chandransh 11863 
  def __repr__(self):
11864 
    L = ['%s=%r' % (key, value)
11865 
      for key, value in self.__dict__.iteritems()]
11866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11867 
 
11868 
  def __eq__(self, other):
11869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11870 
 
11871 
  def __ne__(self, other):
11872 
    return not (self == other)
11873 
 
5553 rajveer 11874 
class addStoreToCart_args:
11875 
  """
11876 
  Attributes:
11877 
   - cartId
11878 
   - storeId
11879 
  """
11880 
 
11881 
  thrift_spec = (
11882 
    None, # 0
11883 
    (1, TType.I64, 'cartId', None, None, ), # 1
11884 
    (2, TType.I64, 'storeId', None, None, ), # 2
11885 
  )
11886 
 
11887 
  def __init__(self, cartId=None, storeId=None,):
11888 
    self.cartId = cartId
11889 
    self.storeId = storeId
11890 
 
11891 
  def read(self, iprot):
11892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11894 
      return
11895 
    iprot.readStructBegin()
11896 
    while True:
11897 
      (fname, ftype, fid) = iprot.readFieldBegin()
11898 
      if ftype == TType.STOP:
11899 
        break
11900 
      if fid == 1:
11901 
        if ftype == TType.I64:
11902 
          self.cartId = iprot.readI64();
11903 
        else:
11904 
          iprot.skip(ftype)
11905 
      elif fid == 2:
11906 
        if ftype == TType.I64:
11907 
          self.storeId = iprot.readI64();
11908 
        else:
11909 
          iprot.skip(ftype)
11910 
      else:
11911 
        iprot.skip(ftype)
11912 
      iprot.readFieldEnd()
11913 
    iprot.readStructEnd()
11914 
 
11915 
  def write(self, oprot):
11916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11918 
      return
11919 
    oprot.writeStructBegin('addStoreToCart_args')
11920 
    if self.cartId is not None:
11921 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11922 
      oprot.writeI64(self.cartId)
11923 
      oprot.writeFieldEnd()
11924 
    if self.storeId is not None:
11925 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11926 
      oprot.writeI64(self.storeId)
11927 
      oprot.writeFieldEnd()
11928 
    oprot.writeFieldStop()
11929 
    oprot.writeStructEnd()
11930 
 
11931 
  def validate(self):
11932 
    return
11933 
 
11934 
 
11935 
  def __repr__(self):
11936 
    L = ['%s=%r' % (key, value)
11937 
      for key, value in self.__dict__.iteritems()]
11938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11939 
 
11940 
  def __eq__(self, other):
11941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11942 
 
11943 
  def __ne__(self, other):
11944 
    return not (self == other)
11945 
 
11946 
class addStoreToCart_result:
11947 
  """
11948 
  Attributes:
11949 
   - scx
11950 
  """
11951 
 
11952 
  thrift_spec = (
11953 
    None, # 0
11954 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11955 
  )
11956 
 
11957 
  def __init__(self, scx=None,):
11958 
    self.scx = scx
11959 
 
11960 
  def read(self, iprot):
11961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11963 
      return
11964 
    iprot.readStructBegin()
11965 
    while True:
11966 
      (fname, ftype, fid) = iprot.readFieldBegin()
11967 
      if ftype == TType.STOP:
11968 
        break
11969 
      if fid == 1:
11970 
        if ftype == TType.STRUCT:
11971 
          self.scx = ShoppingCartException()
11972 
          self.scx.read(iprot)
11973 
        else:
11974 
          iprot.skip(ftype)
11975 
      else:
11976 
        iprot.skip(ftype)
11977 
      iprot.readFieldEnd()
11978 
    iprot.readStructEnd()
11979 
 
11980 
  def write(self, oprot):
11981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11983 
      return
11984 
    oprot.writeStructBegin('addStoreToCart_result')
11985 
    if self.scx is not None:
11986 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11987 
      self.scx.write(oprot)
11988 
      oprot.writeFieldEnd()
11989 
    oprot.writeFieldStop()
11990 
    oprot.writeStructEnd()
11991 
 
11992 
  def validate(self):
11993 
    return
11994 
 
11995 
 
11996 
  def __repr__(self):
11997 
    L = ['%s=%r' % (key, value)
11998 
      for key, value in self.__dict__.iteritems()]
11999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12000 
 
12001 
  def __eq__(self, other):
12002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12003 
 
12004 
  def __ne__(self, other):
12005 
    return not (self == other)
12006 
 
1976 varun.gupt 12007 
class applyCouponToCart_args:
12008 
  """
12009 
  Attributes:
6922 anupam.sin 12010 
   - cart
1976 varun.gupt 12011 
   - couponCode
12012 
  """
12013 
 
12014 
  thrift_spec = (
12015 
    None, # 0
6922 anupam.sin 12016 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 12017 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
12018 
  )
12019 
 
6922 anupam.sin 12020 
  def __init__(self, cart=None, couponCode=None,):
12021 
    self.cart = cart
1976 varun.gupt 12022 
    self.couponCode = couponCode
12023 
 
12024 
  def read(self, iprot):
12025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12027 
      return
12028 
    iprot.readStructBegin()
12029 
    while True:
12030 
      (fname, ftype, fid) = iprot.readFieldBegin()
12031 
      if ftype == TType.STOP:
12032 
        break
12033 
      if fid == 1:
6922 anupam.sin 12034 
        if ftype == TType.STRUCT:
12035 
          self.cart = Cart()
12036 
          self.cart.read(iprot)
1976 varun.gupt 12037 
        else:
12038 
          iprot.skip(ftype)
12039 
      elif fid == 2:
12040 
        if ftype == TType.STRING:
12041 
          self.couponCode = iprot.readString();
12042 
        else:
12043 
          iprot.skip(ftype)
12044 
      else:
12045 
        iprot.skip(ftype)
12046 
      iprot.readFieldEnd()
12047 
    iprot.readStructEnd()
12048 
 
12049 
  def write(self, oprot):
12050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12052 
      return
12053 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 12054 
    if self.cart is not None:
12055 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
12056 
      self.cart.write(oprot)
1976 varun.gupt 12057 
      oprot.writeFieldEnd()
3431 rajveer 12058 
    if self.couponCode is not None:
1976 varun.gupt 12059 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
12060 
      oprot.writeString(self.couponCode)
12061 
      oprot.writeFieldEnd()
12062 
    oprot.writeFieldStop()
12063 
    oprot.writeStructEnd()
12064 
 
3431 rajveer 12065 
  def validate(self):
12066 
    return
12067 
 
12068 
 
1976 varun.gupt 12069 
  def __repr__(self):
12070 
    L = ['%s=%r' % (key, value)
12071 
      for key, value in self.__dict__.iteritems()]
12072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12073 
 
12074 
  def __eq__(self, other):
12075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12076 
 
12077 
  def __ne__(self, other):
12078 
    return not (self == other)
12079 
 
12080 
class applyCouponToCart_result:
12081 
  """
12082 
  Attributes:
12083 
   - scx
12084 
  """
12085 
 
12086 
  thrift_spec = (
12087 
    None, # 0
12088 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12089 
  )
12090 
 
12091 
  def __init__(self, scx=None,):
12092 
    self.scx = scx
12093 
 
12094 
  def read(self, iprot):
12095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12097 
      return
12098 
    iprot.readStructBegin()
12099 
    while True:
12100 
      (fname, ftype, fid) = iprot.readFieldBegin()
12101 
      if ftype == TType.STOP:
12102 
        break
12103 
      if fid == 1:
12104 
        if ftype == TType.STRUCT:
12105 
          self.scx = ShoppingCartException()
12106 
          self.scx.read(iprot)
12107 
        else:
12108 
          iprot.skip(ftype)
12109 
      else:
12110 
        iprot.skip(ftype)
12111 
      iprot.readFieldEnd()
12112 
    iprot.readStructEnd()
12113 
 
12114 
  def write(self, oprot):
12115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12117 
      return
12118 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 12119 
    if self.scx is not None:
1976 varun.gupt 12120 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12121 
      self.scx.write(oprot)
12122 
      oprot.writeFieldEnd()
12123 
    oprot.writeFieldStop()
12124 
    oprot.writeStructEnd()
12125 
 
3431 rajveer 12126 
  def validate(self):
12127 
    return
12128 
 
12129 
 
1976 varun.gupt 12130 
  def __repr__(self):
12131 
    L = ['%s=%r' % (key, value)
12132 
      for key, value in self.__dict__.iteritems()]
12133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12134 
 
12135 
  def __eq__(self, other):
12136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12137 
 
12138 
  def __ne__(self, other):
12139 
    return not (self == other)
12140 
 
12141 
class removeCoupon_args:
12142 
  """
12143 
  Attributes:
12144 
   - cartId
12145 
  """
12146 
 
12147 
  thrift_spec = (
12148 
    None, # 0
12149 
    (1, TType.I64, 'cartId', None, None, ), # 1
12150 
  )
12151 
 
12152 
  def __init__(self, cartId=None,):
12153 
    self.cartId = cartId
12154 
 
12155 
  def read(self, iprot):
12156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12158 
      return
12159 
    iprot.readStructBegin()
12160 
    while True:
12161 
      (fname, ftype, fid) = iprot.readFieldBegin()
12162 
      if ftype == TType.STOP:
12163 
        break
12164 
      if fid == 1:
12165 
        if ftype == TType.I64:
12166 
          self.cartId = iprot.readI64();
12167 
        else:
12168 
          iprot.skip(ftype)
12169 
      else:
12170 
        iprot.skip(ftype)
12171 
      iprot.readFieldEnd()
12172 
    iprot.readStructEnd()
12173 
 
12174 
  def write(self, oprot):
12175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12177 
      return
12178 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 12179 
    if self.cartId is not None:
1976 varun.gupt 12180 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12181 
      oprot.writeI64(self.cartId)
12182 
      oprot.writeFieldEnd()
12183 
    oprot.writeFieldStop()
12184 
    oprot.writeStructEnd()
12185 
 
3431 rajveer 12186 
  def validate(self):
12187 
    return
12188 
 
12189 
 
1976 varun.gupt 12190 
  def __repr__(self):
12191 
    L = ['%s=%r' % (key, value)
12192 
      for key, value in self.__dict__.iteritems()]
12193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12194 
 
12195 
  def __eq__(self, other):
12196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12197 
 
12198 
  def __ne__(self, other):
12199 
    return not (self == other)
12200 
 
12201 
class removeCoupon_result:
12202 
  """
12203 
  Attributes:
12204 
   - scx
12205 
  """
12206 
 
12207 
  thrift_spec = (
12208 
    None, # 0
12209 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12210 
  )
12211 
 
12212 
  def __init__(self, scx=None,):
12213 
    self.scx = scx
12214 
 
12215 
  def read(self, iprot):
12216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12218 
      return
12219 
    iprot.readStructBegin()
12220 
    while True:
12221 
      (fname, ftype, fid) = iprot.readFieldBegin()
12222 
      if ftype == TType.STOP:
12223 
        break
12224 
      if fid == 1:
12225 
        if ftype == TType.STRUCT:
12226 
          self.scx = ShoppingCartException()
12227 
          self.scx.read(iprot)
12228 
        else:
12229 
          iprot.skip(ftype)
12230 
      else:
12231 
        iprot.skip(ftype)
12232 
      iprot.readFieldEnd()
12233 
    iprot.readStructEnd()
12234 
 
12235 
  def write(self, oprot):
12236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12238 
      return
12239 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 12240 
    if self.scx is not None:
1976 varun.gupt 12241 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12242 
      self.scx.write(oprot)
12243 
      oprot.writeFieldEnd()
12244 
    oprot.writeFieldStop()
12245 
    oprot.writeStructEnd()
12246 
 
3431 rajveer 12247 
  def validate(self):
12248 
    return
12249 
 
12250 
 
1976 varun.gupt 12251 
  def __repr__(self):
12252 
    L = ['%s=%r' % (key, value)
12253 
      for key, value in self.__dict__.iteritems()]
12254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12255 
 
12256 
  def __eq__(self, other):
12257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12258 
 
12259 
  def __ne__(self, other):
12260 
    return not (self == other)
12261 
 
3554 varun.gupt 12262 
class deleteDiscountsFromCart_args:
12263 
  """
12264 
  Attributes:
12265 
   - cartId
12266 
  """
12267 
 
12268 
  thrift_spec = (
12269 
    None, # 0
12270 
    (1, TType.I64, 'cartId', None, None, ), # 1
12271 
  )
12272 
 
12273 
  def __init__(self, cartId=None,):
12274 
    self.cartId = cartId
12275 
 
12276 
  def read(self, iprot):
12277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12279 
      return
12280 
    iprot.readStructBegin()
12281 
    while True:
12282 
      (fname, ftype, fid) = iprot.readFieldBegin()
12283 
      if ftype == TType.STOP:
12284 
        break
12285 
      if fid == 1:
12286 
        if ftype == TType.I64:
12287 
          self.cartId = iprot.readI64();
12288 
        else:
12289 
          iprot.skip(ftype)
12290 
      else:
12291 
        iprot.skip(ftype)
12292 
      iprot.readFieldEnd()
12293 
    iprot.readStructEnd()
12294 
 
12295 
  def write(self, oprot):
12296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12298 
      return
12299 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12300 
    if self.cartId is not None:
12301 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12302 
      oprot.writeI64(self.cartId)
12303 
      oprot.writeFieldEnd()
12304 
    oprot.writeFieldStop()
12305 
    oprot.writeStructEnd()
12306 
 
12307 
  def validate(self):
12308 
    return
12309 
 
12310 
 
12311 
  def __repr__(self):
12312 
    L = ['%s=%r' % (key, value)
12313 
      for key, value in self.__dict__.iteritems()]
12314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12315 
 
12316 
  def __eq__(self, other):
12317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12318 
 
12319 
  def __ne__(self, other):
12320 
    return not (self == other)
12321 
 
12322 
class deleteDiscountsFromCart_result:
12323 
  """
12324 
  Attributes:
12325 
   - scx
12326 
  """
12327 
 
12328 
  thrift_spec = (
12329 
    None, # 0
12330 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12331 
  )
12332 
 
12333 
  def __init__(self, scx=None,):
12334 
    self.scx = scx
12335 
 
12336 
  def read(self, iprot):
12337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12339 
      return
12340 
    iprot.readStructBegin()
12341 
    while True:
12342 
      (fname, ftype, fid) = iprot.readFieldBegin()
12343 
      if ftype == TType.STOP:
12344 
        break
12345 
      if fid == 1:
12346 
        if ftype == TType.STRUCT:
12347 
          self.scx = ShoppingCartException()
12348 
          self.scx.read(iprot)
12349 
        else:
12350 
          iprot.skip(ftype)
12351 
      else:
12352 
        iprot.skip(ftype)
12353 
      iprot.readFieldEnd()
12354 
    iprot.readStructEnd()
12355 
 
12356 
  def write(self, oprot):
12357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12359 
      return
12360 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12361 
    if self.scx is not None:
12362 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12363 
      self.scx.write(oprot)
12364 
      oprot.writeFieldEnd()
12365 
    oprot.writeFieldStop()
12366 
    oprot.writeStructEnd()
12367 
 
12368 
  def validate(self):
12369 
    return
12370 
 
12371 
 
12372 
  def __repr__(self):
12373 
    L = ['%s=%r' % (key, value)
12374 
      for key, value in self.__dict__.iteritems()]
12375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12376 
 
12377 
  def __eq__(self, other):
12378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12379 
 
12380 
  def __ne__(self, other):
12381 
    return not (self == other)
12382 
 
12383 
class saveDiscounts_args:
12384 
  """
12385 
  Attributes:
12386 
   - discounts
12387 
  """
12388 
 
12389 
  thrift_spec = (
12390 
    None, # 0
12391 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12392 
  )
12393 
 
12394 
  def __init__(self, discounts=None,):
12395 
    self.discounts = discounts
12396 
 
12397 
  def read(self, iprot):
12398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12400 
      return
12401 
    iprot.readStructBegin()
12402 
    while True:
12403 
      (fname, ftype, fid) = iprot.readFieldBegin()
12404 
      if ftype == TType.STOP:
12405 
        break
12406 
      if fid == 1:
12407 
        if ftype == TType.LIST:
12408 
          self.discounts = []
11592 amit.gupta 12409 
          (_etype163, _size160) = iprot.readListBegin()
12410 
          for _i164 in xrange(_size160):
12411 
            _elem165 = Discount()
12412 
            _elem165.read(iprot)
12413 
            self.discounts.append(_elem165)
3554 varun.gupt 12414 
          iprot.readListEnd()
12415 
        else:
12416 
          iprot.skip(ftype)
12417 
      else:
12418 
        iprot.skip(ftype)
12419 
      iprot.readFieldEnd()
12420 
    iprot.readStructEnd()
12421 
 
12422 
  def write(self, oprot):
12423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12425 
      return
12426 
    oprot.writeStructBegin('saveDiscounts_args')
12427 
    if self.discounts is not None:
12428 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12429 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12430 
      for iter166 in self.discounts:
12431 
        iter166.write(oprot)
3554 varun.gupt 12432 
      oprot.writeListEnd()
12433 
      oprot.writeFieldEnd()
12434 
    oprot.writeFieldStop()
12435 
    oprot.writeStructEnd()
12436 
 
12437 
  def validate(self):
12438 
    return
12439 
 
12440 
 
12441 
  def __repr__(self):
12442 
    L = ['%s=%r' % (key, value)
12443 
      for key, value in self.__dict__.iteritems()]
12444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12445 
 
12446 
  def __eq__(self, other):
12447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12448 
 
12449 
  def __ne__(self, other):
12450 
    return not (self == other)
12451 
 
12452 
class saveDiscounts_result:
12453 
  """
12454 
  Attributes:
12455 
   - scx
12456 
  """
12457 
 
12458 
  thrift_spec = (
12459 
    None, # 0
12460 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12461 
  )
12462 
 
12463 
  def __init__(self, scx=None,):
12464 
    self.scx = scx
12465 
 
12466 
  def read(self, iprot):
12467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12469 
      return
12470 
    iprot.readStructBegin()
12471 
    while True:
12472 
      (fname, ftype, fid) = iprot.readFieldBegin()
12473 
      if ftype == TType.STOP:
12474 
        break
12475 
      if fid == 1:
12476 
        if ftype == TType.STRUCT:
12477 
          self.scx = ShoppingCartException()
12478 
          self.scx.read(iprot)
12479 
        else:
12480 
          iprot.skip(ftype)
12481 
      else:
12482 
        iprot.skip(ftype)
12483 
      iprot.readFieldEnd()
12484 
    iprot.readStructEnd()
12485 
 
12486 
  def write(self, oprot):
12487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12489 
      return
12490 
    oprot.writeStructBegin('saveDiscounts_result')
12491 
    if self.scx is not None:
12492 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12493 
      self.scx.write(oprot)
12494 
      oprot.writeFieldEnd()
12495 
    oprot.writeFieldStop()
12496 
    oprot.writeStructEnd()
12497 
 
12498 
  def validate(self):
12499 
    return
12500 
 
12501 
 
12502 
  def __repr__(self):
12503 
    L = ['%s=%r' % (key, value)
12504 
      for key, value in self.__dict__.iteritems()]
12505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12506 
 
12507 
  def __eq__(self, other):
12508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12509 
 
12510 
  def __ne__(self, other):
12511 
    return not (self == other)
12512 
 
690 chandransh 12513 
class createOrders_args:
559 chandransh 12514 
  """
12515 
  Attributes:
12516 
   - cartId
2815 vikas 12517 
   - sessionSource
12518 
   - sessionStartTime
3858 vikas 12519 
   - firstSource
12520 
   - firstSourceTime
5326 rajveer 12521 
   - userId
6389 rajveer 12522 
   - schemeId
11526 amit.gupta 12523 
   - orderSource
21454 amit.gupta 12524 
   - selfPickup
559 chandransh 12525 
  """
12526 
 
12527 
  thrift_spec = (
12528 
    None, # 0
12529 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12530 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12531 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12532 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12533 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12534 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12535 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12536 
    (8, TType.I64, 'orderSource', None, None, ), # 8
21454 amit.gupta 12537 
    (9, TType.BOOL, 'selfPickup', None, None, ), # 9
559 chandransh 12538 
  )
12539 
 
21454 amit.gupta 12540 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None, selfPickup=None,):
559 chandransh 12541 
    self.cartId = cartId
2815 vikas 12542 
    self.sessionSource = sessionSource
12543 
    self.sessionStartTime = sessionStartTime
3858 vikas 12544 
    self.firstSource = firstSource
12545 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12546 
    self.userId = userId
6389 rajveer 12547 
    self.schemeId = schemeId
11526 amit.gupta 12548 
    self.orderSource = orderSource
21454 amit.gupta 12549 
    self.selfPickup = selfPickup
559 chandransh 12550 
 
12551 
  def read(self, iprot):
12552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12554 
      return
12555 
    iprot.readStructBegin()
12556 
    while True:
12557 
      (fname, ftype, fid) = iprot.readFieldBegin()
12558 
      if ftype == TType.STOP:
12559 
        break
12560 
      if fid == 1:
12561 
        if ftype == TType.I64:
12562 
          self.cartId = iprot.readI64();
12563 
        else:
12564 
          iprot.skip(ftype)
2815 vikas 12565 
      elif fid == 2:
12566 
        if ftype == TType.STRING:
12567 
          self.sessionSource = iprot.readString();
12568 
        else:
12569 
          iprot.skip(ftype)
12570 
      elif fid == 3:
12571 
        if ftype == TType.I64:
12572 
          self.sessionStartTime = iprot.readI64();
12573 
        else:
12574 
          iprot.skip(ftype)
3858 vikas 12575 
      elif fid == 4:
12576 
        if ftype == TType.STRING:
12577 
          self.firstSource = iprot.readString();
12578 
        else:
12579 
          iprot.skip(ftype)
12580 
      elif fid == 5:
12581 
        if ftype == TType.I64:
12582 
          self.firstSourceTime = iprot.readI64();
12583 
        else:
12584 
          iprot.skip(ftype)
5326 rajveer 12585 
      elif fid == 6:
12586 
        if ftype == TType.I64:
12587 
          self.userId = iprot.readI64();
12588 
        else:
12589 
          iprot.skip(ftype)
6389 rajveer 12590 
      elif fid == 7:
12591 
        if ftype == TType.I64:
12592 
          self.schemeId = iprot.readI64();
12593 
        else:
12594 
          iprot.skip(ftype)
11526 amit.gupta 12595 
      elif fid == 8:
12596 
        if ftype == TType.I64:
12597 
          self.orderSource = iprot.readI64();
12598 
        else:
12599 
          iprot.skip(ftype)
21454 amit.gupta 12600 
      elif fid == 9:
12601 
        if ftype == TType.BOOL:
12602 
          self.selfPickup = iprot.readBool();
12603 
        else:
12604 
          iprot.skip(ftype)
559 chandransh 12605 
      else:
12606 
        iprot.skip(ftype)
12607 
      iprot.readFieldEnd()
12608 
    iprot.readStructEnd()
12609 
 
12610 
  def write(self, oprot):
12611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12613 
      return
690 chandransh 12614 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12615 
    if self.cartId is not None:
559 chandransh 12616 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12617 
      oprot.writeI64(self.cartId)
12618 
      oprot.writeFieldEnd()
3431 rajveer 12619 
    if self.sessionSource is not None:
2815 vikas 12620 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12621 
      oprot.writeString(self.sessionSource)
12622 
      oprot.writeFieldEnd()
3431 rajveer 12623 
    if self.sessionStartTime is not None:
2815 vikas 12624 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12625 
      oprot.writeI64(self.sessionStartTime)
12626 
      oprot.writeFieldEnd()
3858 vikas 12627 
    if self.firstSource is not None:
12628 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12629 
      oprot.writeString(self.firstSource)
12630 
      oprot.writeFieldEnd()
12631 
    if self.firstSourceTime is not None:
12632 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12633 
      oprot.writeI64(self.firstSourceTime)
12634 
      oprot.writeFieldEnd()
5326 rajveer 12635 
    if self.userId is not None:
12636 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12637 
      oprot.writeI64(self.userId)
12638 
      oprot.writeFieldEnd()
6389 rajveer 12639 
    if self.schemeId is not None:
12640 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12641 
      oprot.writeI64(self.schemeId)
12642 
      oprot.writeFieldEnd()
11526 amit.gupta 12643 
    if self.orderSource is not None:
12644 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12645 
      oprot.writeI64(self.orderSource)
12646 
      oprot.writeFieldEnd()
21454 amit.gupta 12647 
    if self.selfPickup is not None:
12648 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 9)
12649 
      oprot.writeBool(self.selfPickup)
12650 
      oprot.writeFieldEnd()
559 chandransh 12651 
    oprot.writeFieldStop()
12652 
    oprot.writeStructEnd()
12653 
 
3431 rajveer 12654 
  def validate(self):
12655 
    return
12656 
 
12657 
 
559 chandransh 12658 
  def __repr__(self):
12659 
    L = ['%s=%r' % (key, value)
12660 
      for key, value in self.__dict__.iteritems()]
12661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12662 
 
12663 
  def __eq__(self, other):
12664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12665 
 
12666 
  def __ne__(self, other):
12667 
    return not (self == other)
12668 
 
690 chandransh 12669 
class createOrders_result:
559 chandransh 12670 
  """
12671 
  Attributes:
94 ashish 12672 
   - success
559 chandransh 12673 
   - scx
94 ashish 12674 
  """
12675 
 
12676 
  thrift_spec = (
575 chandransh 12677 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12678 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12679 
  )
12680 
 
559 chandransh 12681 
  def __init__(self, success=None, scx=None,):
94 ashish 12682 
    self.success = success
559 chandransh 12683 
    self.scx = scx
94 ashish 12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 0:
575 chandransh 12695 
        if ftype == TType.I64:
12696 
          self.success = iprot.readI64();
94 ashish 12697 
        else:
12698 
          iprot.skip(ftype)
12699 
      elif fid == 1:
12700 
        if ftype == TType.STRUCT:
559 chandransh 12701 
          self.scx = ShoppingCartException()
12702 
          self.scx.read(iprot)
94 ashish 12703 
        else:
12704 
          iprot.skip(ftype)
12705 
      else:
12706 
        iprot.skip(ftype)
12707 
      iprot.readFieldEnd()
12708 
    iprot.readStructEnd()
12709 
 
12710 
  def write(self, oprot):
12711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12713 
      return
690 chandransh 12714 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12715 
    if self.success is not None:
575 chandransh 12716 
      oprot.writeFieldBegin('success', TType.I64, 0)
12717 
      oprot.writeI64(self.success)
94 ashish 12718 
      oprot.writeFieldEnd()
3431 rajveer 12719 
    if self.scx is not None:
559 chandransh 12720 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12721 
      self.scx.write(oprot)
94 ashish 12722 
      oprot.writeFieldEnd()
12723 
    oprot.writeFieldStop()
12724 
    oprot.writeStructEnd()
12725 
 
3431 rajveer 12726 
  def validate(self):
12727 
    return
12728 
 
12729 
 
94 ashish 12730 
  def __repr__(self):
12731 
    L = ['%s=%r' % (key, value)
12732 
      for key, value in self.__dict__.iteritems()]
12733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12734 
 
12735 
  def __eq__(self, other):
12736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12737 
 
12738 
  def __ne__(self, other):
12739 
    return not (self == other)
12740 
 
559 chandransh 12741 
class validateCart_args:
94 ashish 12742 
  """
12743 
  Attributes:
559 chandransh 12744 
   - cartId
3557 rajveer 12745 
   - sourceId
94 ashish 12746 
  """
12747 
 
12748 
  thrift_spec = (
12749 
    None, # 0
559 chandransh 12750 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12751 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12752 
  )
12753 
 
3557 rajveer 12754 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12755 
    self.cartId = cartId
3557 rajveer 12756 
    self.sourceId = sourceId
94 ashish 12757 
 
12758 
  def read(self, iprot):
12759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12761 
      return
12762 
    iprot.readStructBegin()
12763 
    while True:
12764 
      (fname, ftype, fid) = iprot.readFieldBegin()
12765 
      if ftype == TType.STOP:
12766 
        break
12767 
      if fid == 1:
12768 
        if ftype == TType.I64:
559 chandransh 12769 
          self.cartId = iprot.readI64();
94 ashish 12770 
        else:
12771 
          iprot.skip(ftype)
3557 rajveer 12772 
      elif fid == 2:
12773 
        if ftype == TType.I64:
12774 
          self.sourceId = iprot.readI64();
12775 
        else:
12776 
          iprot.skip(ftype)
94 ashish 12777 
      else:
12778 
        iprot.skip(ftype)
12779 
      iprot.readFieldEnd()
12780 
    iprot.readStructEnd()
12781 
 
12782 
  def write(self, oprot):
12783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12785 
      return
559 chandransh 12786 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12787 
    if self.cartId is not None:
559 chandransh 12788 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12789 
      oprot.writeI64(self.cartId)
94 ashish 12790 
      oprot.writeFieldEnd()
3557 rajveer 12791 
    if self.sourceId is not None:
12792 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12793 
      oprot.writeI64(self.sourceId)
12794 
      oprot.writeFieldEnd()
94 ashish 12795 
    oprot.writeFieldStop()
12796 
    oprot.writeStructEnd()
12797 
 
3431 rajveer 12798 
  def validate(self):
12799 
    return
12800 
 
12801 
 
94 ashish 12802 
  def __repr__(self):
12803 
    L = ['%s=%r' % (key, value)
12804 
      for key, value in self.__dict__.iteritems()]
12805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12806 
 
12807 
  def __eq__(self, other):
12808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12809 
 
12810 
  def __ne__(self, other):
12811 
    return not (self == other)
12812 
 
559 chandransh 12813 
class validateCart_result:
94 ashish 12814 
  """
12815 
  Attributes:
12816 
   - success
575 chandransh 12817 
   - scex
94 ashish 12818 
  """
12819 
 
12820 
  thrift_spec = (
6736 amit.gupta 12821 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12822 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12823 
  )
12824 
 
575 chandransh 12825 
  def __init__(self, success=None, scex=None,):
94 ashish 12826 
    self.success = success
575 chandransh 12827 
    self.scex = scex
94 ashish 12828 
 
12829 
  def read(self, iprot):
12830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12832 
      return
12833 
    iprot.readStructBegin()
12834 
    while True:
12835 
      (fname, ftype, fid) = iprot.readFieldBegin()
12836 
      if ftype == TType.STOP:
12837 
        break
12838 
      if fid == 0:
6736 amit.gupta 12839 
        if ftype == TType.LIST:
12840 
          self.success = []
11592 amit.gupta 12841 
          (_etype170, _size167) = iprot.readListBegin()
12842 
          for _i171 in xrange(_size167):
12843 
            _elem172 = iprot.readString();
12844 
            self.success.append(_elem172)
6736 amit.gupta 12845 
          iprot.readListEnd()
94 ashish 12846 
        else:
12847 
          iprot.skip(ftype)
575 chandransh 12848 
      elif fid == 1:
12849 
        if ftype == TType.STRUCT:
12850 
          self.scex = ShoppingCartException()
12851 
          self.scex.read(iprot)
12852 
        else:
12853 
          iprot.skip(ftype)
94 ashish 12854 
      else:
12855 
        iprot.skip(ftype)
12856 
      iprot.readFieldEnd()
12857 
    iprot.readStructEnd()
12858 
 
12859 
  def write(self, oprot):
12860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12862 
      return
559 chandransh 12863 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12864 
    if self.success is not None:
6736 amit.gupta 12865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12866 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12867 
      for iter173 in self.success:
12868 
        oprot.writeString(iter173)
6736 amit.gupta 12869 
      oprot.writeListEnd()
94 ashish 12870 
      oprot.writeFieldEnd()
3431 rajveer 12871 
    if self.scex is not None:
575 chandransh 12872 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12873 
      self.scex.write(oprot)
12874 
      oprot.writeFieldEnd()
559 chandransh 12875 
    oprot.writeFieldStop()
12876 
    oprot.writeStructEnd()
12877 
 
3431 rajveer 12878 
  def validate(self):
12879 
    return
12880 
 
12881 
 
559 chandransh 12882 
  def __repr__(self):
12883 
    L = ['%s=%r' % (key, value)
12884 
      for key, value in self.__dict__.iteritems()]
12885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12886 
 
12887 
  def __eq__(self, other):
12888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12889 
 
12890 
  def __ne__(self, other):
12891 
    return not (self == other)
12892 
 
11980 amit.gupta 12893 
class validateCartWithDealerCoupon_args:
12894 
  """
12895 
  Attributes:
12896 
   - cartId
12897 
   - sourceId
12898 
   - dealCoupon
12899 
  """
12900 
 
12901 
  thrift_spec = (
12902 
    None, # 0
12903 
    (1, TType.I64, 'cartId', None, None, ), # 1
12904 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12905 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12906 
  )
12907 
 
12908 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12909 
    self.cartId = cartId
12910 
    self.sourceId = sourceId
12911 
    self.dealCoupon = dealCoupon
12912 
 
12913 
  def read(self, iprot):
12914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12916 
      return
12917 
    iprot.readStructBegin()
12918 
    while True:
12919 
      (fname, ftype, fid) = iprot.readFieldBegin()
12920 
      if ftype == TType.STOP:
12921 
        break
12922 
      if fid == 1:
12923 
        if ftype == TType.I64:
12924 
          self.cartId = iprot.readI64();
12925 
        else:
12926 
          iprot.skip(ftype)
12927 
      elif fid == 2:
12928 
        if ftype == TType.I64:
12929 
          self.sourceId = iprot.readI64();
12930 
        else:
12931 
          iprot.skip(ftype)
12932 
      elif fid == 3:
12933 
        if ftype == TType.STRING:
12934 
          self.dealCoupon = iprot.readString();
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
12946 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12947 
    if self.cartId is not None:
12948 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12949 
      oprot.writeI64(self.cartId)
12950 
      oprot.writeFieldEnd()
12951 
    if self.sourceId is not None:
12952 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12953 
      oprot.writeI64(self.sourceId)
12954 
      oprot.writeFieldEnd()
12955 
    if self.dealCoupon is not None:
12956 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12957 
      oprot.writeString(self.dealCoupon)
12958 
      oprot.writeFieldEnd()
12959 
    oprot.writeFieldStop()
12960 
    oprot.writeStructEnd()
12961 
 
12962 
  def validate(self):
12963 
    return
12964 
 
12965 
 
12966 
  def __repr__(self):
12967 
    L = ['%s=%r' % (key, value)
12968 
      for key, value in self.__dict__.iteritems()]
12969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12970 
 
12971 
  def __eq__(self, other):
12972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12973 
 
12974 
  def __ne__(self, other):
12975 
    return not (self == other)
12976 
 
12977 
class validateCartWithDealerCoupon_result:
12978 
  """
12979 
  Attributes:
12980 
   - success
12981 
   - scex
12982 
  """
12983 
 
12984 
  thrift_spec = (
12985 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12986 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12987 
  )
12988 
 
12989 
  def __init__(self, success=None, scex=None,):
12990 
    self.success = success
12991 
    self.scex = scex
12992 
 
12993 
  def read(self, iprot):
12994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12996 
      return
12997 
    iprot.readStructBegin()
12998 
    while True:
12999 
      (fname, ftype, fid) = iprot.readFieldBegin()
13000 
      if ftype == TType.STOP:
13001 
        break
13002 
      if fid == 0:
13003 
        if ftype == TType.LIST:
13004 
          self.success = []
13005 
          (_etype177, _size174) = iprot.readListBegin()
13006 
          for _i178 in xrange(_size174):
13007 
            _elem179 = iprot.readString();
13008 
            self.success.append(_elem179)
13009 
          iprot.readListEnd()
13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      elif fid == 1:
13013 
        if ftype == TType.STRUCT:
13014 
          self.scex = ShoppingCartException()
13015 
          self.scex.read(iprot)
13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
13027 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
13028 
    if self.success is not None:
13029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13030 
      oprot.writeListBegin(TType.STRING, len(self.success))
13031 
      for iter180 in self.success:
13032 
        oprot.writeString(iter180)
13033 
      oprot.writeListEnd()
13034 
      oprot.writeFieldEnd()
13035 
    if self.scex is not None:
13036 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13037 
      self.scex.write(oprot)
13038 
      oprot.writeFieldEnd()
13039 
    oprot.writeFieldStop()
13040 
    oprot.writeStructEnd()
13041 
 
13042 
  def validate(self):
13043 
    return
13044 
 
13045 
 
13046 
  def __repr__(self):
13047 
    L = ['%s=%r' % (key, value)
13048 
      for key, value in self.__dict__.iteritems()]
13049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13050 
 
13051 
  def __eq__(self, other):
13052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13053 
 
13054 
  def __ne__(self, other):
13055 
    return not (self == other)
13056 
 
690 chandransh 13057 
class mergeCart_args:
575 chandransh 13058 
  """
13059 
  Attributes:
690 chandransh 13060 
   - fromCartId
13061 
   - toCartId
13062 
  """
13063 
 
13064 
  thrift_spec = (
13065 
    None, # 0
13066 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
13067 
    (2, TType.I64, 'toCartId', None, None, ), # 2
13068 
  )
13069 
 
13070 
  def __init__(self, fromCartId=None, toCartId=None,):
13071 
    self.fromCartId = fromCartId
13072 
    self.toCartId = toCartId
13073 
 
13074 
  def read(self, iprot):
13075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13077 
      return
13078 
    iprot.readStructBegin()
13079 
    while True:
13080 
      (fname, ftype, fid) = iprot.readFieldBegin()
13081 
      if ftype == TType.STOP:
13082 
        break
13083 
      if fid == 1:
13084 
        if ftype == TType.I64:
13085 
          self.fromCartId = iprot.readI64();
13086 
        else:
13087 
          iprot.skip(ftype)
13088 
      elif fid == 2:
13089 
        if ftype == TType.I64:
13090 
          self.toCartId = iprot.readI64();
13091 
        else:
13092 
          iprot.skip(ftype)
13093 
      else:
13094 
        iprot.skip(ftype)
13095 
      iprot.readFieldEnd()
13096 
    iprot.readStructEnd()
13097 
 
13098 
  def write(self, oprot):
13099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13101 
      return
13102 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 13103 
    if self.fromCartId is not None:
690 chandransh 13104 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
13105 
      oprot.writeI64(self.fromCartId)
13106 
      oprot.writeFieldEnd()
3431 rajveer 13107 
    if self.toCartId is not None:
690 chandransh 13108 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
13109 
      oprot.writeI64(self.toCartId)
13110 
      oprot.writeFieldEnd()
13111 
    oprot.writeFieldStop()
13112 
    oprot.writeStructEnd()
13113 
 
3431 rajveer 13114 
  def validate(self):
13115 
    return
13116 
 
13117 
 
690 chandransh 13118 
  def __repr__(self):
13119 
    L = ['%s=%r' % (key, value)
13120 
      for key, value in self.__dict__.iteritems()]
13121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13122 
 
13123 
  def __eq__(self, other):
13124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13125 
 
13126 
  def __ne__(self, other):
13127 
    return not (self == other)
13128 
 
13129 
class mergeCart_result:
13130 
 
13131 
  thrift_spec = (
13132 
  )
13133 
 
13134 
  def read(self, iprot):
13135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13137 
      return
13138 
    iprot.readStructBegin()
13139 
    while True:
13140 
      (fname, ftype, fid) = iprot.readFieldBegin()
13141 
      if ftype == TType.STOP:
13142 
        break
13143 
      else:
13144 
        iprot.skip(ftype)
13145 
      iprot.readFieldEnd()
13146 
    iprot.readStructEnd()
13147 
 
13148 
  def write(self, oprot):
13149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13151 
      return
13152 
    oprot.writeStructBegin('mergeCart_result')
13153 
    oprot.writeFieldStop()
13154 
    oprot.writeStructEnd()
13155 
 
3431 rajveer 13156 
  def validate(self):
13157 
    return
13158 
 
13159 
 
690 chandransh 13160 
  def __repr__(self):
13161 
    L = ['%s=%r' % (key, value)
13162 
      for key, value in self.__dict__.iteritems()]
13163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13164 
 
13165 
  def __eq__(self, other):
13166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13167 
 
13168 
  def __ne__(self, other):
13169 
    return not (self == other)
13170 
 
13171 
class checkOut_args:
13172 
  """
13173 
  Attributes:
575 chandransh 13174 
   - cartId
13175 
  """
13176 
 
13177 
  thrift_spec = (
13178 
    None, # 0
13179 
    (1, TType.I64, 'cartId', None, None, ), # 1
13180 
  )
13181 
 
13182 
  def __init__(self, cartId=None,):
13183 
    self.cartId = cartId
13184 
 
13185 
  def read(self, iprot):
13186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13188 
      return
13189 
    iprot.readStructBegin()
13190 
    while True:
13191 
      (fname, ftype, fid) = iprot.readFieldBegin()
13192 
      if ftype == TType.STOP:
13193 
        break
13194 
      if fid == 1:
13195 
        if ftype == TType.I64:
13196 
          self.cartId = iprot.readI64();
13197 
        else:
13198 
          iprot.skip(ftype)
13199 
      else:
13200 
        iprot.skip(ftype)
13201 
      iprot.readFieldEnd()
13202 
    iprot.readStructEnd()
13203 
 
13204 
  def write(self, oprot):
13205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13207 
      return
690 chandransh 13208 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 13209 
    if self.cartId is not None:
575 chandransh 13210 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13211 
      oprot.writeI64(self.cartId)
13212 
      oprot.writeFieldEnd()
13213 
    oprot.writeFieldStop()
13214 
    oprot.writeStructEnd()
13215 
 
3431 rajveer 13216 
  def validate(self):
13217 
    return
13218 
 
13219 
 
575 chandransh 13220 
  def __repr__(self):
13221 
    L = ['%s=%r' % (key, value)
13222 
      for key, value in self.__dict__.iteritems()]
13223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13224 
 
13225 
  def __eq__(self, other):
13226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13227 
 
13228 
  def __ne__(self, other):
13229 
    return not (self == other)
13230 
 
690 chandransh 13231 
class checkOut_result:
575 chandransh 13232 
  """
13233 
  Attributes:
13234 
   - success
13235 
   - scex
13236 
  """
13237 
 
13238 
  thrift_spec = (
13239 
    (0, TType.BOOL, 'success', None, None, ), # 0
13240 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13241 
  )
13242 
 
13243 
  def __init__(self, success=None, scex=None,):
13244 
    self.success = success
13245 
    self.scex = scex
13246 
 
13247 
  def read(self, iprot):
13248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13250 
      return
13251 
    iprot.readStructBegin()
13252 
    while True:
13253 
      (fname, ftype, fid) = iprot.readFieldBegin()
13254 
      if ftype == TType.STOP:
13255 
        break
13256 
      if fid == 0:
13257 
        if ftype == TType.BOOL:
13258 
          self.success = iprot.readBool();
13259 
        else:
13260 
          iprot.skip(ftype)
13261 
      elif fid == 1:
13262 
        if ftype == TType.STRUCT:
13263 
          self.scex = ShoppingCartException()
13264 
          self.scex.read(iprot)
13265 
        else:
13266 
          iprot.skip(ftype)
13267 
      else:
13268 
        iprot.skip(ftype)
13269 
      iprot.readFieldEnd()
13270 
    iprot.readStructEnd()
13271 
 
13272 
  def write(self, oprot):
13273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13275 
      return
690 chandransh 13276 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 13277 
    if self.success is not None:
575 chandransh 13278 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13279 
      oprot.writeBool(self.success)
13280 
      oprot.writeFieldEnd()
3431 rajveer 13281 
    if self.scex is not None:
575 chandransh 13282 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13283 
      self.scex.write(oprot)
13284 
      oprot.writeFieldEnd()
13285 
    oprot.writeFieldStop()
13286 
    oprot.writeStructEnd()
13287 
 
3431 rajveer 13288 
  def validate(self):
13289 
    return
13290 
 
13291 
 
575 chandransh 13292 
  def __repr__(self):
13293 
    L = ['%s=%r' % (key, value)
13294 
      for key, value in self.__dict__.iteritems()]
13295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13296 
 
13297 
  def __eq__(self, other):
13298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13299 
 
13300 
  def __ne__(self, other):
13301 
    return not (self == other)
13302 
 
690 chandransh 13303 
class resetCart_args:
559 chandransh 13304 
  """
13305 
  Attributes:
690 chandransh 13306 
   - cartId
13307 
   - items
559 chandransh 13308 
  """
13309 
 
13310 
  thrift_spec = (
13311 
    None, # 0
690 chandransh 13312 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13313 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13314 
  )
13315 
 
690 chandransh 13316 
  def __init__(self, cartId=None, items=None,):
13317 
    self.cartId = cartId
13318 
    self.items = items
559 chandransh 13319 
 
13320 
  def read(self, iprot):
13321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13323 
      return
13324 
    iprot.readStructBegin()
13325 
    while True:
13326 
      (fname, ftype, fid) = iprot.readFieldBegin()
13327 
      if ftype == TType.STOP:
13328 
        break
13329 
      if fid == 1:
13330 
        if ftype == TType.I64:
690 chandransh 13331 
          self.cartId = iprot.readI64();
559 chandransh 13332 
        else:
13333 
          iprot.skip(ftype)
13334 
      elif fid == 2:
690 chandransh 13335 
        if ftype == TType.MAP:
13336 
          self.items = {}
11980 amit.gupta 13337 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13338 
          for _i185 in xrange(_size181):
13339 
            _key186 = iprot.readI64();
13340 
            _val187 = iprot.readDouble();
13341 
            self.items[_key186] = _val187
690 chandransh 13342 
          iprot.readMapEnd()
559 chandransh 13343 
        else:
13344 
          iprot.skip(ftype)
13345 
      else:
13346 
        iprot.skip(ftype)
13347 
      iprot.readFieldEnd()
13348 
    iprot.readStructEnd()
13349 
 
13350 
  def write(self, oprot):
13351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13353 
      return
690 chandransh 13354 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13355 
    if self.cartId is not None:
690 chandransh 13356 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13357 
      oprot.writeI64(self.cartId)
94 ashish 13358 
      oprot.writeFieldEnd()
3431 rajveer 13359 
    if self.items is not None:
690 chandransh 13360 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13361 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13362 
      for kiter188,viter189 in self.items.items():
13363 
        oprot.writeI64(kiter188)
13364 
        oprot.writeDouble(viter189)
690 chandransh 13365 
      oprot.writeMapEnd()
559 chandransh 13366 
      oprot.writeFieldEnd()
94 ashish 13367 
    oprot.writeFieldStop()
13368 
    oprot.writeStructEnd()
13369 
 
3431 rajveer 13370 
  def validate(self):
13371 
    return
13372 
 
13373 
 
94 ashish 13374 
  def __repr__(self):
13375 
    L = ['%s=%r' % (key, value)
13376 
      for key, value in self.__dict__.iteritems()]
13377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13378 
 
13379 
  def __eq__(self, other):
13380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13381 
 
13382 
  def __ne__(self, other):
13383 
    return not (self == other)
13384 
 
690 chandransh 13385 
class resetCart_result:
13386 
  """
13387 
  Attributes:
13388 
   - success
13389 
   - scex
13390 
  """
559 chandransh 13391 
 
13392 
  thrift_spec = (
690 chandransh 13393 
    (0, TType.BOOL, 'success', None, None, ), # 0
13394 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13395 
  )
13396 
 
690 chandransh 13397 
  def __init__(self, success=None, scex=None,):
13398 
    self.success = success
13399 
    self.scex = scex
13400 
 
559 chandransh 13401 
  def read(self, iprot):
13402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13404 
      return
13405 
    iprot.readStructBegin()
13406 
    while True:
13407 
      (fname, ftype, fid) = iprot.readFieldBegin()
13408 
      if ftype == TType.STOP:
13409 
        break
690 chandransh 13410 
      if fid == 0:
13411 
        if ftype == TType.BOOL:
13412 
          self.success = iprot.readBool();
13413 
        else:
13414 
          iprot.skip(ftype)
13415 
      elif fid == 1:
13416 
        if ftype == TType.STRUCT:
13417 
          self.scex = ShoppingCartException()
13418 
          self.scex.read(iprot)
13419 
        else:
13420 
          iprot.skip(ftype)
559 chandransh 13421 
      else:
13422 
        iprot.skip(ftype)
13423 
      iprot.readFieldEnd()
13424 
    iprot.readStructEnd()
13425 
 
13426 
  def write(self, oprot):
13427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13429 
      return
690 chandransh 13430 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13431 
    if self.success is not None:
690 chandransh 13432 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13433 
      oprot.writeBool(self.success)
13434 
      oprot.writeFieldEnd()
3431 rajveer 13435 
    if self.scex is not None:
690 chandransh 13436 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13437 
      self.scex.write(oprot)
13438 
      oprot.writeFieldEnd()
559 chandransh 13439 
    oprot.writeFieldStop()
13440 
    oprot.writeStructEnd()
13441 
 
3431 rajveer 13442 
  def validate(self):
13443 
    return
13444 
 
13445 
 
559 chandransh 13446 
  def __repr__(self):
13447 
    L = ['%s=%r' % (key, value)
13448 
      for key, value in self.__dict__.iteritems()]
13449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13450 
 
13451 
  def __eq__(self, other):
13452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13453 
 
13454 
  def __ne__(self, other):
13455 
    return not (self == other)
13456 
 
2981 rajveer 13457 
class getUserCount_args:
94 ashish 13458 
  """
13459 
  Attributes:
2981 rajveer 13460 
   - userType
559 chandransh 13461 
  """
13462 
 
13463 
  thrift_spec = (
13464 
    None, # 0
2981 rajveer 13465 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13466 
  )
13467 
 
2981 rajveer 13468 
  def __init__(self, userType=None,):
13469 
    self.userType = userType
559 chandransh 13470 
 
13471 
  def read(self, iprot):
13472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13474 
      return
13475 
    iprot.readStructBegin()
13476 
    while True:
13477 
      (fname, ftype, fid) = iprot.readFieldBegin()
13478 
      if ftype == TType.STOP:
13479 
        break
13480 
      if fid == 1:
2981 rajveer 13481 
        if ftype == TType.I32:
13482 
          self.userType = iprot.readI32();
559 chandransh 13483 
        else:
13484 
          iprot.skip(ftype)
13485 
      else:
13486 
        iprot.skip(ftype)
13487 
      iprot.readFieldEnd()
13488 
    iprot.readStructEnd()
13489 
 
13490 
  def write(self, oprot):
13491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13493 
      return
2981 rajveer 13494 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13495 
    if self.userType is not None:
2981 rajveer 13496 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13497 
      oprot.writeI32(self.userType)
559 chandransh 13498 
      oprot.writeFieldEnd()
13499 
    oprot.writeFieldStop()
13500 
    oprot.writeStructEnd()
13501 
 
3431 rajveer 13502 
  def validate(self):
13503 
    return
13504 
 
13505 
 
559 chandransh 13506 
  def __repr__(self):
13507 
    L = ['%s=%r' % (key, value)
13508 
      for key, value in self.__dict__.iteritems()]
13509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13510 
 
13511 
  def __eq__(self, other):
13512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13513 
 
13514 
  def __ne__(self, other):
13515 
    return not (self == other)
13516 
 
2981 rajveer 13517 
class getUserCount_result:
94 ashish 13518 
  """
13519 
  Attributes:
13520 
   - success
13521 
  """
13522 
 
13523 
  thrift_spec = (
2981 rajveer 13524 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13525 
  )
13526 
 
2981 rajveer 13527 
  def __init__(self, success=None,):
94 ashish 13528 
    self.success = success
13529 
 
13530 
  def read(self, iprot):
13531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13533 
      return
13534 
    iprot.readStructBegin()
13535 
    while True:
13536 
      (fname, ftype, fid) = iprot.readFieldBegin()
13537 
      if ftype == TType.STOP:
13538 
        break
13539 
      if fid == 0:
2981 rajveer 13540 
        if ftype == TType.I64:
13541 
          self.success = iprot.readI64();
94 ashish 13542 
        else:
13543 
          iprot.skip(ftype)
13544 
      else:
13545 
        iprot.skip(ftype)
13546 
      iprot.readFieldEnd()
13547 
    iprot.readStructEnd()
13548 
 
13549 
  def write(self, oprot):
13550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13552 
      return
2981 rajveer 13553 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13554 
    if self.success is not None:
2981 rajveer 13555 
      oprot.writeFieldBegin('success', TType.I64, 0)
13556 
      oprot.writeI64(self.success)
94 ashish 13557 
      oprot.writeFieldEnd()
13558 
    oprot.writeFieldStop()
13559 
    oprot.writeStructEnd()
13560 
 
3431 rajveer 13561 
  def validate(self):
13562 
    return
13563 
 
13564 
 
94 ashish 13565 
  def __repr__(self):
13566 
    L = ['%s=%r' % (key, value)
13567 
      for key, value in self.__dict__.iteritems()]
13568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13569 
 
13570 
  def __eq__(self, other):
13571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13572 
 
13573 
  def __ne__(self, other):
13574 
    return not (self == other)
13575 
 
2981 rajveer 13576 
class getAllUsers_args:
94 ashish 13577 
  """
13578 
  Attributes:
2981 rajveer 13579 
   - userType
13580 
   - startDate
13581 
   - endDate
94 ashish 13582 
  """
13583 
 
13584 
  thrift_spec = (
13585 
    None, # 0
2981 rajveer 13586 
    (1, TType.I32, 'userType', None, None, ), # 1
13587 
    (2, TType.I64, 'startDate', None, None, ), # 2
13588 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13589 
  )
13590 
 
2981 rajveer 13591 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13592 
    self.userType = userType
13593 
    self.startDate = startDate
13594 
    self.endDate = endDate
94 ashish 13595 
 
13596 
  def read(self, iprot):
13597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13599 
      return
13600 
    iprot.readStructBegin()
13601 
    while True:
13602 
      (fname, ftype, fid) = iprot.readFieldBegin()
13603 
      if ftype == TType.STOP:
13604 
        break
13605 
      if fid == 1:
2981 rajveer 13606 
        if ftype == TType.I32:
13607 
          self.userType = iprot.readI32();
94 ashish 13608 
        else:
13609 
          iprot.skip(ftype)
13610 
      elif fid == 2:
559 chandransh 13611 
        if ftype == TType.I64:
2981 rajveer 13612 
          self.startDate = iprot.readI64();
94 ashish 13613 
        else:
13614 
          iprot.skip(ftype)
2981 rajveer 13615 
      elif fid == 3:
13616 
        if ftype == TType.I64:
13617 
          self.endDate = iprot.readI64();
13618 
        else:
13619 
          iprot.skip(ftype)
94 ashish 13620 
      else:
13621 
        iprot.skip(ftype)
13622 
      iprot.readFieldEnd()
13623 
    iprot.readStructEnd()
13624 
 
13625 
  def write(self, oprot):
13626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13628 
      return
2981 rajveer 13629 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13630 
    if self.userType is not None:
2981 rajveer 13631 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13632 
      oprot.writeI32(self.userType)
94 ashish 13633 
      oprot.writeFieldEnd()
3431 rajveer 13634 
    if self.startDate is not None:
2981 rajveer 13635 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13636 
      oprot.writeI64(self.startDate)
94 ashish 13637 
      oprot.writeFieldEnd()
3431 rajveer 13638 
    if self.endDate is not None:
2981 rajveer 13639 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13640 
      oprot.writeI64(self.endDate)
13641 
      oprot.writeFieldEnd()
94 ashish 13642 
    oprot.writeFieldStop()
13643 
    oprot.writeStructEnd()
13644 
 
3431 rajveer 13645 
  def validate(self):
13646 
    return
13647 
 
13648 
 
94 ashish 13649 
  def __repr__(self):
13650 
    L = ['%s=%r' % (key, value)
13651 
      for key, value in self.__dict__.iteritems()]
13652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13653 
 
13654 
  def __eq__(self, other):
13655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13656 
 
13657 
  def __ne__(self, other):
13658 
    return not (self == other)
13659 
 
2981 rajveer 13660 
class getAllUsers_result:
94 ashish 13661 
  """
13662 
  Attributes:
13663 
   - success
13664 
  """
13665 
 
13666 
  thrift_spec = (
2981 rajveer 13667 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13668 
  )
13669 
 
2981 rajveer 13670 
  def __init__(self, success=None,):
94 ashish 13671 
    self.success = success
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:
2981 rajveer 13683 
        if ftype == TType.LIST:
13684 
          self.success = []
11980 amit.gupta 13685 
          (_etype193, _size190) = iprot.readListBegin()
13686 
          for _i194 in xrange(_size190):
13687 
            _elem195 = User()
13688 
            _elem195.read(iprot)
13689 
            self.success.append(_elem195)
2981 rajveer 13690 
          iprot.readListEnd()
94 ashish 13691 
        else:
13692 
          iprot.skip(ftype)
13693 
      else:
13694 
        iprot.skip(ftype)
13695 
      iprot.readFieldEnd()
13696 
    iprot.readStructEnd()
13697 
 
13698 
  def write(self, oprot):
13699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13701 
      return
2981 rajveer 13702 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13703 
    if self.success is not None:
2981 rajveer 13704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13706 
      for iter196 in self.success:
13707 
        iter196.write(oprot)
2981 rajveer 13708 
      oprot.writeListEnd()
94 ashish 13709 
      oprot.writeFieldEnd()
13710 
    oprot.writeFieldStop()
13711 
    oprot.writeStructEnd()
13712 
 
3431 rajveer 13713 
  def validate(self):
13714 
    return
13715 
 
13716 
 
94 ashish 13717 
  def __repr__(self):
13718 
    L = ['%s=%r' % (key, value)
13719 
      for key, value in self.__dict__.iteritems()]
13720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13721 
 
13722 
  def __eq__(self, other):
13723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13724 
 
13725 
  def __ne__(self, other):
13726 
    return not (self == other)
13727 
 
2981 rajveer 13728 
class getMyResearchItems_args:
559 chandransh 13729 
  """
13730 
  Attributes:
772 rajveer 13731 
   - userId
559 chandransh 13732 
  """
13733 
 
13734 
  thrift_spec = (
13735 
    None, # 0
772 rajveer 13736 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13737 
  )
13738 
 
772 rajveer 13739 
  def __init__(self, userId=None,):
13740 
    self.userId = userId
559 chandransh 13741 
 
13742 
  def read(self, iprot):
13743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13745 
      return
13746 
    iprot.readStructBegin()
13747 
    while True:
13748 
      (fname, ftype, fid) = iprot.readFieldBegin()
13749 
      if ftype == TType.STOP:
13750 
        break
13751 
      if fid == 1:
13752 
        if ftype == TType.I64:
772 rajveer 13753 
          self.userId = iprot.readI64();
559 chandransh 13754 
        else:
13755 
          iprot.skip(ftype)
13756 
      else:
13757 
        iprot.skip(ftype)
13758 
      iprot.readFieldEnd()
13759 
    iprot.readStructEnd()
13760 
 
13761 
  def write(self, oprot):
13762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13764 
      return
2981 rajveer 13765 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13766 
    if self.userId is not None:
772 rajveer 13767 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13768 
      oprot.writeI64(self.userId)
559 chandransh 13769 
      oprot.writeFieldEnd()
13770 
    oprot.writeFieldStop()
13771 
    oprot.writeStructEnd()
13772 
 
3431 rajveer 13773 
  def validate(self):
13774 
    return
13775 
 
13776 
 
559 chandransh 13777 
  def __repr__(self):
13778 
    L = ['%s=%r' % (key, value)
13779 
      for key, value in self.__dict__.iteritems()]
13780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13781 
 
13782 
  def __eq__(self, other):
13783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13784 
 
13785 
  def __ne__(self, other):
13786 
    return not (self == other)
13787 
 
2981 rajveer 13788 
class getMyResearchItems_result:
559 chandransh 13789 
  """
13790 
  Attributes:
130 ashish 13791 
   - success
559 chandransh 13792 
   - scx
130 ashish 13793 
  """
13794 
 
13795 
  thrift_spec = (
2981 rajveer 13796 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13797 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13798 
  )
13799 
 
559 chandransh 13800 
  def __init__(self, success=None, scx=None,):
130 ashish 13801 
    self.success = success
559 chandransh 13802 
    self.scx = scx
130 ashish 13803 
 
13804 
  def read(self, iprot):
13805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13807 
      return
13808 
    iprot.readStructBegin()
13809 
    while True:
13810 
      (fname, ftype, fid) = iprot.readFieldBegin()
13811 
      if ftype == TType.STOP:
13812 
        break
13813 
      if fid == 0:
2981 rajveer 13814 
        if ftype == TType.LIST:
13815 
          self.success = []
11980 amit.gupta 13816 
          (_etype200, _size197) = iprot.readListBegin()
13817 
          for _i201 in xrange(_size197):
13818 
            _elem202 = iprot.readI64();
13819 
            self.success.append(_elem202)
2981 rajveer 13820 
          iprot.readListEnd()
130 ashish 13821 
        else:
13822 
          iprot.skip(ftype)
13823 
      elif fid == 1:
13824 
        if ftype == TType.STRUCT:
559 chandransh 13825 
          self.scx = WidgetException()
13826 
          self.scx.read(iprot)
130 ashish 13827 
        else:
13828 
          iprot.skip(ftype)
13829 
      else:
13830 
        iprot.skip(ftype)
13831 
      iprot.readFieldEnd()
13832 
    iprot.readStructEnd()
13833 
 
13834 
  def write(self, oprot):
13835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13837 
      return
2981 rajveer 13838 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13839 
    if self.success is not None:
2981 rajveer 13840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13841 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13842 
      for iter203 in self.success:
13843 
        oprot.writeI64(iter203)
2981 rajveer 13844 
      oprot.writeListEnd()
130 ashish 13845 
      oprot.writeFieldEnd()
3431 rajveer 13846 
    if self.scx is not None:
559 chandransh 13847 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13848 
      self.scx.write(oprot)
130 ashish 13849 
      oprot.writeFieldEnd()
13850 
    oprot.writeFieldStop()
13851 
    oprot.writeStructEnd()
13852 
 
3431 rajveer 13853 
  def validate(self):
13854 
    return
13855 
 
13856 
 
130 ashish 13857 
  def __repr__(self):
13858 
    L = ['%s=%r' % (key, value)
13859 
      for key, value in self.__dict__.iteritems()]
13860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13861 
 
13862 
  def __eq__(self, other):
13863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13864 
 
13865 
  def __ne__(self, other):
13866 
    return not (self == other)
13867 
 
2981 rajveer 13868 
class updateMyResearch_args:
130 ashish 13869 
  """
13870 
  Attributes:
2981 rajveer 13871 
   - userId
13872 
   - itemId
130 ashish 13873 
  """
13874 
 
13875 
  thrift_spec = (
13876 
    None, # 0
2981 rajveer 13877 
    (1, TType.I64, 'userId', None, None, ), # 1
13878 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13879 
  )
13880 
 
2981 rajveer 13881 
  def __init__(self, userId=None, itemId=None,):
13882 
    self.userId = userId
13883 
    self.itemId = itemId
130 ashish 13884 
 
13885 
  def read(self, iprot):
13886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13888 
      return
13889 
    iprot.readStructBegin()
13890 
    while True:
13891 
      (fname, ftype, fid) = iprot.readFieldBegin()
13892 
      if ftype == TType.STOP:
13893 
        break
13894 
      if fid == 1:
559 chandransh 13895 
        if ftype == TType.I64:
2981 rajveer 13896 
          self.userId = iprot.readI64();
130 ashish 13897 
        else:
13898 
          iprot.skip(ftype)
13899 
      elif fid == 2:
559 chandransh 13900 
        if ftype == TType.I64:
2981 rajveer 13901 
          self.itemId = iprot.readI64();
559 chandransh 13902 
        else:
13903 
          iprot.skip(ftype)
130 ashish 13904 
      else:
13905 
        iprot.skip(ftype)
13906 
      iprot.readFieldEnd()
13907 
    iprot.readStructEnd()
13908 
 
13909 
  def write(self, oprot):
13910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13912 
      return
2981 rajveer 13913 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13914 
    if self.userId is not None:
2981 rajveer 13915 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13916 
      oprot.writeI64(self.userId)
130 ashish 13917 
      oprot.writeFieldEnd()
3431 rajveer 13918 
    if self.itemId is not None:
2981 rajveer 13919 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13920 
      oprot.writeI64(self.itemId)
130 ashish 13921 
      oprot.writeFieldEnd()
13922 
    oprot.writeFieldStop()
13923 
    oprot.writeStructEnd()
13924 
 
3431 rajveer 13925 
  def validate(self):
13926 
    return
13927 
 
13928 
 
130 ashish 13929 
  def __repr__(self):
13930 
    L = ['%s=%r' % (key, value)
13931 
      for key, value in self.__dict__.iteritems()]
13932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13933 
 
13934 
  def __eq__(self, other):
13935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13936 
 
13937 
  def __ne__(self, other):
13938 
    return not (self == other)
13939 
 
2981 rajveer 13940 
class updateMyResearch_result:
13941 
  """
13942 
  Attributes:
13943 
   - success
13944 
   - scx
13945 
  """
559 chandransh 13946 
 
13947 
  thrift_spec = (
2981 rajveer 13948 
    (0, TType.BOOL, 'success', None, None, ), # 0
13949 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13950 
  )
13951 
 
2981 rajveer 13952 
  def __init__(self, success=None, scx=None,):
13953 
    self.success = success
13954 
    self.scx = scx
13955 
 
559 chandransh 13956 
  def read(self, iprot):
13957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13959 
      return
13960 
    iprot.readStructBegin()
13961 
    while True:
13962 
      (fname, ftype, fid) = iprot.readFieldBegin()
13963 
      if ftype == TType.STOP:
13964 
        break
2981 rajveer 13965 
      if fid == 0:
13966 
        if ftype == TType.BOOL:
13967 
          self.success = iprot.readBool();
13968 
        else:
13969 
          iprot.skip(ftype)
13970 
      elif fid == 1:
13971 
        if ftype == TType.STRUCT:
13972 
          self.scx = WidgetException()
13973 
          self.scx.read(iprot)
13974 
        else:
13975 
          iprot.skip(ftype)
559 chandransh 13976 
      else:
13977 
        iprot.skip(ftype)
13978 
      iprot.readFieldEnd()
13979 
    iprot.readStructEnd()
13980 
 
13981 
  def write(self, oprot):
13982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13984 
      return
2981 rajveer 13985 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13986 
    if self.success is not None:
2981 rajveer 13987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13988 
      oprot.writeBool(self.success)
13989 
      oprot.writeFieldEnd()
3431 rajveer 13990 
    if self.scx is not None:
2981 rajveer 13991 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13992 
      self.scx.write(oprot)
13993 
      oprot.writeFieldEnd()
559 chandransh 13994 
    oprot.writeFieldStop()
13995 
    oprot.writeStructEnd()
13996 
 
3431 rajveer 13997 
  def validate(self):
13998 
    return
13999 
 
14000 
 
559 chandransh 14001 
  def __repr__(self):
14002 
    L = ['%s=%r' % (key, value)
14003 
      for key, value in self.__dict__.iteritems()]
14004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14005 
 
14006 
  def __eq__(self, other):
14007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14008 
 
14009 
  def __ne__(self, other):
14010 
    return not (self == other)
14011 
 
2981 rajveer 14012 
class deleteItemFromMyResearch_args:
1596 ankur.sing 14013 
  """
14014 
  Attributes:
2981 rajveer 14015 
   - userId
14016 
   - itemId
1596 ankur.sing 14017 
  """
559 chandransh 14018 
 
1596 ankur.sing 14019 
  thrift_spec = (
14020 
    None, # 0
2981 rajveer 14021 
    (1, TType.I64, 'userId', None, None, ), # 1
14022 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 14023 
  )
14024 
 
2981 rajveer 14025 
  def __init__(self, userId=None, itemId=None,):
14026 
    self.userId = userId
14027 
    self.itemId = itemId
1596 ankur.sing 14028 
 
14029 
  def read(self, iprot):
14030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14032 
      return
14033 
    iprot.readStructBegin()
14034 
    while True:
14035 
      (fname, ftype, fid) = iprot.readFieldBegin()
14036 
      if ftype == TType.STOP:
14037 
        break
14038 
      if fid == 1:
2981 rajveer 14039 
        if ftype == TType.I64:
14040 
          self.userId = iprot.readI64();
1596 ankur.sing 14041 
        else:
14042 
          iprot.skip(ftype)
2981 rajveer 14043 
      elif fid == 2:
14044 
        if ftype == TType.I64:
14045 
          self.itemId = iprot.readI64();
14046 
        else:
14047 
          iprot.skip(ftype)
1596 ankur.sing 14048 
      else:
14049 
        iprot.skip(ftype)
14050 
      iprot.readFieldEnd()
14051 
    iprot.readStructEnd()
14052 
 
14053 
  def write(self, oprot):
14054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14056 
      return
2981 rajveer 14057 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 14058 
    if self.userId is not None:
2981 rajveer 14059 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14060 
      oprot.writeI64(self.userId)
1596 ankur.sing 14061 
      oprot.writeFieldEnd()
3431 rajveer 14062 
    if self.itemId is not None:
2981 rajveer 14063 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14064 
      oprot.writeI64(self.itemId)
14065 
      oprot.writeFieldEnd()
1596 ankur.sing 14066 
    oprot.writeFieldStop()
14067 
    oprot.writeStructEnd()
14068 
 
3431 rajveer 14069 
  def validate(self):
14070 
    return
14071 
 
14072 
 
1596 ankur.sing 14073 
  def __repr__(self):
14074 
    L = ['%s=%r' % (key, value)
14075 
      for key, value in self.__dict__.iteritems()]
14076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14077 
 
14078 
  def __eq__(self, other):
14079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14080 
 
14081 
  def __ne__(self, other):
14082 
    return not (self == other)
14083 
 
2981 rajveer 14084 
class deleteItemFromMyResearch_result:
1596 ankur.sing 14085 
  """
14086 
  Attributes:
2981 rajveer 14087 
   - scx
1596 ankur.sing 14088 
  """
14089 
 
14090 
  thrift_spec = (
2981 rajveer 14091 
    None, # 0
14092 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 14093 
  )
14094 
 
2981 rajveer 14095 
  def __init__(self, scx=None,):
14096 
    self.scx = scx
1596 ankur.sing 14097 
 
14098 
  def read(self, iprot):
14099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14101 
      return
14102 
    iprot.readStructBegin()
14103 
    while True:
14104 
      (fname, ftype, fid) = iprot.readFieldBegin()
14105 
      if ftype == TType.STOP:
14106 
        break
2981 rajveer 14107 
      if fid == 1:
14108 
        if ftype == TType.STRUCT:
14109 
          self.scx = WidgetException()
14110 
          self.scx.read(iprot)
1596 ankur.sing 14111 
        else:
14112 
          iprot.skip(ftype)
14113 
      else:
14114 
        iprot.skip(ftype)
14115 
      iprot.readFieldEnd()
14116 
    iprot.readStructEnd()
14117 
 
14118 
  def write(self, oprot):
14119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14121 
      return
2981 rajveer 14122 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 14123 
    if self.scx is not None:
2981 rajveer 14124 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14125 
      self.scx.write(oprot)
1596 ankur.sing 14126 
      oprot.writeFieldEnd()
14127 
    oprot.writeFieldStop()
14128 
    oprot.writeStructEnd()
14129 
 
3431 rajveer 14130 
  def validate(self):
14131 
    return
14132 
 
14133 
 
1596 ankur.sing 14134 
  def __repr__(self):
14135 
    L = ['%s=%r' % (key, value)
14136 
      for key, value in self.__dict__.iteritems()]
14137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14138 
 
14139 
  def __eq__(self, other):
14140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14141 
 
14142 
  def __ne__(self, other):
14143 
    return not (self == other)
14144 
 
2981 rajveer 14145 
class getBrowseHistoryItems_args:
1673 ankur.sing 14146 
  """
14147 
  Attributes:
2981 rajveer 14148 
   - userId
1673 ankur.sing 14149 
  """
1596 ankur.sing 14150 
 
1673 ankur.sing 14151 
  thrift_spec = (
14152 
    None, # 0
2981 rajveer 14153 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 14154 
  )
14155 
 
2981 rajveer 14156 
  def __init__(self, userId=None,):
14157 
    self.userId = userId
1673 ankur.sing 14158 
 
14159 
  def read(self, iprot):
14160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14162 
      return
14163 
    iprot.readStructBegin()
14164 
    while True:
14165 
      (fname, ftype, fid) = iprot.readFieldBegin()
14166 
      if ftype == TType.STOP:
14167 
        break
14168 
      if fid == 1:
1891 ankur.sing 14169 
        if ftype == TType.I64:
2981 rajveer 14170 
          self.userId = iprot.readI64();
1891 ankur.sing 14171 
        else:
14172 
          iprot.skip(ftype)
1673 ankur.sing 14173 
      else:
14174 
        iprot.skip(ftype)
14175 
      iprot.readFieldEnd()
14176 
    iprot.readStructEnd()
14177 
 
14178 
  def write(self, oprot):
14179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14181 
      return
2981 rajveer 14182 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 14183 
    if self.userId is not None:
2981 rajveer 14184 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14185 
      oprot.writeI64(self.userId)
1673 ankur.sing 14186 
      oprot.writeFieldEnd()
14187 
    oprot.writeFieldStop()
14188 
    oprot.writeStructEnd()
14189 
 
3431 rajveer 14190 
  def validate(self):
14191 
    return
14192 
 
14193 
 
1673 ankur.sing 14194 
  def __repr__(self):
14195 
    L = ['%s=%r' % (key, value)
14196 
      for key, value in self.__dict__.iteritems()]
14197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14198 
 
14199 
  def __eq__(self, other):
14200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14201 
 
14202 
  def __ne__(self, other):
14203 
    return not (self == other)
14204 
 
2981 rajveer 14205 
class getBrowseHistoryItems_result:
1673 ankur.sing 14206 
  """
14207 
  Attributes:
14208 
   - success
2981 rajveer 14209 
   - scx
1673 ankur.sing 14210 
  """
14211 
 
14212 
  thrift_spec = (
2981 rajveer 14213 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14214 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 14215 
  )
14216 
 
2981 rajveer 14217 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 14218 
    self.success = success
2981 rajveer 14219 
    self.scx = scx
1673 ankur.sing 14220 
 
14221 
  def read(self, iprot):
14222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14224 
      return
14225 
    iprot.readStructBegin()
14226 
    while True:
14227 
      (fname, ftype, fid) = iprot.readFieldBegin()
14228 
      if ftype == TType.STOP:
14229 
        break
14230 
      if fid == 0:
14231 
        if ftype == TType.LIST:
14232 
          self.success = []
11980 amit.gupta 14233 
          (_etype207, _size204) = iprot.readListBegin()
14234 
          for _i208 in xrange(_size204):
14235 
            _elem209 = iprot.readI64();
14236 
            self.success.append(_elem209)
1673 ankur.sing 14237 
          iprot.readListEnd()
14238 
        else:
14239 
          iprot.skip(ftype)
2981 rajveer 14240 
      elif fid == 1:
14241 
        if ftype == TType.STRUCT:
14242 
          self.scx = WidgetException()
14243 
          self.scx.read(iprot)
14244 
        else:
14245 
          iprot.skip(ftype)
1673 ankur.sing 14246 
      else:
14247 
        iprot.skip(ftype)
14248 
      iprot.readFieldEnd()
14249 
    iprot.readStructEnd()
14250 
 
14251 
  def write(self, oprot):
14252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14254 
      return
2981 rajveer 14255 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 14256 
    if self.success is not None:
1673 ankur.sing 14257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 14258 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14259 
      for iter210 in self.success:
14260 
        oprot.writeI64(iter210)
1673 ankur.sing 14261 
      oprot.writeListEnd()
14262 
      oprot.writeFieldEnd()
3431 rajveer 14263 
    if self.scx is not None:
2981 rajveer 14264 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14265 
      self.scx.write(oprot)
2642 varun.gupt 14266 
      oprot.writeFieldEnd()
14267 
    oprot.writeFieldStop()
14268 
    oprot.writeStructEnd()
14269 
 
3431 rajveer 14270 
  def validate(self):
14271 
    return
14272 
 
14273 
 
2642 varun.gupt 14274 
  def __repr__(self):
14275 
    L = ['%s=%r' % (key, value)
14276 
      for key, value in self.__dict__.iteritems()]
14277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14278 
 
14279 
  def __eq__(self, other):
14280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14281 
 
14282 
  def __ne__(self, other):
14283 
    return not (self == other)
14284 
 
2981 rajveer 14285 
class updateBrowseHistory_args:
2642 varun.gupt 14286 
  """
14287 
  Attributes:
2981 rajveer 14288 
   - userId
14289 
   - itemId
2642 varun.gupt 14290 
  """
14291 
 
14292 
  thrift_spec = (
14293 
    None, # 0
2981 rajveer 14294 
    (1, TType.I64, 'userId', None, None, ), # 1
14295 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 14296 
  )
14297 
 
2981 rajveer 14298 
  def __init__(self, userId=None, itemId=None,):
14299 
    self.userId = userId
14300 
    self.itemId = itemId
2642 varun.gupt 14301 
 
14302 
  def read(self, iprot):
14303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14305 
      return
14306 
    iprot.readStructBegin()
14307 
    while True:
14308 
      (fname, ftype, fid) = iprot.readFieldBegin()
14309 
      if ftype == TType.STOP:
14310 
        break
14311 
      if fid == 1:
14312 
        if ftype == TType.I64:
2981 rajveer 14313 
          self.userId = iprot.readI64();
2642 varun.gupt 14314 
        else:
14315 
          iprot.skip(ftype)
14316 
      elif fid == 2:
14317 
        if ftype == TType.I64:
2981 rajveer 14318 
          self.itemId = iprot.readI64();
2642 varun.gupt 14319 
        else:
14320 
          iprot.skip(ftype)
14321 
      else:
14322 
        iprot.skip(ftype)
14323 
      iprot.readFieldEnd()
14324 
    iprot.readStructEnd()
14325 
 
14326 
  def write(self, oprot):
14327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14329 
      return
2981 rajveer 14330 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14331 
    if self.userId is not None:
2981 rajveer 14332 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14333 
      oprot.writeI64(self.userId)
2642 varun.gupt 14334 
      oprot.writeFieldEnd()
3431 rajveer 14335 
    if self.itemId is not None:
2981 rajveer 14336 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14337 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14338 
      oprot.writeFieldEnd()
14339 
    oprot.writeFieldStop()
14340 
    oprot.writeStructEnd()
14341 
 
3431 rajveer 14342 
  def validate(self):
14343 
    return
14344 
 
14345 
 
2642 varun.gupt 14346 
  def __repr__(self):
14347 
    L = ['%s=%r' % (key, value)
14348 
      for key, value in self.__dict__.iteritems()]
14349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14350 
 
14351 
  def __eq__(self, other):
14352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14353 
 
14354 
  def __ne__(self, other):
14355 
    return not (self == other)
14356 
 
2981 rajveer 14357 
class updateBrowseHistory_result:
2642 varun.gupt 14358 
 
14359 
  thrift_spec = (
14360 
  )
14361 
 
14362 
  def read(self, iprot):
14363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14365 
      return
14366 
    iprot.readStructBegin()
14367 
    while True:
14368 
      (fname, ftype, fid) = iprot.readFieldBegin()
14369 
      if ftype == TType.STOP:
14370 
        break
14371 
      else:
14372 
        iprot.skip(ftype)
14373 
      iprot.readFieldEnd()
14374 
    iprot.readStructEnd()
14375 
 
14376 
  def write(self, oprot):
14377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14379 
      return
2981 rajveer 14380 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14381 
    oprot.writeFieldStop()
14382 
    oprot.writeStructEnd()
14383 
 
3431 rajveer 14384 
  def validate(self):
14385 
    return
14386 
 
14387 
 
2642 varun.gupt 14388 
  def __repr__(self):
14389 
    L = ['%s=%r' % (key, value)
14390 
      for key, value in self.__dict__.iteritems()]
14391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14392 
 
14393 
  def __eq__(self, other):
14394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14395 
 
14396 
  def __ne__(self, other):
14397 
    return not (self == other)
14398 
 
3385 varun.gupt 14399 
class getCartsWithCouponCount_args:
14400 
  """
14401 
  Attributes:
14402 
   - couponCode
14403 
  """
2642 varun.gupt 14404 
 
3385 varun.gupt 14405 
  thrift_spec = (
14406 
    None, # 0
14407 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14408 
  )
14409 
 
14410 
  def __init__(self, couponCode=None,):
14411 
    self.couponCode = couponCode
14412 
 
14413 
  def read(self, iprot):
14414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14416 
      return
14417 
    iprot.readStructBegin()
14418 
    while True:
14419 
      (fname, ftype, fid) = iprot.readFieldBegin()
14420 
      if ftype == TType.STOP:
14421 
        break
14422 
      if fid == 1:
14423 
        if ftype == TType.STRING:
14424 
          self.couponCode = iprot.readString();
14425 
        else:
14426 
          iprot.skip(ftype)
14427 
      else:
14428 
        iprot.skip(ftype)
14429 
      iprot.readFieldEnd()
14430 
    iprot.readStructEnd()
14431 
 
14432 
  def write(self, oprot):
14433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14435 
      return
14436 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14437 
    if self.couponCode is not None:
3385 varun.gupt 14438 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14439 
      oprot.writeString(self.couponCode)
14440 
      oprot.writeFieldEnd()
14441 
    oprot.writeFieldStop()
14442 
    oprot.writeStructEnd()
14443 
 
3431 rajveer 14444 
  def validate(self):
14445 
    return
14446 
 
14447 
 
3385 varun.gupt 14448 
  def __repr__(self):
14449 
    L = ['%s=%r' % (key, value)
14450 
      for key, value in self.__dict__.iteritems()]
14451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14452 
 
14453 
  def __eq__(self, other):
14454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14455 
 
14456 
  def __ne__(self, other):
14457 
    return not (self == other)
14458 
 
14459 
class getCartsWithCouponCount_result:
14460 
  """
14461 
  Attributes:
14462 
   - success
14463 
  """
14464 
 
14465 
  thrift_spec = (
14466 
    (0, TType.I64, 'success', None, None, ), # 0
14467 
  )
14468 
 
14469 
  def __init__(self, success=None,):
14470 
    self.success = success
14471 
 
14472 
  def read(self, iprot):
14473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14475 
      return
14476 
    iprot.readStructBegin()
14477 
    while True:
14478 
      (fname, ftype, fid) = iprot.readFieldBegin()
14479 
      if ftype == TType.STOP:
14480 
        break
14481 
      if fid == 0:
14482 
        if ftype == TType.I64:
14483 
          self.success = iprot.readI64();
14484 
        else:
14485 
          iprot.skip(ftype)
14486 
      else:
14487 
        iprot.skip(ftype)
14488 
      iprot.readFieldEnd()
14489 
    iprot.readStructEnd()
14490 
 
14491 
  def write(self, oprot):
14492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14494 
      return
14495 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14496 
    if self.success is not None:
3385 varun.gupt 14497 
      oprot.writeFieldBegin('success', TType.I64, 0)
14498 
      oprot.writeI64(self.success)
14499 
      oprot.writeFieldEnd()
14500 
    oprot.writeFieldStop()
14501 
    oprot.writeStructEnd()
14502 
 
3431 rajveer 14503 
  def validate(self):
14504 
    return
14505 
 
14506 
 
3385 varun.gupt 14507 
  def __repr__(self):
14508 
    L = ['%s=%r' % (key, value)
14509 
      for key, value in self.__dict__.iteritems()]
14510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14511 
 
14512 
  def __eq__(self, other):
14513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14514 
 
14515 
  def __ne__(self, other):
14516 
    return not (self == other)
3499 mandeep.dh 14517 
 
14518 
class increaseTrustLevel_args:
14519 
  """
14520 
  Attributes:
14521 
   - userId
14522 
   - trustLevelDelta
14523 
  """
14524 
 
14525 
  thrift_spec = (
14526 
    None, # 0
14527 
    (1, TType.I64, 'userId', None, None, ), # 1
14528 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14529 
  )
14530 
 
14531 
  def __init__(self, userId=None, trustLevelDelta=None,):
14532 
    self.userId = userId
14533 
    self.trustLevelDelta = trustLevelDelta
14534 
 
14535 
  def read(self, iprot):
14536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14538 
      return
14539 
    iprot.readStructBegin()
14540 
    while True:
14541 
      (fname, ftype, fid) = iprot.readFieldBegin()
14542 
      if ftype == TType.STOP:
14543 
        break
14544 
      if fid == 1:
14545 
        if ftype == TType.I64:
14546 
          self.userId = iprot.readI64();
14547 
        else:
14548 
          iprot.skip(ftype)
14549 
      elif fid == 2:
14550 
        if ftype == TType.DOUBLE:
14551 
          self.trustLevelDelta = iprot.readDouble();
14552 
        else:
14553 
          iprot.skip(ftype)
14554 
      else:
14555 
        iprot.skip(ftype)
14556 
      iprot.readFieldEnd()
14557 
    iprot.readStructEnd()
14558 
 
14559 
  def write(self, oprot):
14560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14562 
      return
14563 
    oprot.writeStructBegin('increaseTrustLevel_args')
14564 
    if self.userId is not None:
14565 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14566 
      oprot.writeI64(self.userId)
14567 
      oprot.writeFieldEnd()
14568 
    if self.trustLevelDelta is not None:
14569 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14570 
      oprot.writeDouble(self.trustLevelDelta)
14571 
      oprot.writeFieldEnd()
14572 
    oprot.writeFieldStop()
14573 
    oprot.writeStructEnd()
14574 
 
14575 
  def validate(self):
14576 
    return
14577 
 
14578 
 
14579 
  def __repr__(self):
14580 
    L = ['%s=%r' % (key, value)
14581 
      for key, value in self.__dict__.iteritems()]
14582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14583 
 
14584 
  def __eq__(self, other):
14585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14586 
 
14587 
  def __ne__(self, other):
14588 
    return not (self == other)
4668 varun.gupt 14589 
 
5407 amar.kumar 14590 
class getTrustLevel_args:
14591 
  """
14592 
  Attributes:
14593 
   - userId
14594 
  """
14595 
 
14596 
  thrift_spec = (
14597 
    None, # 0
14598 
    (1, TType.I64, 'userId', None, None, ), # 1
14599 
  )
14600 
 
14601 
  def __init__(self, userId=None,):
14602 
    self.userId = userId
14603 
 
14604 
  def read(self, iprot):
14605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14607 
      return
14608 
    iprot.readStructBegin()
14609 
    while True:
14610 
      (fname, ftype, fid) = iprot.readFieldBegin()
14611 
      if ftype == TType.STOP:
14612 
        break
14613 
      if fid == 1:
14614 
        if ftype == TType.I64:
14615 
          self.userId = iprot.readI64();
14616 
        else:
14617 
          iprot.skip(ftype)
14618 
      else:
14619 
        iprot.skip(ftype)
14620 
      iprot.readFieldEnd()
14621 
    iprot.readStructEnd()
14622 
 
14623 
  def write(self, oprot):
14624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14626 
      return
14627 
    oprot.writeStructBegin('getTrustLevel_args')
14628 
    if self.userId is not None:
14629 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14630 
      oprot.writeI64(self.userId)
14631 
      oprot.writeFieldEnd()
14632 
    oprot.writeFieldStop()
14633 
    oprot.writeStructEnd()
14634 
 
14635 
  def validate(self):
14636 
    return
14637 
 
14638 
 
14639 
  def __repr__(self):
14640 
    L = ['%s=%r' % (key, value)
14641 
      for key, value in self.__dict__.iteritems()]
14642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14643 
 
14644 
  def __eq__(self, other):
14645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14646 
 
14647 
  def __ne__(self, other):
14648 
    return not (self == other)
14649 
 
14650 
class getTrustLevel_result:
14651 
  """
14652 
  Attributes:
14653 
   - success
14654 
  """
14655 
 
14656 
  thrift_spec = (
14657 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14658 
  )
14659 
 
14660 
  def __init__(self, success=None,):
14661 
    self.success = success
14662 
 
14663 
  def read(self, iprot):
14664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14666 
      return
14667 
    iprot.readStructBegin()
14668 
    while True:
14669 
      (fname, ftype, fid) = iprot.readFieldBegin()
14670 
      if ftype == TType.STOP:
14671 
        break
14672 
      if fid == 0:
14673 
        if ftype == TType.DOUBLE:
14674 
          self.success = iprot.readDouble();
14675 
        else:
14676 
          iprot.skip(ftype)
14677 
      else:
14678 
        iprot.skip(ftype)
14679 
      iprot.readFieldEnd()
14680 
    iprot.readStructEnd()
14681 
 
14682 
  def write(self, oprot):
14683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14685 
      return
14686 
    oprot.writeStructBegin('getTrustLevel_result')
14687 
    if self.success is not None:
14688 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14689 
      oprot.writeDouble(self.success)
14690 
      oprot.writeFieldEnd()
14691 
    oprot.writeFieldStop()
14692 
    oprot.writeStructEnd()
14693 
 
14694 
  def validate(self):
14695 
    return
14696 
 
14697 
 
14698 
  def __repr__(self):
14699 
    L = ['%s=%r' % (key, value)
14700 
      for key, value in self.__dict__.iteritems()]
14701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14702 
 
14703 
  def __eq__(self, other):
14704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14705 
 
14706 
  def __ne__(self, other):
14707 
    return not (self == other)
14708 
 
4668 varun.gupt 14709 
class showCODOption_args:
14710 
  """
14711 
  Attributes:
14712 
   - cartId
14713 
   - sourceId
14714 
   - pincode
14715 
  """
14716 
 
14717 
  thrift_spec = (
14718 
    None, # 0
14719 
    (1, TType.I64, 'cartId', None, None, ), # 1
14720 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14721 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14722 
  )
14723 
 
14724 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14725 
    self.cartId = cartId
14726 
    self.sourceId = sourceId
14727 
    self.pincode = pincode
14728 
 
14729 
  def read(self, iprot):
14730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14732 
      return
14733 
    iprot.readStructBegin()
14734 
    while True:
14735 
      (fname, ftype, fid) = iprot.readFieldBegin()
14736 
      if ftype == TType.STOP:
14737 
        break
14738 
      if fid == 1:
14739 
        if ftype == TType.I64:
14740 
          self.cartId = iprot.readI64();
14741 
        else:
14742 
          iprot.skip(ftype)
14743 
      elif fid == 2:
14744 
        if ftype == TType.I64:
14745 
          self.sourceId = iprot.readI64();
14746 
        else:
14747 
          iprot.skip(ftype)
14748 
      elif fid == 3:
14749 
        if ftype == TType.STRING:
14750 
          self.pincode = iprot.readString();
14751 
        else:
14752 
          iprot.skip(ftype)
14753 
      else:
14754 
        iprot.skip(ftype)
14755 
      iprot.readFieldEnd()
14756 
    iprot.readStructEnd()
14757 
 
14758 
  def write(self, oprot):
14759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14761 
      return
14762 
    oprot.writeStructBegin('showCODOption_args')
14763 
    if self.cartId is not None:
14764 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14765 
      oprot.writeI64(self.cartId)
14766 
      oprot.writeFieldEnd()
14767 
    if self.sourceId is not None:
14768 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14769 
      oprot.writeI64(self.sourceId)
14770 
      oprot.writeFieldEnd()
14771 
    if self.pincode is not None:
14772 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14773 
      oprot.writeString(self.pincode)
14774 
      oprot.writeFieldEnd()
14775 
    oprot.writeFieldStop()
14776 
    oprot.writeStructEnd()
14777 
 
14778 
  def validate(self):
14779 
    return
14780 
 
14781 
 
14782 
  def __repr__(self):
14783 
    L = ['%s=%r' % (key, value)
14784 
      for key, value in self.__dict__.iteritems()]
14785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14786 
 
14787 
  def __eq__(self, other):
14788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14789 
 
14790 
  def __ne__(self, other):
14791 
    return not (self == other)
14792 
 
14793 
class showCODOption_result:
14794 
  """
14795 
  Attributes:
14796 
   - success
14797 
  """
14798 
 
14799 
  thrift_spec = (
14800 
    (0, TType.BOOL, 'success', None, None, ), # 0
14801 
  )
14802 
 
14803 
  def __init__(self, success=None,):
14804 
    self.success = success
14805 
 
14806 
  def read(self, iprot):
14807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14809 
      return
14810 
    iprot.readStructBegin()
14811 
    while True:
14812 
      (fname, ftype, fid) = iprot.readFieldBegin()
14813 
      if ftype == TType.STOP:
14814 
        break
14815 
      if fid == 0:
14816 
        if ftype == TType.BOOL:
14817 
          self.success = iprot.readBool();
14818 
        else:
14819 
          iprot.skip(ftype)
14820 
      else:
14821 
        iprot.skip(ftype)
14822 
      iprot.readFieldEnd()
14823 
    iprot.readStructEnd()
14824 
 
14825 
  def write(self, oprot):
14826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14828 
      return
14829 
    oprot.writeStructBegin('showCODOption_result')
14830 
    if self.success is not None:
14831 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14832 
      oprot.writeBool(self.success)
14833 
      oprot.writeFieldEnd()
14834 
    oprot.writeFieldStop()
14835 
    oprot.writeStructEnd()
14836 
 
14837 
  def validate(self):
14838 
    return
14839 
 
14840 
 
14841 
  def __repr__(self):
14842 
    L = ['%s=%r' % (key, value)
14843 
      for key, value in self.__dict__.iteritems()]
14844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14845 
 
14846 
  def __eq__(self, other):
14847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14848 
 
14849 
  def __ne__(self, other):
14850 
    return not (self == other)
5623 anupam.sin 14851 
 
14852 
class getUserEmails_args:
14853 
  """
14854 
  Attributes:
14855 
   - startDate
14856 
   - endDate
14857 
  """
14858 
 
14859 
  thrift_spec = (
14860 
    None, # 0
14861 
    (1, TType.I64, 'startDate', None, None, ), # 1
14862 
    (2, TType.I64, 'endDate', None, None, ), # 2
14863 
  )
14864 
 
14865 
  def __init__(self, startDate=None, endDate=None,):
14866 
    self.startDate = startDate
14867 
    self.endDate = endDate
14868 
 
14869 
  def read(self, iprot):
14870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14872 
      return
14873 
    iprot.readStructBegin()
14874 
    while True:
14875 
      (fname, ftype, fid) = iprot.readFieldBegin()
14876 
      if ftype == TType.STOP:
14877 
        break
14878 
      if fid == 1:
14879 
        if ftype == TType.I64:
14880 
          self.startDate = iprot.readI64();
14881 
        else:
14882 
          iprot.skip(ftype)
14883 
      elif fid == 2:
14884 
        if ftype == TType.I64:
14885 
          self.endDate = 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('getUserEmails_args')
14898 
    if self.startDate is not None:
14899 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14900 
      oprot.writeI64(self.startDate)
14901 
      oprot.writeFieldEnd()
14902 
    if self.endDate is not None:
14903 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14904 
      oprot.writeI64(self.endDate)
14905 
      oprot.writeFieldEnd()
14906 
    oprot.writeFieldStop()
14907 
    oprot.writeStructEnd()
14908 
 
14909 
  def validate(self):
14910 
    return
14911 
 
14912 
 
14913 
  def __repr__(self):
14914 
    L = ['%s=%r' % (key, value)
14915 
      for key, value in self.__dict__.iteritems()]
14916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14917 
 
14918 
  def __eq__(self, other):
14919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14920 
 
14921 
  def __ne__(self, other):
14922 
    return not (self == other)
14923 
 
14924 
class getUserEmails_result:
14925 
  """
14926 
  Attributes:
14927 
   - success
14928 
  """
14929 
 
14930 
  thrift_spec = (
14931 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14932 
  )
14933 
 
14934 
  def __init__(self, success=None,):
14935 
    self.success = success
14936 
 
14937 
  def read(self, iprot):
14938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14940 
      return
14941 
    iprot.readStructBegin()
14942 
    while True:
14943 
      (fname, ftype, fid) = iprot.readFieldBegin()
14944 
      if ftype == TType.STOP:
14945 
        break
14946 
      if fid == 0:
14947 
        if ftype == TType.LIST:
14948 
          self.success = []
11980 amit.gupta 14949 
          (_etype214, _size211) = iprot.readListBegin()
14950 
          for _i215 in xrange(_size211):
14951 
            _elem216 = iprot.readString();
14952 
            self.success.append(_elem216)
5623 anupam.sin 14953 
          iprot.readListEnd()
14954 
        else:
14955 
          iprot.skip(ftype)
14956 
      else:
14957 
        iprot.skip(ftype)
14958 
      iprot.readFieldEnd()
14959 
    iprot.readStructEnd()
14960 
 
14961 
  def write(self, oprot):
14962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14964 
      return
14965 
    oprot.writeStructBegin('getUserEmails_result')
14966 
    if self.success is not None:
14967 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14968 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14969 
      for iter217 in self.success:
14970 
        oprot.writeString(iter217)
5623 anupam.sin 14971 
      oprot.writeListEnd()
14972 
      oprot.writeFieldEnd()
14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
6821 amar.kumar 14990 
 
6903 anupam.sin 14991 
class insureItem_args:
14992 
  """
14993 
  Attributes:
14994 
   - itemId
14995 
   - cartId
14996 
   - toInsure
9299 kshitij.so 14997 
   - insurerType
6903 anupam.sin 14998 
  """
14999 
 
15000 
  thrift_spec = (
15001 
    None, # 0
15002 
    (1, TType.I64, 'itemId', None, None, ), # 1
15003 
    (2, TType.I64, 'cartId', None, None, ), # 2
15004 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 15005 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 15006 
  )
15007 
 
9299 kshitij.so 15008 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 15009 
    self.itemId = itemId
15010 
    self.cartId = cartId
15011 
    self.toInsure = toInsure
9299 kshitij.so 15012 
    self.insurerType = insurerType
6903 anupam.sin 15013 
 
15014 
  def read(self, iprot):
15015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15017 
      return
15018 
    iprot.readStructBegin()
15019 
    while True:
15020 
      (fname, ftype, fid) = iprot.readFieldBegin()
15021 
      if ftype == TType.STOP:
15022 
        break
15023 
      if fid == 1:
15024 
        if ftype == TType.I64:
15025 
          self.itemId = iprot.readI64();
15026 
        else:
15027 
          iprot.skip(ftype)
15028 
      elif fid == 2:
15029 
        if ftype == TType.I64:
15030 
          self.cartId = iprot.readI64();
15031 
        else:
15032 
          iprot.skip(ftype)
15033 
      elif fid == 3:
15034 
        if ftype == TType.BOOL:
15035 
          self.toInsure = iprot.readBool();
15036 
        else:
15037 
          iprot.skip(ftype)
9299 kshitij.so 15038 
      elif fid == 4:
15039 
        if ftype == TType.I32:
15040 
          self.insurerType = iprot.readI32();
15041 
        else:
15042 
          iprot.skip(ftype)
6903 anupam.sin 15043 
      else:
15044 
        iprot.skip(ftype)
15045 
      iprot.readFieldEnd()
15046 
    iprot.readStructEnd()
15047 
 
15048 
  def write(self, oprot):
15049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15051 
      return
15052 
    oprot.writeStructBegin('insureItem_args')
15053 
    if self.itemId is not None:
15054 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15055 
      oprot.writeI64(self.itemId)
15056 
      oprot.writeFieldEnd()
15057 
    if self.cartId is not None:
15058 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
15059 
      oprot.writeI64(self.cartId)
15060 
      oprot.writeFieldEnd()
15061 
    if self.toInsure is not None:
15062 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
15063 
      oprot.writeBool(self.toInsure)
15064 
      oprot.writeFieldEnd()
9299 kshitij.so 15065 
    if self.insurerType is not None:
15066 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
15067 
      oprot.writeI32(self.insurerType)
15068 
      oprot.writeFieldEnd()
6903 anupam.sin 15069 
    oprot.writeFieldStop()
15070 
    oprot.writeStructEnd()
15071 
 
15072 
  def validate(self):
15073 
    return
15074 
 
15075 
 
15076 
  def __repr__(self):
15077 
    L = ['%s=%r' % (key, value)
15078 
      for key, value in self.__dict__.iteritems()]
15079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15080 
 
15081 
  def __eq__(self, other):
15082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15083 
 
15084 
  def __ne__(self, other):
15085 
    return not (self == other)
15086 
 
15087 
class insureItem_result:
15088 
  """
15089 
  Attributes:
15090 
   - success
15091 
  """
15092 
 
15093 
  thrift_spec = (
15094 
    (0, TType.BOOL, 'success', None, None, ), # 0
15095 
  )
15096 
 
15097 
  def __init__(self, success=None,):
15098 
    self.success = success
15099 
 
15100 
  def read(self, iprot):
15101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15103 
      return
15104 
    iprot.readStructBegin()
15105 
    while True:
15106 
      (fname, ftype, fid) = iprot.readFieldBegin()
15107 
      if ftype == TType.STOP:
15108 
        break
15109 
      if fid == 0:
15110 
        if ftype == TType.BOOL:
15111 
          self.success = iprot.readBool();
15112 
        else:
15113 
          iprot.skip(ftype)
15114 
      else:
15115 
        iprot.skip(ftype)
15116 
      iprot.readFieldEnd()
15117 
    iprot.readStructEnd()
15118 
 
15119 
  def write(self, oprot):
15120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15122 
      return
15123 
    oprot.writeStructBegin('insureItem_result')
15124 
    if self.success is not None:
15125 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15126 
      oprot.writeBool(self.success)
15127 
      oprot.writeFieldEnd()
15128 
    oprot.writeFieldStop()
15129 
    oprot.writeStructEnd()
15130 
 
15131 
  def validate(self):
15132 
    return
15133 
 
15134 
 
15135 
  def __repr__(self):
15136 
    L = ['%s=%r' % (key, value)
15137 
      for key, value in self.__dict__.iteritems()]
15138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15139 
 
15140 
  def __eq__(self, other):
15141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15142 
 
15143 
  def __ne__(self, other):
15144 
    return not (self == other)
15145 
 
15146 
class cancelInsurance_args:
15147 
  """
15148 
  Attributes:
15149 
   - cartId
15150 
  """
15151 
 
15152 
  thrift_spec = (
15153 
    None, # 0
15154 
    (1, TType.I64, 'cartId', None, None, ), # 1
15155 
  )
15156 
 
15157 
  def __init__(self, cartId=None,):
15158 
    self.cartId = cartId
15159 
 
15160 
  def read(self, iprot):
15161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15163 
      return
15164 
    iprot.readStructBegin()
15165 
    while True:
15166 
      (fname, ftype, fid) = iprot.readFieldBegin()
15167 
      if ftype == TType.STOP:
15168 
        break
15169 
      if fid == 1:
15170 
        if ftype == TType.I64:
15171 
          self.cartId = iprot.readI64();
15172 
        else:
15173 
          iprot.skip(ftype)
15174 
      else:
15175 
        iprot.skip(ftype)
15176 
      iprot.readFieldEnd()
15177 
    iprot.readStructEnd()
15178 
 
15179 
  def write(self, oprot):
15180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15182 
      return
15183 
    oprot.writeStructBegin('cancelInsurance_args')
15184 
    if self.cartId is not None:
15185 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15186 
      oprot.writeI64(self.cartId)
15187 
      oprot.writeFieldEnd()
15188 
    oprot.writeFieldStop()
15189 
    oprot.writeStructEnd()
15190 
 
15191 
  def validate(self):
15192 
    return
15193 
 
15194 
 
15195 
  def __repr__(self):
15196 
    L = ['%s=%r' % (key, value)
15197 
      for key, value in self.__dict__.iteritems()]
15198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15199 
 
15200 
  def __eq__(self, other):
15201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15202 
 
15203 
  def __ne__(self, other):
15204 
    return not (self == other)
15205 
 
15206 
class cancelInsurance_result:
15207 
  """
15208 
  Attributes:
15209 
   - success
15210 
  """
15211 
 
15212 
  thrift_spec = (
15213 
    (0, TType.BOOL, 'success', None, None, ), # 0
15214 
  )
15215 
 
15216 
  def __init__(self, success=None,):
15217 
    self.success = success
15218 
 
15219 
  def read(self, iprot):
15220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15222 
      return
15223 
    iprot.readStructBegin()
15224 
    while True:
15225 
      (fname, ftype, fid) = iprot.readFieldBegin()
15226 
      if ftype == TType.STOP:
15227 
        break
15228 
      if fid == 0:
15229 
        if ftype == TType.BOOL:
15230 
          self.success = iprot.readBool();
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('cancelInsurance_result')
15243 
    if self.success is not None:
15244 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15245 
      oprot.writeBool(self.success)
15246 
      oprot.writeFieldEnd()
15247 
    oprot.writeFieldStop()
15248 
    oprot.writeStructEnd()
15249 
 
15250 
  def validate(self):
15251 
    return
15252 
 
15253 
 
15254 
  def __repr__(self):
15255 
    L = ['%s=%r' % (key, value)
15256 
      for key, value in self.__dict__.iteritems()]
15257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15258 
 
15259 
  def __eq__(self, other):
15260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15261 
 
15262 
  def __ne__(self, other):
15263 
    return not (self == other)
15264 
 
15265 
class storeInsuranceSpecificDetails_args:
15266 
  """
15267 
  Attributes:
15268 
   - addressId
15269 
   - dob
15270 
   - guardianName
15271 
  """
15272 
 
15273 
  thrift_spec = (
15274 
    None, # 0
15275 
    (1, TType.I64, 'addressId', None, None, ), # 1
15276 
    (2, TType.STRING, 'dob', None, None, ), # 2
15277 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
15278 
  )
15279 
 
15280 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
15281 
    self.addressId = addressId
15282 
    self.dob = dob
15283 
    self.guardianName = guardianName
15284 
 
15285 
  def read(self, iprot):
15286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15288 
      return
15289 
    iprot.readStructBegin()
15290 
    while True:
15291 
      (fname, ftype, fid) = iprot.readFieldBegin()
15292 
      if ftype == TType.STOP:
15293 
        break
15294 
      if fid == 1:
15295 
        if ftype == TType.I64:
15296 
          self.addressId = iprot.readI64();
15297 
        else:
15298 
          iprot.skip(ftype)
15299 
      elif fid == 2:
15300 
        if ftype == TType.STRING:
15301 
          self.dob = iprot.readString();
15302 
        else:
15303 
          iprot.skip(ftype)
15304 
      elif fid == 3:
15305 
        if ftype == TType.STRING:
15306 
          self.guardianName = iprot.readString();
15307 
        else:
15308 
          iprot.skip(ftype)
15309 
      else:
15310 
        iprot.skip(ftype)
15311 
      iprot.readFieldEnd()
15312 
    iprot.readStructEnd()
15313 
 
15314 
  def write(self, oprot):
15315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15317 
      return
15318 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15319 
    if self.addressId is not None:
15320 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15321 
      oprot.writeI64(self.addressId)
15322 
      oprot.writeFieldEnd()
15323 
    if self.dob is not None:
15324 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15325 
      oprot.writeString(self.dob)
15326 
      oprot.writeFieldEnd()
15327 
    if self.guardianName is not None:
15328 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15329 
      oprot.writeString(self.guardianName)
15330 
      oprot.writeFieldEnd()
15331 
    oprot.writeFieldStop()
15332 
    oprot.writeStructEnd()
15333 
 
15334 
  def validate(self):
15335 
    return
15336 
 
15337 
 
15338 
  def __repr__(self):
15339 
    L = ['%s=%r' % (key, value)
15340 
      for key, value in self.__dict__.iteritems()]
15341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15342 
 
15343 
  def __eq__(self, other):
15344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15345 
 
15346 
  def __ne__(self, other):
15347 
    return not (self == other)
15348 
 
15349 
class storeInsuranceSpecificDetails_result:
15350 
  """
15351 
  Attributes:
15352 
   - success
15353 
  """
15354 
 
15355 
  thrift_spec = (
15356 
    (0, TType.BOOL, 'success', None, None, ), # 0
15357 
  )
15358 
 
15359 
  def __init__(self, success=None,):
15360 
    self.success = success
15361 
 
15362 
  def read(self, iprot):
15363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15365 
      return
15366 
    iprot.readStructBegin()
15367 
    while True:
15368 
      (fname, ftype, fid) = iprot.readFieldBegin()
15369 
      if ftype == TType.STOP:
15370 
        break
15371 
      if fid == 0:
15372 
        if ftype == TType.BOOL:
15373 
          self.success = iprot.readBool();
15374 
        else:
15375 
          iprot.skip(ftype)
15376 
      else:
15377 
        iprot.skip(ftype)
15378 
      iprot.readFieldEnd()
15379 
    iprot.readStructEnd()
15380 
 
15381 
  def write(self, oprot):
15382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15384 
      return
15385 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15386 
    if self.success is not None:
15387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15388 
      oprot.writeBool(self.success)
15389 
      oprot.writeFieldEnd()
15390 
    oprot.writeFieldStop()
15391 
    oprot.writeStructEnd()
15392 
 
15393 
  def validate(self):
15394 
    return
15395 
 
15396 
 
15397 
  def __repr__(self):
15398 
    L = ['%s=%r' % (key, value)
15399 
      for key, value in self.__dict__.iteritems()]
15400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15401 
 
15402 
  def __eq__(self, other):
15403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15404 
 
15405 
  def __ne__(self, other):
15406 
    return not (self == other)
15407 
 
15408 
class isInsuranceDetailPresent_args:
15409 
  """
15410 
  Attributes:
15411 
   - addressId
15412 
  """
15413 
 
15414 
  thrift_spec = (
15415 
    None, # 0
15416 
    (1, TType.I64, 'addressId', None, None, ), # 1
15417 
  )
15418 
 
15419 
  def __init__(self, addressId=None,):
15420 
    self.addressId = addressId
15421 
 
15422 
  def read(self, iprot):
15423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15425 
      return
15426 
    iprot.readStructBegin()
15427 
    while True:
15428 
      (fname, ftype, fid) = iprot.readFieldBegin()
15429 
      if ftype == TType.STOP:
15430 
        break
15431 
      if fid == 1:
15432 
        if ftype == TType.I64:
15433 
          self.addressId = iprot.readI64();
15434 
        else:
15435 
          iprot.skip(ftype)
15436 
      else:
15437 
        iprot.skip(ftype)
15438 
      iprot.readFieldEnd()
15439 
    iprot.readStructEnd()
15440 
 
15441 
  def write(self, oprot):
15442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15444 
      return
15445 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15446 
    if self.addressId is not None:
15447 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15448 
      oprot.writeI64(self.addressId)
15449 
      oprot.writeFieldEnd()
15450 
    oprot.writeFieldStop()
15451 
    oprot.writeStructEnd()
15452 
 
15453 
  def validate(self):
15454 
    return
15455 
 
15456 
 
15457 
  def __repr__(self):
15458 
    L = ['%s=%r' % (key, value)
15459 
      for key, value in self.__dict__.iteritems()]
15460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15461 
 
15462 
  def __eq__(self, other):
15463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15464 
 
15465 
  def __ne__(self, other):
15466 
    return not (self == other)
15467 
 
15468 
class isInsuranceDetailPresent_result:
15469 
  """
15470 
  Attributes:
15471 
   - success
15472 
  """
15473 
 
15474 
  thrift_spec = (
15475 
    (0, TType.BOOL, 'success', None, None, ), # 0
15476 
  )
15477 
 
15478 
  def __init__(self, success=None,):
15479 
    self.success = success
15480 
 
15481 
  def read(self, iprot):
15482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15484 
      return
15485 
    iprot.readStructBegin()
15486 
    while True:
15487 
      (fname, ftype, fid) = iprot.readFieldBegin()
15488 
      if ftype == TType.STOP:
15489 
        break
15490 
      if fid == 0:
15491 
        if ftype == TType.BOOL:
15492 
          self.success = iprot.readBool();
15493 
        else:
15494 
          iprot.skip(ftype)
15495 
      else:
15496 
        iprot.skip(ftype)
15497 
      iprot.readFieldEnd()
15498 
    iprot.readStructEnd()
15499 
 
15500 
  def write(self, oprot):
15501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15503 
      return
15504 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15505 
    if self.success is not None:
15506 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15507 
      oprot.writeBool(self.success)
15508 
      oprot.writeFieldEnd()
15509 
    oprot.writeFieldStop()
15510 
    oprot.writeStructEnd()
15511 
 
15512 
  def validate(self):
15513 
    return
15514 
 
15515 
 
15516 
  def __repr__(self):
15517 
    L = ['%s=%r' % (key, value)
15518 
      for key, value in self.__dict__.iteritems()]
15519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15520 
 
15521 
  def __eq__(self, other):
15522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15523 
 
15524 
  def __ne__(self, other):
15525 
    return not (self == other)
15526 
 
9791 rajveer 15527 
class getProductsAddedToCart_args:
6821 amar.kumar 15528 
  """
15529 
  Attributes:
15530 
   - startDate
15531 
   - endDate
15532 
  """
15533 
 
15534 
  thrift_spec = (
15535 
    None, # 0
9791 rajveer 15536 
    (1, TType.I64, 'startDate', None, None, ), # 1
15537 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15538 
  )
15539 
 
9791 rajveer 15540 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15541 
    self.startDate = startDate
15542 
    self.endDate = endDate
15543 
 
15544 
  def read(self, iprot):
15545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15547 
      return
15548 
    iprot.readStructBegin()
15549 
    while True:
15550 
      (fname, ftype, fid) = iprot.readFieldBegin()
15551 
      if ftype == TType.STOP:
15552 
        break
15553 
      if fid == 1:
15554 
        if ftype == TType.I64:
9791 rajveer 15555 
          self.startDate = iprot.readI64();
6821 amar.kumar 15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      elif fid == 2:
15559 
        if ftype == TType.I64:
15560 
          self.endDate = iprot.readI64();
15561 
        else:
15562 
          iprot.skip(ftype)
15563 
      else:
15564 
        iprot.skip(ftype)
15565 
      iprot.readFieldEnd()
15566 
    iprot.readStructEnd()
15567 
 
15568 
  def write(self, oprot):
15569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15571 
      return
9791 rajveer 15572 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15573 
    if self.startDate is not None:
9791 rajveer 15574 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15575 
      oprot.writeI64(self.startDate)
15576 
      oprot.writeFieldEnd()
15577 
    if self.endDate is not None:
9791 rajveer 15578 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15579 
      oprot.writeI64(self.endDate)
15580 
      oprot.writeFieldEnd()
15581 
    oprot.writeFieldStop()
15582 
    oprot.writeStructEnd()
15583 
 
15584 
  def validate(self):
15585 
    return
15586 
 
15587 
 
15588 
  def __repr__(self):
15589 
    L = ['%s=%r' % (key, value)
15590 
      for key, value in self.__dict__.iteritems()]
15591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15592 
 
15593 
  def __eq__(self, other):
15594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15595 
 
15596 
  def __ne__(self, other):
15597 
    return not (self == other)
15598 
 
9791 rajveer 15599 
class getProductsAddedToCart_result:
6821 amar.kumar 15600 
  """
15601 
  Attributes:
15602 
   - success
15603 
  """
15604 
 
15605 
  thrift_spec = (
9791 rajveer 15606 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15607 
  )
15608 
 
15609 
  def __init__(self, success=None,):
15610 
    self.success = success
15611 
 
15612 
  def read(self, iprot):
15613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15615 
      return
15616 
    iprot.readStructBegin()
15617 
    while True:
15618 
      (fname, ftype, fid) = iprot.readFieldBegin()
15619 
      if ftype == TType.STOP:
15620 
        break
15621 
      if fid == 0:
9791 rajveer 15622 
        if ftype == TType.LIST:
15623 
          self.success = []
11980 amit.gupta 15624 
          (_etype221, _size218) = iprot.readListBegin()
15625 
          for _i222 in xrange(_size218):
15626 
            _elem223 = iprot.readI64();
15627 
            self.success.append(_elem223)
9791 rajveer 15628 
          iprot.readListEnd()
6821 amar.kumar 15629 
        else:
15630 
          iprot.skip(ftype)
15631 
      else:
15632 
        iprot.skip(ftype)
15633 
      iprot.readFieldEnd()
15634 
    iprot.readStructEnd()
15635 
 
15636 
  def write(self, oprot):
15637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15639 
      return
9791 rajveer 15640 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15641 
    if self.success is not None:
9791 rajveer 15642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15643 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15644 
      for iter224 in self.success:
15645 
        oprot.writeI64(iter224)
9791 rajveer 15646 
      oprot.writeListEnd()
6821 amar.kumar 15647 
      oprot.writeFieldEnd()
15648 
    oprot.writeFieldStop()
15649 
    oprot.writeStructEnd()
15650 
 
15651 
  def validate(self):
15652 
    return
15653 
 
15654 
 
15655 
  def __repr__(self):
15656 
    L = ['%s=%r' % (key, value)
15657 
      for key, value in self.__dict__.iteritems()]
15658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15659 
 
15660 
  def __eq__(self, other):
15661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15662 
 
15663 
  def __ne__(self, other):
15664 
    return not (self == other)
11592 amit.gupta 15665 
 
15666 
class validateCartPlus_args:
15667 
  """
15668 
  Attributes:
15669 
   - cartId
15670 
   - sourceId
11980 amit.gupta 15671 
   - dealerCoupon
11592 amit.gupta 15672 
  """
15673 
 
15674 
  thrift_spec = (
15675 
    None, # 0
15676 
    (1, TType.I64, 'cartId', None, None, ), # 1
15677 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15678 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15679 
  )
15680 
 
11980 amit.gupta 15681 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15682 
    self.cartId = cartId
15683 
    self.sourceId = sourceId
11980 amit.gupta 15684 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15685 
 
15686 
  def read(self, iprot):
15687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15689 
      return
15690 
    iprot.readStructBegin()
15691 
    while True:
15692 
      (fname, ftype, fid) = iprot.readFieldBegin()
15693 
      if ftype == TType.STOP:
15694 
        break
15695 
      if fid == 1:
15696 
        if ftype == TType.I64:
15697 
          self.cartId = iprot.readI64();
15698 
        else:
15699 
          iprot.skip(ftype)
15700 
      elif fid == 2:
15701 
        if ftype == TType.I64:
15702 
          self.sourceId = iprot.readI64();
15703 
        else:
15704 
          iprot.skip(ftype)
11980 amit.gupta 15705 
      elif fid == 3:
15706 
        if ftype == TType.STRING:
15707 
          self.dealerCoupon = iprot.readString();
15708 
        else:
15709 
          iprot.skip(ftype)
11592 amit.gupta 15710 
      else:
15711 
        iprot.skip(ftype)
15712 
      iprot.readFieldEnd()
15713 
    iprot.readStructEnd()
15714 
 
15715 
  def write(self, oprot):
15716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15718 
      return
15719 
    oprot.writeStructBegin('validateCartPlus_args')
15720 
    if self.cartId is not None:
15721 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15722 
      oprot.writeI64(self.cartId)
15723 
      oprot.writeFieldEnd()
15724 
    if self.sourceId is not None:
15725 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15726 
      oprot.writeI64(self.sourceId)
15727 
      oprot.writeFieldEnd()
11980 amit.gupta 15728 
    if self.dealerCoupon is not None:
15729 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15730 
      oprot.writeString(self.dealerCoupon)
15731 
      oprot.writeFieldEnd()
11592 amit.gupta 15732 
    oprot.writeFieldStop()
15733 
    oprot.writeStructEnd()
15734 
 
15735 
  def validate(self):
15736 
    return
15737 
 
15738 
 
15739 
  def __repr__(self):
15740 
    L = ['%s=%r' % (key, value)
15741 
      for key, value in self.__dict__.iteritems()]
15742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15743 
 
15744 
  def __eq__(self, other):
15745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15746 
 
15747 
  def __ne__(self, other):
15748 
    return not (self == other)
15749 
 
15750 
class validateCartPlus_result:
15751 
  """
15752 
  Attributes:
15753 
   - success
15754 
   - scex
15755 
  """
15756 
 
15757 
  thrift_spec = (
15758 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15759 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15760 
  )
15761 
 
15762 
  def __init__(self, success=None, scex=None,):
15763 
    self.success = success
15764 
    self.scex = scex
15765 
 
15766 
  def read(self, iprot):
15767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15769 
      return
15770 
    iprot.readStructBegin()
15771 
    while True:
15772 
      (fname, ftype, fid) = iprot.readFieldBegin()
15773 
      if ftype == TType.STOP:
15774 
        break
15775 
      if fid == 0:
15776 
        if ftype == TType.STRUCT:
15777 
          self.success = CartPlus()
15778 
          self.success.read(iprot)
15779 
        else:
15780 
          iprot.skip(ftype)
15781 
      elif fid == 1:
15782 
        if ftype == TType.STRUCT:
15783 
          self.scex = ShoppingCartException()
15784 
          self.scex.read(iprot)
15785 
        else:
15786 
          iprot.skip(ftype)
15787 
      else:
15788 
        iprot.skip(ftype)
15789 
      iprot.readFieldEnd()
15790 
    iprot.readStructEnd()
15791 
 
15792 
  def write(self, oprot):
15793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15795 
      return
15796 
    oprot.writeStructBegin('validateCartPlus_result')
15797 
    if self.success is not None:
15798 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15799 
      self.success.write(oprot)
15800 
      oprot.writeFieldEnd()
15801 
    if self.scex is not None:
15802 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15803 
      self.scex.write(oprot)
15804 
      oprot.writeFieldEnd()
15805 
    oprot.writeFieldStop()
15806 
    oprot.writeStructEnd()
15807 
 
15808 
  def validate(self):
15809 
    return
15810 
 
15811 
 
15812 
  def __repr__(self):
15813 
    L = ['%s=%r' % (key, value)
15814 
      for key, value in self.__dict__.iteritems()]
15815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15816 
 
15817 
  def __eq__(self, other):
15818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15819 
 
15820 
  def __ne__(self, other):
15821 
    return not (self == other)
11679 vikram.rag 15822 
 
15823 
class isPrivateDealUser_args:
15824 
  """
15825 
  Attributes:
15826 
   - userId
15827 
  """
15828 
 
15829 
  thrift_spec = (
15830 
    None, # 0
15831 
    (1, TType.I64, 'userId', None, None, ), # 1
15832 
  )
15833 
 
15834 
  def __init__(self, userId=None,):
15835 
    self.userId = userId
15836 
 
15837 
  def read(self, iprot):
15838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15840 
      return
15841 
    iprot.readStructBegin()
15842 
    while True:
15843 
      (fname, ftype, fid) = iprot.readFieldBegin()
15844 
      if ftype == TType.STOP:
15845 
        break
15846 
      if fid == 1:
15847 
        if ftype == TType.I64:
15848 
          self.userId = iprot.readI64();
15849 
        else:
15850 
          iprot.skip(ftype)
15851 
      else:
15852 
        iprot.skip(ftype)
15853 
      iprot.readFieldEnd()
15854 
    iprot.readStructEnd()
15855 
 
15856 
  def write(self, oprot):
15857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15859 
      return
15860 
    oprot.writeStructBegin('isPrivateDealUser_args')
15861 
    if self.userId is not None:
15862 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15863 
      oprot.writeI64(self.userId)
15864 
      oprot.writeFieldEnd()
15865 
    oprot.writeFieldStop()
15866 
    oprot.writeStructEnd()
15867 
 
15868 
  def validate(self):
15869 
    return
15870 
 
15871 
 
15872 
  def __repr__(self):
15873 
    L = ['%s=%r' % (key, value)
15874 
      for key, value in self.__dict__.iteritems()]
15875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15876 
 
15877 
  def __eq__(self, other):
15878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15879 
 
15880 
  def __ne__(self, other):
15881 
    return not (self == other)
15882 
 
15883 
class isPrivateDealUser_result:
15884 
  """
15885 
  Attributes:
15886 
   - success
15887 
  """
15888 
 
15889 
  thrift_spec = (
15890 
    (0, TType.BOOL, 'success', None, None, ), # 0
15891 
  )
15892 
 
15893 
  def __init__(self, success=None,):
15894 
    self.success = success
15895 
 
15896 
  def read(self, iprot):
15897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15899 
      return
15900 
    iprot.readStructBegin()
15901 
    while True:
15902 
      (fname, ftype, fid) = iprot.readFieldBegin()
15903 
      if ftype == TType.STOP:
15904 
        break
15905 
      if fid == 0:
15906 
        if ftype == TType.BOOL:
15907 
          self.success = iprot.readBool();
15908 
        else:
15909 
          iprot.skip(ftype)
15910 
      else:
15911 
        iprot.skip(ftype)
15912 
      iprot.readFieldEnd()
15913 
    iprot.readStructEnd()
15914 
 
15915 
  def write(self, oprot):
15916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15918 
      return
15919 
    oprot.writeStructBegin('isPrivateDealUser_result')
15920 
    if self.success is not None:
15921 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15922 
      oprot.writeBool(self.success)
15923 
      oprot.writeFieldEnd()
15924 
    oprot.writeFieldStop()
15925 
    oprot.writeStructEnd()
15926 
 
15927 
  def validate(self):
15928 
    return
15929 
 
15930 
 
15931 
  def __repr__(self):
15932 
    L = ['%s=%r' % (key, value)
15933 
      for key, value in self.__dict__.iteritems()]
15934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15935 
 
15936 
  def __eq__(self, other):
15937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15938 
 
15939 
  def __ne__(self, other):
15940 
    return not (self == other)
11890 kshitij.so 15941 
 
15942 
class addPrivateDealUser_args:
15943 
  """
15944 
  Attributes:
15945 
   - userId
15946 
  """
15947 
 
15948 
  thrift_spec = (
15949 
    None, # 0
15950 
    (1, TType.I64, 'userId', None, None, ), # 1
15951 
  )
15952 
 
15953 
  def __init__(self, userId=None,):
15954 
    self.userId = userId
15955 
 
15956 
  def read(self, iprot):
15957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15959 
      return
15960 
    iprot.readStructBegin()
15961 
    while True:
15962 
      (fname, ftype, fid) = iprot.readFieldBegin()
15963 
      if ftype == TType.STOP:
15964 
        break
15965 
      if fid == 1:
15966 
        if ftype == TType.I64:
15967 
          self.userId = iprot.readI64();
15968 
        else:
15969 
          iprot.skip(ftype)
15970 
      else:
15971 
        iprot.skip(ftype)
15972 
      iprot.readFieldEnd()
15973 
    iprot.readStructEnd()
15974 
 
15975 
  def write(self, oprot):
15976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15978 
      return
15979 
    oprot.writeStructBegin('addPrivateDealUser_args')
15980 
    if self.userId is not None:
15981 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15982 
      oprot.writeI64(self.userId)
15983 
      oprot.writeFieldEnd()
15984 
    oprot.writeFieldStop()
15985 
    oprot.writeStructEnd()
15986 
 
15987 
  def validate(self):
15988 
    return
15989 
 
15990 
 
15991 
  def __repr__(self):
15992 
    L = ['%s=%r' % (key, value)
15993 
      for key, value in self.__dict__.iteritems()]
15994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15995 
 
15996 
  def __eq__(self, other):
15997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15998 
 
15999 
  def __ne__(self, other):
16000 
    return not (self == other)
16001 
 
16002 
class addPrivateDealUser_result:
16003 
  """
16004 
  Attributes:
16005 
   - success
16006 
  """
16007 
 
16008 
  thrift_spec = (
16009 
    (0, TType.BOOL, 'success', None, None, ), # 0
16010 
  )
16011 
 
16012 
  def __init__(self, success=None,):
16013 
    self.success = success
16014 
 
16015 
  def read(self, iprot):
16016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16018 
      return
16019 
    iprot.readStructBegin()
16020 
    while True:
16021 
      (fname, ftype, fid) = iprot.readFieldBegin()
16022 
      if ftype == TType.STOP:
16023 
        break
16024 
      if fid == 0:
16025 
        if ftype == TType.BOOL:
16026 
          self.success = iprot.readBool();
16027 
        else:
16028 
          iprot.skip(ftype)
16029 
      else:
16030 
        iprot.skip(ftype)
16031 
      iprot.readFieldEnd()
16032 
    iprot.readStructEnd()
16033 
 
16034 
  def write(self, oprot):
16035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16037 
      return
16038 
    oprot.writeStructBegin('addPrivateDealUser_result')
16039 
    if self.success is not None:
16040 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16041 
      oprot.writeBool(self.success)
16042 
      oprot.writeFieldEnd()
16043 
    oprot.writeFieldStop()
16044 
    oprot.writeStructEnd()
16045 
 
16046 
  def validate(self):
16047 
    return
16048 
 
16049 
 
16050 
  def __repr__(self):
16051 
    L = ['%s=%r' % (key, value)
16052 
      for key, value in self.__dict__.iteritems()]
16053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16054 
 
16055 
  def __eq__(self, other):
16056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16057 
 
16058 
  def __ne__(self, other):
16059 
    return not (self == other)
16060 
 
16061 
class changePrivateDealUserStatus_args:
16062 
  """
16063 
  Attributes:
16064 
   - userId
16065 
   - isActive
16066 
  """
16067 
 
16068 
  thrift_spec = (
16069 
    None, # 0
16070 
    (1, TType.I64, 'userId', None, None, ), # 1
16071 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
16072 
  )
16073 
 
16074 
  def __init__(self, userId=None, isActive=None,):
16075 
    self.userId = userId
16076 
    self.isActive = isActive
16077 
 
16078 
  def read(self, iprot):
16079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16081 
      return
16082 
    iprot.readStructBegin()
16083 
    while True:
16084 
      (fname, ftype, fid) = iprot.readFieldBegin()
16085 
      if ftype == TType.STOP:
16086 
        break
16087 
      if fid == 1:
16088 
        if ftype == TType.I64:
16089 
          self.userId = iprot.readI64();
16090 
        else:
16091 
          iprot.skip(ftype)
16092 
      elif fid == 2:
16093 
        if ftype == TType.BOOL:
16094 
          self.isActive = iprot.readBool();
16095 
        else:
16096 
          iprot.skip(ftype)
16097 
      else:
16098 
        iprot.skip(ftype)
16099 
      iprot.readFieldEnd()
16100 
    iprot.readStructEnd()
16101 
 
16102 
  def write(self, oprot):
16103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16105 
      return
16106 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
16107 
    if self.userId is not None:
16108 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16109 
      oprot.writeI64(self.userId)
16110 
      oprot.writeFieldEnd()
16111 
    if self.isActive is not None:
16112 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
16113 
      oprot.writeBool(self.isActive)
16114 
      oprot.writeFieldEnd()
16115 
    oprot.writeFieldStop()
16116 
    oprot.writeStructEnd()
16117 
 
16118 
  def validate(self):
16119 
    return
16120 
 
16121 
 
16122 
  def __repr__(self):
16123 
    L = ['%s=%r' % (key, value)
16124 
      for key, value in self.__dict__.iteritems()]
16125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16126 
 
16127 
  def __eq__(self, other):
16128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16129 
 
16130 
  def __ne__(self, other):
16131 
    return not (self == other)
16132 
 
16133 
class changePrivateDealUserStatus_result:
16134 
  """
16135 
  Attributes:
16136 
   - success
16137 
  """
16138 
 
16139 
  thrift_spec = (
16140 
    (0, TType.BOOL, 'success', None, None, ), # 0
16141 
  )
16142 
 
16143 
  def __init__(self, success=None,):
16144 
    self.success = success
16145 
 
16146 
  def read(self, iprot):
16147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16149 
      return
16150 
    iprot.readStructBegin()
16151 
    while True:
16152 
      (fname, ftype, fid) = iprot.readFieldBegin()
16153 
      if ftype == TType.STOP:
16154 
        break
16155 
      if fid == 0:
16156 
        if ftype == TType.BOOL:
16157 
          self.success = iprot.readBool();
16158 
        else:
16159 
          iprot.skip(ftype)
16160 
      else:
16161 
        iprot.skip(ftype)
16162 
      iprot.readFieldEnd()
16163 
    iprot.readStructEnd()
16164 
 
16165 
  def write(self, oprot):
16166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16168 
      return
16169 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
16170 
    if self.success is not None:
16171 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16172 
      oprot.writeBool(self.success)
16173 
      oprot.writeFieldEnd()
16174 
    oprot.writeFieldStop()
16175 
    oprot.writeStructEnd()
16176 
 
16177 
  def validate(self):
16178 
    return
16179 
 
16180 
 
16181 
  def __repr__(self):
16182 
    L = ['%s=%r' % (key, value)
16183 
      for key, value in self.__dict__.iteritems()]
16184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16185 
 
16186 
  def __eq__(self, other):
16187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16188 
 
16189 
  def __ne__(self, other):
16190 
    return not (self == other)
16191 
 
16192 
class getPrivateDealUser_args:
16193 
  """
16194 
  Attributes:
16195 
   - userId
16196 
  """
16197 
 
16198 
  thrift_spec = (
16199 
    None, # 0
16200 
    (1, TType.I64, 'userId', None, None, ), # 1
16201 
  )
16202 
 
16203 
  def __init__(self, userId=None,):
16204 
    self.userId = userId
16205 
 
16206 
  def read(self, iprot):
16207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16209 
      return
16210 
    iprot.readStructBegin()
16211 
    while True:
16212 
      (fname, ftype, fid) = iprot.readFieldBegin()
16213 
      if ftype == TType.STOP:
16214 
        break
16215 
      if fid == 1:
16216 
        if ftype == TType.I64:
16217 
          self.userId = iprot.readI64();
16218 
        else:
16219 
          iprot.skip(ftype)
16220 
      else:
16221 
        iprot.skip(ftype)
16222 
      iprot.readFieldEnd()
16223 
    iprot.readStructEnd()
16224 
 
16225 
  def write(self, oprot):
16226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16228 
      return
16229 
    oprot.writeStructBegin('getPrivateDealUser_args')
16230 
    if self.userId is not None:
16231 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16232 
      oprot.writeI64(self.userId)
16233 
      oprot.writeFieldEnd()
16234 
    oprot.writeFieldStop()
16235 
    oprot.writeStructEnd()
16236 
 
16237 
  def validate(self):
16238 
    return
16239 
 
16240 
 
16241 
  def __repr__(self):
16242 
    L = ['%s=%r' % (key, value)
16243 
      for key, value in self.__dict__.iteritems()]
16244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16245 
 
16246 
  def __eq__(self, other):
16247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16248 
 
16249 
  def __ne__(self, other):
16250 
    return not (self == other)
16251 
 
16252 
class getPrivateDealUser_result:
16253 
  """
16254 
  Attributes:
16255 
   - success
16256 
  """
16257 
 
16258 
  thrift_spec = (
16259 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
16260 
  )
16261 
 
16262 
  def __init__(self, success=None,):
16263 
    self.success = success
16264 
 
16265 
  def read(self, iprot):
16266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16268 
      return
16269 
    iprot.readStructBegin()
16270 
    while True:
16271 
      (fname, ftype, fid) = iprot.readFieldBegin()
16272 
      if ftype == TType.STOP:
16273 
        break
16274 
      if fid == 0:
16275 
        if ftype == TType.STRUCT:
16276 
          self.success = PrivateDealUser()
16277 
          self.success.read(iprot)
16278 
        else:
16279 
          iprot.skip(ftype)
16280 
      else:
16281 
        iprot.skip(ftype)
16282 
      iprot.readFieldEnd()
16283 
    iprot.readStructEnd()
16284 
 
16285 
  def write(self, oprot):
16286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16288 
      return
16289 
    oprot.writeStructBegin('getPrivateDealUser_result')
16290 
    if self.success is not None:
16291 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16292 
      self.success.write(oprot)
16293 
      oprot.writeFieldEnd()
16294 
    oprot.writeFieldStop()
16295 
    oprot.writeStructEnd()
16296 
 
16297 
  def validate(self):
16298 
    return
16299 
 
16300 
 
16301 
  def __repr__(self):
16302 
    L = ['%s=%r' % (key, value)
16303 
      for key, value in self.__dict__.iteritems()]
16304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16305 
 
16306 
  def __eq__(self, other):
16307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16308 
 
16309 
  def __ne__(self, other):
16310 
    return not (self == other)
12696 amit.gupta 16311 
 
16312 
class registerCounter_args:
16313 
  """
16314 
  Attributes:
16315 
   - counter
16316 
   - userId
16317 
  """
16318 
 
16319 
  thrift_spec = (
16320 
    None, # 0
16321 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16322 
    (2, TType.I64, 'userId', None, None, ), # 2
16323 
  )
16324 
 
16325 
  def __init__(self, counter=None, userId=None,):
16326 
    self.counter = counter
16327 
    self.userId = userId
16328 
 
16329 
  def read(self, iprot):
16330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16332 
      return
16333 
    iprot.readStructBegin()
16334 
    while True:
16335 
      (fname, ftype, fid) = iprot.readFieldBegin()
16336 
      if ftype == TType.STOP:
16337 
        break
16338 
      if fid == 1:
16339 
        if ftype == TType.STRUCT:
16340 
          self.counter = Counter()
16341 
          self.counter.read(iprot)
16342 
        else:
16343 
          iprot.skip(ftype)
16344 
      elif fid == 2:
16345 
        if ftype == TType.I64:
16346 
          self.userId = iprot.readI64();
16347 
        else:
16348 
          iprot.skip(ftype)
16349 
      else:
16350 
        iprot.skip(ftype)
16351 
      iprot.readFieldEnd()
16352 
    iprot.readStructEnd()
16353 
 
16354 
  def write(self, oprot):
16355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16357 
      return
16358 
    oprot.writeStructBegin('registerCounter_args')
16359 
    if self.counter is not None:
16360 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16361 
      self.counter.write(oprot)
16362 
      oprot.writeFieldEnd()
16363 
    if self.userId is not None:
16364 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16365 
      oprot.writeI64(self.userId)
16366 
      oprot.writeFieldEnd()
16367 
    oprot.writeFieldStop()
16368 
    oprot.writeStructEnd()
16369 
 
16370 
  def validate(self):
16371 
    return
16372 
 
16373 
 
16374 
  def __repr__(self):
16375 
    L = ['%s=%r' % (key, value)
16376 
      for key, value in self.__dict__.iteritems()]
16377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16378 
 
16379 
  def __eq__(self, other):
16380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16381 
 
16382 
  def __ne__(self, other):
16383 
    return not (self == other)
16384 
 
16385 
class registerCounter_result:
16386 
  """
16387 
  Attributes:
16388 
   - success
16389 
  """
16390 
 
16391 
  thrift_spec = (
16392 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16393 
  )
16394 
 
16395 
  def __init__(self, success=None,):
16396 
    self.success = success
16397 
 
16398 
  def read(self, iprot):
16399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16401 
      return
16402 
    iprot.readStructBegin()
16403 
    while True:
16404 
      (fname, ftype, fid) = iprot.readFieldBegin()
16405 
      if ftype == TType.STOP:
16406 
        break
16407 
      if fid == 0:
16408 
        if ftype == TType.MAP:
16409 
          self.success = {}
16410 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16411 
          for _i229 in xrange(_size225):
16412 
            _key230 = iprot.readString();
16413 
            _val231 = iprot.readString();
16414 
            self.success[_key230] = _val231
16415 
          iprot.readMapEnd()
16416 
        else:
16417 
          iprot.skip(ftype)
16418 
      else:
16419 
        iprot.skip(ftype)
16420 
      iprot.readFieldEnd()
16421 
    iprot.readStructEnd()
16422 
 
16423 
  def write(self, oprot):
16424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16426 
      return
16427 
    oprot.writeStructBegin('registerCounter_result')
16428 
    if self.success is not None:
16429 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16430 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16431 
      for kiter232,viter233 in self.success.items():
16432 
        oprot.writeString(kiter232)
16433 
        oprot.writeString(viter233)
16434 
      oprot.writeMapEnd()
16435 
      oprot.writeFieldEnd()
16436 
    oprot.writeFieldStop()
16437 
    oprot.writeStructEnd()
16438 
 
16439 
  def validate(self):
16440 
    return
16441 
 
16442 
 
16443 
  def __repr__(self):
16444 
    L = ['%s=%r' % (key, value)
16445 
      for key, value in self.__dict__.iteritems()]
16446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16447 
 
16448 
  def __eq__(self, other):
16449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16450 
 
16451 
  def __ne__(self, other):
16452 
    return not (self == other)
12722 amit.gupta 16453 
 
16454 
class searchCounter_args:
16455 
  """
16456 
  Attributes:
16457 
   - type1
16458 
   - searchString
16459 
  """
16460 
 
16461 
  thrift_spec = (
16462 
    None, # 0
16463 
    (1, TType.STRING, 'type1', None, None, ), # 1
16464 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16465 
  )
16466 
 
16467 
  def __init__(self, type1=None, searchString=None,):
16468 
    self.type1 = type1
16469 
    self.searchString = searchString
16470 
 
16471 
  def read(self, iprot):
16472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16474 
      return
16475 
    iprot.readStructBegin()
16476 
    while True:
16477 
      (fname, ftype, fid) = iprot.readFieldBegin()
16478 
      if ftype == TType.STOP:
16479 
        break
16480 
      if fid == 1:
16481 
        if ftype == TType.STRING:
16482 
          self.type1 = iprot.readString();
16483 
        else:
16484 
          iprot.skip(ftype)
16485 
      elif fid == 2:
16486 
        if ftype == TType.STRING:
16487 
          self.searchString = iprot.readString();
16488 
        else:
16489 
          iprot.skip(ftype)
16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('searchCounter_args')
16500 
    if self.type1 is not None:
16501 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16502 
      oprot.writeString(self.type1)
16503 
      oprot.writeFieldEnd()
16504 
    if self.searchString is not None:
16505 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16506 
      oprot.writeString(self.searchString)
16507 
      oprot.writeFieldEnd()
16508 
    oprot.writeFieldStop()
16509 
    oprot.writeStructEnd()
16510 
 
16511 
  def validate(self):
16512 
    return
16513 
 
16514 
 
16515 
  def __repr__(self):
16516 
    L = ['%s=%r' % (key, value)
16517 
      for key, value in self.__dict__.iteritems()]
16518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16519 
 
16520 
  def __eq__(self, other):
16521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16522 
 
16523 
  def __ne__(self, other):
16524 
    return not (self == other)
16525 
 
16526 
class searchCounter_result:
16527 
  """
16528 
  Attributes:
16529 
   - success
16530 
  """
16531 
 
16532 
  thrift_spec = (
16533 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16534 
  )
16535 
 
16536 
  def __init__(self, success=None,):
16537 
    self.success = success
16538 
 
16539 
  def read(self, iprot):
16540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16542 
      return
16543 
    iprot.readStructBegin()
16544 
    while True:
16545 
      (fname, ftype, fid) = iprot.readFieldBegin()
16546 
      if ftype == TType.STOP:
16547 
        break
16548 
      if fid == 0:
16549 
        if ftype == TType.LIST:
16550 
          self.success = []
16551 
          (_etype237, _size234) = iprot.readListBegin()
16552 
          for _i238 in xrange(_size234):
16553 
            _elem239 = Counter()
16554 
            _elem239.read(iprot)
16555 
            self.success.append(_elem239)
16556 
          iprot.readListEnd()
16557 
        else:
16558 
          iprot.skip(ftype)
16559 
      else:
16560 
        iprot.skip(ftype)
16561 
      iprot.readFieldEnd()
16562 
    iprot.readStructEnd()
16563 
 
16564 
  def write(self, oprot):
16565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16567 
      return
16568 
    oprot.writeStructBegin('searchCounter_result')
16569 
    if self.success is not None:
16570 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16571 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16572 
      for iter240 in self.success:
16573 
        iter240.write(oprot)
16574 
      oprot.writeListEnd()
16575 
      oprot.writeFieldEnd()
16576 
    oprot.writeFieldStop()
16577 
    oprot.writeStructEnd()
16578 
 
16579 
  def validate(self):
16580 
    return
16581 
 
16582 
 
16583 
  def __repr__(self):
16584 
    L = ['%s=%r' % (key, value)
16585 
      for key, value in self.__dict__.iteritems()]
16586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16587 
 
16588 
  def __eq__(self, other):
16589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16590 
 
16591 
  def __ne__(self, other):
16592 
    return not (self == other)
16593 
 
18977 amit.gupta 16594 
class getCounterByUserId_args:
16595 
  """
16596 
  Attributes:
16597 
   - userId
16598 
  """
16599 
 
16600 
  thrift_spec = (
16601 
    None, # 0
16602 
    (1, TType.I64, 'userId', None, None, ), # 1
16603 
  )
16604 
 
16605 
  def __init__(self, userId=None,):
16606 
    self.userId = userId
16607 
 
16608 
  def read(self, iprot):
16609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16611 
      return
16612 
    iprot.readStructBegin()
16613 
    while True:
16614 
      (fname, ftype, fid) = iprot.readFieldBegin()
16615 
      if ftype == TType.STOP:
16616 
        break
16617 
      if fid == 1:
16618 
        if ftype == TType.I64:
16619 
          self.userId = iprot.readI64();
16620 
        else:
16621 
          iprot.skip(ftype)
16622 
      else:
16623 
        iprot.skip(ftype)
16624 
      iprot.readFieldEnd()
16625 
    iprot.readStructEnd()
16626 
 
16627 
  def write(self, oprot):
16628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16630 
      return
16631 
    oprot.writeStructBegin('getCounterByUserId_args')
16632 
    if self.userId is not None:
16633 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16634 
      oprot.writeI64(self.userId)
16635 
      oprot.writeFieldEnd()
16636 
    oprot.writeFieldStop()
16637 
    oprot.writeStructEnd()
16638 
 
16639 
  def validate(self):
16640 
    return
16641 
 
16642 
 
16643 
  def __repr__(self):
16644 
    L = ['%s=%r' % (key, value)
16645 
      for key, value in self.__dict__.iteritems()]
16646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16647 
 
16648 
  def __eq__(self, other):
16649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16650 
 
16651 
  def __ne__(self, other):
16652 
    return not (self == other)
16653 
 
16654 
class getCounterByUserId_result:
16655 
  """
16656 
  Attributes:
16657 
   - success
16658 
  """
16659 
 
16660 
  thrift_spec = (
16661 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16662 
  )
16663 
 
16664 
  def __init__(self, success=None,):
16665 
    self.success = success
16666 
 
16667 
  def read(self, iprot):
16668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16670 
      return
16671 
    iprot.readStructBegin()
16672 
    while True:
16673 
      (fname, ftype, fid) = iprot.readFieldBegin()
16674 
      if ftype == TType.STOP:
16675 
        break
16676 
      if fid == 0:
16677 
        if ftype == TType.STRUCT:
16678 
          self.success = Counter()
16679 
          self.success.read(iprot)
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      else:
16683 
        iprot.skip(ftype)
16684 
      iprot.readFieldEnd()
16685 
    iprot.readStructEnd()
16686 
 
16687 
  def write(self, oprot):
16688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16690 
      return
16691 
    oprot.writeStructBegin('getCounterByUserId_result')
16692 
    if self.success is not None:
16693 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16694 
      self.success.write(oprot)
16695 
      oprot.writeFieldEnd()
16696 
    oprot.writeFieldStop()
16697 
    oprot.writeStructEnd()
16698 
 
16699 
  def validate(self):
16700 
    return
16701 
 
16702 
 
16703 
  def __repr__(self):
16704 
    L = ['%s=%r' % (key, value)
16705 
      for key, value in self.__dict__.iteritems()]
16706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16707 
 
16708 
  def __eq__(self, other):
16709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16710 
 
16711 
  def __ne__(self, other):
16712 
    return not (self == other)
16713 
 
12722 amit.gupta 16714 
class getAllUsersByCounter_args:
16715 
  """
16716 
  Attributes:
16717 
   - counterId
16718 
  """
16719 
 
16720 
  thrift_spec = (
16721 
    None, # 0
16722 
    (1, TType.I64, 'counterId', None, None, ), # 1
16723 
  )
16724 
 
16725 
  def __init__(self, counterId=None,):
16726 
    self.counterId = counterId
16727 
 
16728 
  def read(self, iprot):
16729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16731 
      return
16732 
    iprot.readStructBegin()
16733 
    while True:
16734 
      (fname, ftype, fid) = iprot.readFieldBegin()
16735 
      if ftype == TType.STOP:
16736 
        break
16737 
      if fid == 1:
16738 
        if ftype == TType.I64:
16739 
          self.counterId = iprot.readI64();
16740 
        else:
16741 
          iprot.skip(ftype)
16742 
      else:
16743 
        iprot.skip(ftype)
16744 
      iprot.readFieldEnd()
16745 
    iprot.readStructEnd()
16746 
 
16747 
  def write(self, oprot):
16748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16750 
      return
16751 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16752 
    if self.counterId is not None:
16753 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16754 
      oprot.writeI64(self.counterId)
16755 
      oprot.writeFieldEnd()
16756 
    oprot.writeFieldStop()
16757 
    oprot.writeStructEnd()
16758 
 
16759 
  def validate(self):
16760 
    return
16761 
 
16762 
 
16763 
  def __repr__(self):
16764 
    L = ['%s=%r' % (key, value)
16765 
      for key, value in self.__dict__.iteritems()]
16766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16767 
 
16768 
  def __eq__(self, other):
16769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16770 
 
16771 
  def __ne__(self, other):
16772 
    return not (self == other)
16773 
 
16774 
class getAllUsersByCounter_result:
16775 
  """
16776 
  Attributes:
16777 
   - success
16778 
  """
16779 
 
16780 
  thrift_spec = (
16781 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16782 
  )
16783 
 
16784 
  def __init__(self, success=None,):
16785 
    self.success = success
16786 
 
16787 
  def read(self, iprot):
16788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16790 
      return
16791 
    iprot.readStructBegin()
16792 
    while True:
16793 
      (fname, ftype, fid) = iprot.readFieldBegin()
16794 
      if ftype == TType.STOP:
16795 
        break
16796 
      if fid == 0:
16797 
        if ftype == TType.LIST:
16798 
          self.success = []
16799 
          (_etype244, _size241) = iprot.readListBegin()
16800 
          for _i245 in xrange(_size241):
16801 
            _elem246 = User()
16802 
            _elem246.read(iprot)
16803 
            self.success.append(_elem246)
16804 
          iprot.readListEnd()
16805 
        else:
16806 
          iprot.skip(ftype)
16807 
      else:
16808 
        iprot.skip(ftype)
16809 
      iprot.readFieldEnd()
16810 
    iprot.readStructEnd()
16811 
 
16812 
  def write(self, oprot):
16813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16815 
      return
16816 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16817 
    if self.success is not None:
16818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16820 
      for iter247 in self.success:
16821 
        iter247.write(oprot)
16822 
      oprot.writeListEnd()
16823 
      oprot.writeFieldEnd()
16824 
    oprot.writeFieldStop()
16825 
    oprot.writeStructEnd()
16826 
 
16827 
  def validate(self):
16828 
    return
16829 
 
16830 
 
16831 
  def __repr__(self):
16832 
    L = ['%s=%r' % (key, value)
16833 
      for key, value in self.__dict__.iteritems()]
16834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16835 
 
16836 
  def __eq__(self, other):
16837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16838 
 
16839 
  def __ne__(self, other):
16840 
    return not (self == other)
15251 manish.sha 16841 
 
16842 
class getActiveAccessTokenForUser_args:
16843 
  """
16844 
  Attributes:
16845 
   - userId
16846 
   - source
16847 
  """
16848 
 
16849 
  thrift_spec = (
16850 
    None, # 0
16851 
    (1, TType.I64, 'userId', None, None, ), # 1
16852 
    (2, TType.STRING, 'source', None, None, ), # 2
16853 
  )
16854 
 
16855 
  def __init__(self, userId=None, source=None,):
16856 
    self.userId = userId
16857 
    self.source = source
16858 
 
16859 
  def read(self, iprot):
16860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16862 
      return
16863 
    iprot.readStructBegin()
16864 
    while True:
16865 
      (fname, ftype, fid) = iprot.readFieldBegin()
16866 
      if ftype == TType.STOP:
16867 
        break
16868 
      if fid == 1:
16869 
        if ftype == TType.I64:
16870 
          self.userId = iprot.readI64();
16871 
        else:
16872 
          iprot.skip(ftype)
16873 
      elif fid == 2:
16874 
        if ftype == TType.STRING:
16875 
          self.source = iprot.readString();
16876 
        else:
16877 
          iprot.skip(ftype)
16878 
      else:
16879 
        iprot.skip(ftype)
16880 
      iprot.readFieldEnd()
16881 
    iprot.readStructEnd()
16882 
 
16883 
  def write(self, oprot):
16884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16886 
      return
16887 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16888 
    if self.userId is not None:
16889 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16890 
      oprot.writeI64(self.userId)
16891 
      oprot.writeFieldEnd()
16892 
    if self.source is not None:
16893 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16894 
      oprot.writeString(self.source)
16895 
      oprot.writeFieldEnd()
16896 
    oprot.writeFieldStop()
16897 
    oprot.writeStructEnd()
16898 
 
16899 
  def validate(self):
16900 
    return
16901 
 
16902 
 
16903 
  def __repr__(self):
16904 
    L = ['%s=%r' % (key, value)
16905 
      for key, value in self.__dict__.iteritems()]
16906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16907 
 
16908 
  def __eq__(self, other):
16909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16910 
 
16911 
  def __ne__(self, other):
16912 
    return not (self == other)
16913 
 
16914 
class getActiveAccessTokenForUser_result:
16915 
  """
16916 
  Attributes:
16917 
   - success
16918 
  """
16919 
 
16920 
  thrift_spec = (
16921 
    (0, TType.STRING, 'success', None, None, ), # 0
16922 
  )
16923 
 
16924 
  def __init__(self, success=None,):
16925 
    self.success = success
16926 
 
16927 
  def read(self, iprot):
16928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16930 
      return
16931 
    iprot.readStructBegin()
16932 
    while True:
16933 
      (fname, ftype, fid) = iprot.readFieldBegin()
16934 
      if ftype == TType.STOP:
16935 
        break
16936 
      if fid == 0:
16937 
        if ftype == TType.STRING:
16938 
          self.success = iprot.readString();
16939 
        else:
16940 
          iprot.skip(ftype)
16941 
      else:
16942 
        iprot.skip(ftype)
16943 
      iprot.readFieldEnd()
16944 
    iprot.readStructEnd()
16945 
 
16946 
  def write(self, oprot):
16947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16949 
      return
16950 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16951 
    if self.success is not None:
16952 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16953 
      oprot.writeString(self.success)
16954 
      oprot.writeFieldEnd()
16955 
    oprot.writeFieldStop()
16956 
    oprot.writeStructEnd()
16957 
 
16958 
  def validate(self):
16959 
    return
16960 
 
16961 
 
16962 
  def __repr__(self):
16963 
    L = ['%s=%r' % (key, value)
16964 
      for key, value in self.__dict__.iteritems()]
16965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16966 
 
16967 
  def __eq__(self, other):
16968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16969 
 
16970 
  def __ne__(self, other):
16971 
    return not (self == other)
16972 
 
16973 
class validateAccessToken_args:
16974 
  """
16975 
  Attributes:
16976 
   - accessToken
16977 
  """
16978 
 
16979 
  thrift_spec = (
16980 
    None, # 0
16981 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16982 
  )
16983 
 
16984 
  def __init__(self, accessToken=None,):
16985 
    self.accessToken = accessToken
16986 
 
16987 
  def read(self, iprot):
16988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16990 
      return
16991 
    iprot.readStructBegin()
16992 
    while True:
16993 
      (fname, ftype, fid) = iprot.readFieldBegin()
16994 
      if ftype == TType.STOP:
16995 
        break
16996 
      if fid == 1:
16997 
        if ftype == TType.STRING:
16998 
          self.accessToken = iprot.readString();
16999 
        else:
17000 
          iprot.skip(ftype)
17001 
      else:
17002 
        iprot.skip(ftype)
17003 
      iprot.readFieldEnd()
17004 
    iprot.readStructEnd()
17005 
 
17006 
  def write(self, oprot):
17007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17009 
      return
17010 
    oprot.writeStructBegin('validateAccessToken_args')
17011 
    if self.accessToken is not None:
17012 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
17013 
      oprot.writeString(self.accessToken)
17014 
      oprot.writeFieldEnd()
17015 
    oprot.writeFieldStop()
17016 
    oprot.writeStructEnd()
17017 
 
17018 
  def validate(self):
17019 
    return
17020 
 
17021 
 
17022 
  def __repr__(self):
17023 
    L = ['%s=%r' % (key, value)
17024 
      for key, value in self.__dict__.iteritems()]
17025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17026 
 
17027 
  def __eq__(self, other):
17028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17029 
 
17030 
  def __ne__(self, other):
17031 
    return not (self == other)
17032 
 
17033 
class validateAccessToken_result:
17034 
  """
17035 
  Attributes:
17036 
   - success
17037 
  """
17038 
 
17039 
  thrift_spec = (
17040 
    (0, TType.BOOL, 'success', None, None, ), # 0
17041 
  )
17042 
 
17043 
  def __init__(self, success=None,):
17044 
    self.success = success
17045 
 
17046 
  def read(self, iprot):
17047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17049 
      return
17050 
    iprot.readStructBegin()
17051 
    while True:
17052 
      (fname, ftype, fid) = iprot.readFieldBegin()
17053 
      if ftype == TType.STOP:
17054 
        break
17055 
      if fid == 0:
17056 
        if ftype == TType.BOOL:
17057 
          self.success = iprot.readBool();
17058 
        else:
17059 
          iprot.skip(ftype)
17060 
      else:
17061 
        iprot.skip(ftype)
17062 
      iprot.readFieldEnd()
17063 
    iprot.readStructEnd()
17064 
 
17065 
  def write(self, oprot):
17066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17068 
      return
17069 
    oprot.writeStructBegin('validateAccessToken_result')
17070 
    if self.success is not None:
17071 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17072 
      oprot.writeBool(self.success)
17073 
      oprot.writeFieldEnd()
17074 
    oprot.writeFieldStop()
17075 
    oprot.writeStructEnd()
17076 
 
17077 
  def validate(self):
17078 
    return
17079 
 
17080 
 
17081 
  def __repr__(self):
17082 
    L = ['%s=%r' % (key, value)
17083 
      for key, value in self.__dict__.iteritems()]
17084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17085 
 
17086 
  def __eq__(self, other):
17087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17088 
 
17089 
  def __ne__(self, other):
17090 
    return not (self == other)
17782 amit.gupta 17091 
 
17092 
class addItemsToCart_args:
17093 
  """
17094 
  Attributes:
17095 
   - cartId
17096 
   - itemQty
17097 
   - couponCode
17098 
  """
17099 
 
17100 
  thrift_spec = (
17101 
    None, # 0
17102 
    (1, TType.I64, 'cartId', None, None, ), # 1
17103 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
17104 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
17105 
  )
17106 
 
17107 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
17108 
    self.cartId = cartId
17109 
    self.itemQty = itemQty
17110 
    self.couponCode = couponCode
17111 
 
17112 
  def read(self, iprot):
17113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17115 
      return
17116 
    iprot.readStructBegin()
17117 
    while True:
17118 
      (fname, ftype, fid) = iprot.readFieldBegin()
17119 
      if ftype == TType.STOP:
17120 
        break
17121 
      if fid == 1:
17122 
        if ftype == TType.I64:
17123 
          self.cartId = iprot.readI64();
17124 
        else:
17125 
          iprot.skip(ftype)
17126 
      elif fid == 2:
17127 
        if ftype == TType.LIST:
17128 
          self.itemQty = []
17129 
          (_etype251, _size248) = iprot.readListBegin()
17130 
          for _i252 in xrange(_size248):
17131 
            _elem253 = ItemQuantity()
17132 
            _elem253.read(iprot)
17133 
            self.itemQty.append(_elem253)
17134 
          iprot.readListEnd()
17135 
        else:
17136 
          iprot.skip(ftype)
17137 
      elif fid == 3:
17138 
        if ftype == TType.STRING:
17139 
          self.couponCode = iprot.readString();
17140 
        else:
17141 
          iprot.skip(ftype)
17142 
      else:
17143 
        iprot.skip(ftype)
17144 
      iprot.readFieldEnd()
17145 
    iprot.readStructEnd()
17146 
 
17147 
  def write(self, oprot):
17148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17150 
      return
17151 
    oprot.writeStructBegin('addItemsToCart_args')
17152 
    if self.cartId is not None:
17153 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17154 
      oprot.writeI64(self.cartId)
17155 
      oprot.writeFieldEnd()
17156 
    if self.itemQty is not None:
17157 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
17158 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
17159 
      for iter254 in self.itemQty:
17160 
        iter254.write(oprot)
17161 
      oprot.writeListEnd()
17162 
      oprot.writeFieldEnd()
17163 
    if self.couponCode is not None:
17164 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
17165 
      oprot.writeString(self.couponCode)
17166 
      oprot.writeFieldEnd()
17167 
    oprot.writeFieldStop()
17168 
    oprot.writeStructEnd()
17169 
 
17170 
  def validate(self):
17171 
    return
17172 
 
17173 
 
17174 
  def __repr__(self):
17175 
    L = ['%s=%r' % (key, value)
17176 
      for key, value in self.__dict__.iteritems()]
17177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17178 
 
17179 
  def __eq__(self, other):
17180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17181 
 
17182 
  def __ne__(self, other):
17183 
    return not (self == other)
17184 
 
17185 
class addItemsToCart_result:
17186 
  """
17187 
  Attributes:
17188 
   - success
17189 
  """
17190 
 
17191 
  thrift_spec = (
17192 
    (0, TType.BOOL, 'success', None, None, ), # 0
17193 
  )
17194 
 
17195 
  def __init__(self, success=None,):
17196 
    self.success = success
17197 
 
17198 
  def read(self, iprot):
17199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17201 
      return
17202 
    iprot.readStructBegin()
17203 
    while True:
17204 
      (fname, ftype, fid) = iprot.readFieldBegin()
17205 
      if ftype == TType.STOP:
17206 
        break
17207 
      if fid == 0:
17208 
        if ftype == TType.BOOL:
17209 
          self.success = iprot.readBool();
17210 
        else:
17211 
          iprot.skip(ftype)
17212 
      else:
17213 
        iprot.skip(ftype)
17214 
      iprot.readFieldEnd()
17215 
    iprot.readStructEnd()
17216 
 
17217 
  def write(self, oprot):
17218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17220 
      return
17221 
    oprot.writeStructBegin('addItemsToCart_result')
17222 
    if self.success is not None:
17223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17224 
      oprot.writeBool(self.success)
17225 
      oprot.writeFieldEnd()
17226 
    oprot.writeFieldStop()
17227 
    oprot.writeStructEnd()
17228 
 
17229 
  def validate(self):
17230 
    return
17231 
 
17232 
 
17233 
  def __repr__(self):
17234 
    L = ['%s=%r' % (key, value)
17235 
      for key, value in self.__dict__.iteritems()]
17236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17237 
 
17238 
  def __eq__(self, other):
17239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17240 
 
17241 
  def __ne__(self, other):
17242 
    return not (self == other)
17243 
 
17244 
class validateCartNew_args:
17245 
  """
17246 
  Attributes:
17247 
   - cartId
17248 
   - pinCode
17249 
   - sourceId
17250 
  """
17251 
 
17252 
  thrift_spec = (
17253 
    None, # 0
17254 
    (1, TType.I64, 'cartId', None, None, ), # 1
17255 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
17256 
    (3, TType.I64, 'sourceId', None, None, ), # 3
17257 
  )
17258 
 
17259 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
17260 
    self.cartId = cartId
17261 
    self.pinCode = pinCode
17262 
    self.sourceId = sourceId
17263 
 
17264 
  def read(self, iprot):
17265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17267 
      return
17268 
    iprot.readStructBegin()
17269 
    while True:
17270 
      (fname, ftype, fid) = iprot.readFieldBegin()
17271 
      if ftype == TType.STOP:
17272 
        break
17273 
      if fid == 1:
17274 
        if ftype == TType.I64:
17275 
          self.cartId = iprot.readI64();
17276 
        else:
17277 
          iprot.skip(ftype)
17278 
      elif fid == 2:
17279 
        if ftype == TType.STRING:
17280 
          self.pinCode = iprot.readString();
17281 
        else:
17282 
          iprot.skip(ftype)
17283 
      elif fid == 3:
17284 
        if ftype == TType.I64:
17285 
          self.sourceId = iprot.readI64();
17286 
        else:
17287 
          iprot.skip(ftype)
17288 
      else:
17289 
        iprot.skip(ftype)
17290 
      iprot.readFieldEnd()
17291 
    iprot.readStructEnd()
17292 
 
17293 
  def write(self, oprot):
17294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17296 
      return
17297 
    oprot.writeStructBegin('validateCartNew_args')
17298 
    if self.cartId is not None:
17299 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17300 
      oprot.writeI64(self.cartId)
17301 
      oprot.writeFieldEnd()
17302 
    if self.pinCode is not None:
17303 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17304 
      oprot.writeString(self.pinCode)
17305 
      oprot.writeFieldEnd()
17306 
    if self.sourceId is not None:
17307 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17308 
      oprot.writeI64(self.sourceId)
17309 
      oprot.writeFieldEnd()
17310 
    oprot.writeFieldStop()
17311 
    oprot.writeStructEnd()
17312 
 
17313 
  def validate(self):
17314 
    return
17315 
 
17316 
 
17317 
  def __repr__(self):
17318 
    L = ['%s=%r' % (key, value)
17319 
      for key, value in self.__dict__.iteritems()]
17320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17321 
 
17322 
  def __eq__(self, other):
17323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17324 
 
17325 
  def __ne__(self, other):
17326 
    return not (self == other)
17327 
 
17328 
class validateCartNew_result:
17329 
  """
17330 
  Attributes:
17331 
   - success
17332 
  """
17333 
 
17334 
  thrift_spec = (
17335 
    (0, TType.STRING, 'success', None, None, ), # 0
17336 
  )
17337 
 
17338 
  def __init__(self, success=None,):
17339 
    self.success = success
17340 
 
17341 
  def read(self, iprot):
17342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17344 
      return
17345 
    iprot.readStructBegin()
17346 
    while True:
17347 
      (fname, ftype, fid) = iprot.readFieldBegin()
17348 
      if ftype == TType.STOP:
17349 
        break
17350 
      if fid == 0:
17351 
        if ftype == TType.STRING:
17352 
          self.success = iprot.readString();
17353 
        else:
17354 
          iprot.skip(ftype)
17355 
      else:
17356 
        iprot.skip(ftype)
17357 
      iprot.readFieldEnd()
17358 
    iprot.readStructEnd()
17359 
 
17360 
  def write(self, oprot):
17361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17363 
      return
17364 
    oprot.writeStructBegin('validateCartNew_result')
17365 
    if self.success is not None:
17366 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17367 
      oprot.writeString(self.success)
17368 
      oprot.writeFieldEnd()
17369 
    oprot.writeFieldStop()
17370 
    oprot.writeStructEnd()
17371 
 
17372 
  def validate(self):
17373 
    return
17374 
 
17375 
 
17376 
  def __repr__(self):
17377 
    L = ['%s=%r' % (key, value)
17378 
      for key, value in self.__dict__.iteritems()]
17379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17380 
 
17381 
  def __eq__(self, other):
17382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17383 
 
17384 
  def __ne__(self, other):
17385 
    return not (self == other)
18530 manish.sha 17386 
 
18644 manish.sha 17387 
class isAddressEditableForCounter_args:
18530 manish.sha 17388 
  """
17389 
  Attributes:
17390 
   - userId
17391 
  """
17392 
 
17393 
  thrift_spec = (
17394 
    None, # 0
17395 
    (1, TType.I64, 'userId', None, None, ), # 1
17396 
  )
17397 
 
17398 
  def __init__(self, userId=None,):
17399 
    self.userId = userId
17400 
 
17401 
  def read(self, iprot):
17402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17404 
      return
17405 
    iprot.readStructBegin()
17406 
    while True:
17407 
      (fname, ftype, fid) = iprot.readFieldBegin()
17408 
      if ftype == TType.STOP:
17409 
        break
17410 
      if fid == 1:
17411 
        if ftype == TType.I64:
17412 
          self.userId = iprot.readI64();
17413 
        else:
17414 
          iprot.skip(ftype)
17415 
      else:
17416 
        iprot.skip(ftype)
17417 
      iprot.readFieldEnd()
17418 
    iprot.readStructEnd()
17419 
 
17420 
  def write(self, oprot):
17421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17423 
      return
18644 manish.sha 17424 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17425 
    if self.userId is not None:
17426 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17427 
      oprot.writeI64(self.userId)
17428 
      oprot.writeFieldEnd()
17429 
    oprot.writeFieldStop()
17430 
    oprot.writeStructEnd()
17431 
 
17432 
  def validate(self):
17433 
    return
17434 
 
17435 
 
17436 
  def __repr__(self):
17437 
    L = ['%s=%r' % (key, value)
17438 
      for key, value in self.__dict__.iteritems()]
17439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17440 
 
17441 
  def __eq__(self, other):
17442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17443 
 
17444 
  def __ne__(self, other):
17445 
    return not (self == other)
17446 
 
18644 manish.sha 17447 
class isAddressEditableForCounter_result:
18530 manish.sha 17448 
  """
17449 
  Attributes:
17450 
   - success
17451 
  """
17452 
 
17453 
  thrift_spec = (
17454 
    (0, TType.BOOL, 'success', None, None, ), # 0
17455 
  )
17456 
 
17457 
  def __init__(self, success=None,):
17458 
    self.success = success
17459 
 
17460 
  def read(self, iprot):
17461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17463 
      return
17464 
    iprot.readStructBegin()
17465 
    while True:
17466 
      (fname, ftype, fid) = iprot.readFieldBegin()
17467 
      if ftype == TType.STOP:
17468 
        break
17469 
      if fid == 0:
17470 
        if ftype == TType.BOOL:
17471 
          self.success = iprot.readBool();
17472 
        else:
17473 
          iprot.skip(ftype)
17474 
      else:
17475 
        iprot.skip(ftype)
17476 
      iprot.readFieldEnd()
17477 
    iprot.readStructEnd()
17478 
 
17479 
  def write(self, oprot):
17480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17482 
      return
18644 manish.sha 17483 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17484 
    if self.success is not None:
17485 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17486 
      oprot.writeBool(self.success)
17487 
      oprot.writeFieldEnd()
17488 
    oprot.writeFieldStop()
17489 
    oprot.writeStructEnd()
17490 
 
17491 
  def validate(self):
17492 
    return
17493 
 
17494 
 
17495 
  def __repr__(self):
17496 
    L = ['%s=%r' % (key, value)
17497 
      for key, value in self.__dict__.iteritems()]
17498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17499 
 
17500 
  def __eq__(self, other):
17501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17502 
 
17503 
  def __ne__(self, other):
17504 
    return not (self == other)
17505 
 
17506 
class getBillingAddressForUser_args:
17507 
  """
17508 
  Attributes:
17509 
   - userId
17510 
  """
17511 
 
17512 
  thrift_spec = (
17513 
    None, # 0
17514 
    (1, TType.I64, 'userId', None, None, ), # 1
17515 
  )
17516 
 
17517 
  def __init__(self, userId=None,):
17518 
    self.userId = userId
17519 
 
17520 
  def read(self, iprot):
17521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17523 
      return
17524 
    iprot.readStructBegin()
17525 
    while True:
17526 
      (fname, ftype, fid) = iprot.readFieldBegin()
17527 
      if ftype == TType.STOP:
17528 
        break
17529 
      if fid == 1:
17530 
        if ftype == TType.I64:
17531 
          self.userId = iprot.readI64();
17532 
        else:
17533 
          iprot.skip(ftype)
17534 
      else:
17535 
        iprot.skip(ftype)
17536 
      iprot.readFieldEnd()
17537 
    iprot.readStructEnd()
17538 
 
17539 
  def write(self, oprot):
17540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17542 
      return
17543 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17544 
    if self.userId is not None:
17545 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17546 
      oprot.writeI64(self.userId)
17547 
      oprot.writeFieldEnd()
17548 
    oprot.writeFieldStop()
17549 
    oprot.writeStructEnd()
17550 
 
17551 
  def validate(self):
17552 
    return
17553 
 
17554 
 
17555 
  def __repr__(self):
17556 
    L = ['%s=%r' % (key, value)
17557 
      for key, value in self.__dict__.iteritems()]
17558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17559 
 
17560 
  def __eq__(self, other):
17561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17562 
 
17563 
  def __ne__(self, other):
17564 
    return not (self == other)
17565 
 
17566 
class getBillingAddressForUser_result:
17567 
  """
17568 
  Attributes:
17569 
   - success
17570 
  """
17571 
 
17572 
  thrift_spec = (
17573 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17574 
  )
17575 
 
17576 
  def __init__(self, success=None,):
17577 
    self.success = success
17578 
 
17579 
  def read(self, iprot):
17580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17582 
      return
17583 
    iprot.readStructBegin()
17584 
    while True:
17585 
      (fname, ftype, fid) = iprot.readFieldBegin()
17586 
      if ftype == TType.STOP:
17587 
        break
17588 
      if fid == 0:
17589 
        if ftype == TType.STRUCT:
17590 
          self.success = Address()
17591 
          self.success.read(iprot)
17592 
        else:
17593 
          iprot.skip(ftype)
17594 
      else:
17595 
        iprot.skip(ftype)
17596 
      iprot.readFieldEnd()
17597 
    iprot.readStructEnd()
17598 
 
17599 
  def write(self, oprot):
17600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17602 
      return
17603 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17604 
    if self.success is not None:
17605 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17606 
      self.success.write(oprot)
17607 
      oprot.writeFieldEnd()
17608 
    oprot.writeFieldStop()
17609 
    oprot.writeStructEnd()
17610 
 
17611 
  def validate(self):
17612 
    return
17613 
 
17614 
 
17615 
  def __repr__(self):
17616 
    L = ['%s=%r' % (key, value)
17617 
      for key, value in self.__dict__.iteritems()]
17618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17619 
 
17620 
  def __eq__(self, other):
17621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17622 
 
17623 
  def __ne__(self, other):
17624 
    return not (self == other)
18590 manish.sha 17625 
 
17626 
class isCreditorAssigned_args:
17627 
  """
17628 
  Attributes:
17629 
   - userId
17630 
  """
17631 
 
17632 
  thrift_spec = (
17633 
    None, # 0
17634 
    (1, TType.I64, 'userId', None, None, ), # 1
17635 
  )
17636 
 
17637 
  def __init__(self, userId=None,):
17638 
    self.userId = userId
17639 
 
17640 
  def read(self, iprot):
17641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17643 
      return
17644 
    iprot.readStructBegin()
17645 
    while True:
17646 
      (fname, ftype, fid) = iprot.readFieldBegin()
17647 
      if ftype == TType.STOP:
17648 
        break
17649 
      if fid == 1:
17650 
        if ftype == TType.I64:
17651 
          self.userId = iprot.readI64();
17652 
        else:
17653 
          iprot.skip(ftype)
17654 
      else:
17655 
        iprot.skip(ftype)
17656 
      iprot.readFieldEnd()
17657 
    iprot.readStructEnd()
17658 
 
17659 
  def write(self, oprot):
17660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17662 
      return
17663 
    oprot.writeStructBegin('isCreditorAssigned_args')
17664 
    if self.userId is not None:
17665 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17666 
      oprot.writeI64(self.userId)
17667 
      oprot.writeFieldEnd()
17668 
    oprot.writeFieldStop()
17669 
    oprot.writeStructEnd()
17670 
 
17671 
  def validate(self):
17672 
    return
17673 
 
17674 
 
17675 
  def __repr__(self):
17676 
    L = ['%s=%r' % (key, value)
17677 
      for key, value in self.__dict__.iteritems()]
17678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17679 
 
17680 
  def __eq__(self, other):
17681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17682 
 
17683 
  def __ne__(self, other):
17684 
    return not (self == other)
17685 
 
17686 
class isCreditorAssigned_result:
17687 
  """
17688 
  Attributes:
17689 
   - success
17690 
  """
17691 
 
17692 
  thrift_spec = (
17693 
    (0, TType.BOOL, 'success', None, None, ), # 0
17694 
  )
17695 
 
17696 
  def __init__(self, success=None,):
17697 
    self.success = success
17698 
 
17699 
  def read(self, iprot):
17700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17702 
      return
17703 
    iprot.readStructBegin()
17704 
    while True:
17705 
      (fname, ftype, fid) = iprot.readFieldBegin()
17706 
      if ftype == TType.STOP:
17707 
        break
17708 
      if fid == 0:
17709 
        if ftype == TType.BOOL:
17710 
          self.success = iprot.readBool();
17711 
        else:
17712 
          iprot.skip(ftype)
17713 
      else:
17714 
        iprot.skip(ftype)
17715 
      iprot.readFieldEnd()
17716 
    iprot.readStructEnd()
17717 
 
17718 
  def write(self, oprot):
17719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17721 
      return
17722 
    oprot.writeStructBegin('isCreditorAssigned_result')
17723 
    if self.success is not None:
17724 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17725 
      oprot.writeBool(self.success)
17726 
      oprot.writeFieldEnd()
17727 
    oprot.writeFieldStop()
17728 
    oprot.writeStructEnd()
17729 
 
17730 
  def validate(self):
17731 
    return
17732 
 
17733 
 
17734 
  def __repr__(self):
17735 
    L = ['%s=%r' % (key, value)
17736 
      for key, value in self.__dict__.iteritems()]
17737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17738 
 
17739 
  def __eq__(self, other):
17740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17741 
 
17742 
  def __ne__(self, other):
17743 
    return not (self == other)
18735 manish.sha 17744 
 
17745 
class isTaxInvoiceEnabledUser_args:
17746 
  """
17747 
  Attributes:
17748 
   - userId
17749 
  """
17750 
 
17751 
  thrift_spec = (
17752 
    None, # 0
17753 
    (1, TType.I64, 'userId', None, None, ), # 1
17754 
  )
17755 
 
17756 
  def __init__(self, userId=None,):
17757 
    self.userId = userId
17758 
 
17759 
  def read(self, iprot):
17760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17762 
      return
17763 
    iprot.readStructBegin()
17764 
    while True:
17765 
      (fname, ftype, fid) = iprot.readFieldBegin()
17766 
      if ftype == TType.STOP:
17767 
        break
17768 
      if fid == 1:
17769 
        if ftype == TType.I64:
17770 
          self.userId = iprot.readI64();
17771 
        else:
17772 
          iprot.skip(ftype)
17773 
      else:
17774 
        iprot.skip(ftype)
17775 
      iprot.readFieldEnd()
17776 
    iprot.readStructEnd()
17777 
 
17778 
  def write(self, oprot):
17779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17781 
      return
17782 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17783 
    if self.userId is not None:
17784 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17785 
      oprot.writeI64(self.userId)
17786 
      oprot.writeFieldEnd()
17787 
    oprot.writeFieldStop()
17788 
    oprot.writeStructEnd()
17789 
 
17790 
  def validate(self):
17791 
    return
17792 
 
17793 
 
17794 
  def __repr__(self):
17795 
    L = ['%s=%r' % (key, value)
17796 
      for key, value in self.__dict__.iteritems()]
17797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17798 
 
17799 
  def __eq__(self, other):
17800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17801 
 
17802 
  def __ne__(self, other):
17803 
    return not (self == other)
17804 
 
17805 
class isTaxInvoiceEnabledUser_result:
17806 
  """
17807 
  Attributes:
17808 
   - success
17809 
  """
17810 
 
17811 
  thrift_spec = (
17812 
    (0, TType.BOOL, 'success', None, None, ), # 0
17813 
  )
17814 
 
17815 
  def __init__(self, success=None,):
17816 
    self.success = success
17817 
 
17818 
  def read(self, iprot):
17819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17821 
      return
17822 
    iprot.readStructBegin()
17823 
    while True:
17824 
      (fname, ftype, fid) = iprot.readFieldBegin()
17825 
      if ftype == TType.STOP:
17826 
        break
17827 
      if fid == 0:
17828 
        if ftype == TType.BOOL:
17829 
          self.success = iprot.readBool();
17830 
        else:
17831 
          iprot.skip(ftype)
17832 
      else:
17833 
        iprot.skip(ftype)
17834 
      iprot.readFieldEnd()
17835 
    iprot.readStructEnd()
17836 
 
17837 
  def write(self, oprot):
17838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17840 
      return
17841 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17842 
    if self.success is not None:
17843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17844 
      oprot.writeBool(self.success)
17845 
      oprot.writeFieldEnd()
17846 
    oprot.writeFieldStop()
17847 
    oprot.writeStructEnd()
17848 
 
17849 
  def validate(self):
17850 
    return
17851 
 
17852 
 
17853 
  def __repr__(self):
17854 
    L = ['%s=%r' % (key, value)
17855 
      for key, value in self.__dict__.iteritems()]
17856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17857 
 
17858 
  def __eq__(self, other):
17859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17860 
 
17861 
  def __ne__(self, other):
17862 
    return not (self == other)
18764 kshitij.so 17863 
 
19182 amit.gupta 17864 
class taxInvoiceAvailable_args:
17865 
  """
17866 
  Attributes:
17867 
   - addressId
17868 
  """
17869 
 
17870 
  thrift_spec = (
17871 
    None, # 0
17872 
    (1, TType.I64, 'addressId', None, None, ), # 1
17873 
  )
17874 
 
17875 
  def __init__(self, addressId=None,):
17876 
    self.addressId = addressId
17877 
 
17878 
  def read(self, iprot):
17879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17881 
      return
17882 
    iprot.readStructBegin()
17883 
    while True:
17884 
      (fname, ftype, fid) = iprot.readFieldBegin()
17885 
      if ftype == TType.STOP:
17886 
        break
17887 
      if fid == 1:
17888 
        if ftype == TType.I64:
17889 
          self.addressId = iprot.readI64();
17890 
        else:
17891 
          iprot.skip(ftype)
17892 
      else:
17893 
        iprot.skip(ftype)
17894 
      iprot.readFieldEnd()
17895 
    iprot.readStructEnd()
17896 
 
17897 
  def write(self, oprot):
17898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17900 
      return
17901 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
17902 
    if self.addressId is not None:
17903 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
17904 
      oprot.writeI64(self.addressId)
17905 
      oprot.writeFieldEnd()
17906 
    oprot.writeFieldStop()
17907 
    oprot.writeStructEnd()
17908 
 
17909 
  def validate(self):
17910 
    return
17911 
 
17912 
 
17913 
  def __repr__(self):
17914 
    L = ['%s=%r' % (key, value)
17915 
      for key, value in self.__dict__.iteritems()]
17916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17917 
 
17918 
  def __eq__(self, other):
17919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17920 
 
17921 
  def __ne__(self, other):
17922 
    return not (self == other)
17923 
 
17924 
class taxInvoiceAvailable_result:
17925 
  """
17926 
  Attributes:
17927 
   - success
17928 
  """
17929 
 
17930 
  thrift_spec = (
17931 
    (0, TType.BOOL, 'success', None, None, ), # 0
17932 
  )
17933 
 
17934 
  def __init__(self, success=None,):
17935 
    self.success = success
17936 
 
17937 
  def read(self, iprot):
17938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17940 
      return
17941 
    iprot.readStructBegin()
17942 
    while True:
17943 
      (fname, ftype, fid) = iprot.readFieldBegin()
17944 
      if ftype == TType.STOP:
17945 
        break
17946 
      if fid == 0:
17947 
        if ftype == TType.BOOL:
17948 
          self.success = iprot.readBool();
17949 
        else:
17950 
          iprot.skip(ftype)
17951 
      else:
17952 
        iprot.skip(ftype)
17953 
      iprot.readFieldEnd()
17954 
    iprot.readStructEnd()
17955 
 
17956 
  def write(self, oprot):
17957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17959 
      return
17960 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
17961 
    if self.success is not None:
17962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17963 
      oprot.writeBool(self.success)
17964 
      oprot.writeFieldEnd()
17965 
    oprot.writeFieldStop()
17966 
    oprot.writeStructEnd()
17967 
 
17968 
  def validate(self):
17969 
    return
17970 
 
17971 
 
17972 
  def __repr__(self):
17973 
    L = ['%s=%r' % (key, value)
17974 
      for key, value in self.__dict__.iteritems()]
17975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17976 
 
17977 
  def __eq__(self, other):
17978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17979 
 
17980 
  def __ne__(self, other):
17981 
    return not (self == other)
17982 
 
18764 kshitij.so 17983 
class getCartByValue_args:
17984 
  """
17985 
  Attributes:
17986 
   - cartIds
17987 
  """
17988 
 
17989 
  thrift_spec = (
17990 
    None, # 0
17991 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17992 
  )
17993 
 
17994 
  def __init__(self, cartIds=None,):
17995 
    self.cartIds = cartIds
17996 
 
17997 
  def read(self, iprot):
17998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18000 
      return
18001 
    iprot.readStructBegin()
18002 
    while True:
18003 
      (fname, ftype, fid) = iprot.readFieldBegin()
18004 
      if ftype == TType.STOP:
18005 
        break
18006 
      if fid == 1:
18007 
        if ftype == TType.LIST:
18008 
          self.cartIds = []
18009 
          (_etype258, _size255) = iprot.readListBegin()
18010 
          for _i259 in xrange(_size255):
18011 
            _elem260 = iprot.readI64();
18012 
            self.cartIds.append(_elem260)
18013 
          iprot.readListEnd()
18014 
        else:
18015 
          iprot.skip(ftype)
18016 
      else:
18017 
        iprot.skip(ftype)
18018 
      iprot.readFieldEnd()
18019 
    iprot.readStructEnd()
18020 
 
18021 
  def write(self, oprot):
18022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18024 
      return
18025 
    oprot.writeStructBegin('getCartByValue_args')
18026 
    if self.cartIds is not None:
18027 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
18028 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
18029 
      for iter261 in self.cartIds:
18030 
        oprot.writeI64(iter261)
18031 
      oprot.writeListEnd()
18032 
      oprot.writeFieldEnd()
18033 
    oprot.writeFieldStop()
18034 
    oprot.writeStructEnd()
18035 
 
18036 
  def validate(self):
18037 
    return
18038 
 
18039 
 
18040 
  def __repr__(self):
18041 
    L = ['%s=%r' % (key, value)
18042 
      for key, value in self.__dict__.iteritems()]
18043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18044 
 
18045 
  def __eq__(self, other):
18046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18047 
 
18048 
  def __ne__(self, other):
18049 
    return not (self == other)
18050 
 
18051 
class getCartByValue_result:
18052 
  """
18053 
  Attributes:
18054 
   - success
18055 
  """
18056 
 
18057 
  thrift_spec = (
18058 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
18059 
  )
18060 
 
18061 
  def __init__(self, success=None,):
18062 
    self.success = success
18063 
 
18064 
  def read(self, iprot):
18065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18067 
      return
18068 
    iprot.readStructBegin()
18069 
    while True:
18070 
      (fname, ftype, fid) = iprot.readFieldBegin()
18071 
      if ftype == TType.STOP:
18072 
        break
18073 
      if fid == 0:
18074 
        if ftype == TType.MAP:
18075 
          self.success = {}
18076 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
18077 
          for _i266 in xrange(_size262):
18078 
            _key267 = iprot.readI64();
18079 
            _val268 = []
18080 
            (_etype272, _size269) = iprot.readListBegin()
18081 
            for _i273 in xrange(_size269):
18082 
              _elem274 = Line()
18083 
              _elem274.read(iprot)
18084 
              _val268.append(_elem274)
18085 
            iprot.readListEnd()
18086 
            self.success[_key267] = _val268
18087 
          iprot.readMapEnd()
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      else:
18091 
        iprot.skip(ftype)
18092 
      iprot.readFieldEnd()
18093 
    iprot.readStructEnd()
18094 
 
18095 
  def write(self, oprot):
18096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18098 
      return
18099 
    oprot.writeStructBegin('getCartByValue_result')
18100 
    if self.success is not None:
18101 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18102 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
18103 
      for kiter275,viter276 in self.success.items():
18104 
        oprot.writeI64(kiter275)
18105 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
18106 
        for iter277 in viter276:
18107 
          iter277.write(oprot)
18108 
        oprot.writeListEnd()
18109 
      oprot.writeMapEnd()
18110 
      oprot.writeFieldEnd()
18111 
    oprot.writeFieldStop()
18112 
    oprot.writeStructEnd()
18113 
 
18114 
  def validate(self):
18115 
    return
18116 
 
18117 
 
18118 
  def __repr__(self):
18119 
    L = ['%s=%r' % (key, value)
18120 
      for key, value in self.__dict__.iteritems()]
18121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18122 
 
18123 
  def __eq__(self, other):
18124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18125 
 
18126 
  def __ne__(self, other):
18127 
    return not (self == other)
19889 manas 18128 
 
18129 
class getCounterName_args:
18130 
  """
18131 
  Attributes:
18132 
   - userIds
18133 
  """
18134 
 
18135 
  thrift_spec = (
18136 
    None, # 0
18137 
    (1, TType.LIST, 'userIds', (TType.I64,None), None, ), # 1
18138 
  )
18139 
 
18140 
  def __init__(self, userIds=None,):
18141 
    self.userIds = userIds
18142 
 
18143 
  def read(self, iprot):
18144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18146 
      return
18147 
    iprot.readStructBegin()
18148 
    while True:
18149 
      (fname, ftype, fid) = iprot.readFieldBegin()
18150 
      if ftype == TType.STOP:
18151 
        break
18152 
      if fid == 1:
18153 
        if ftype == TType.LIST:
18154 
          self.userIds = []
18155 
          (_etype281, _size278) = iprot.readListBegin()
18156 
          for _i282 in xrange(_size278):
18157 
            _elem283 = iprot.readI64();
18158 
            self.userIds.append(_elem283)
18159 
          iprot.readListEnd()
18160 
        else:
18161 
          iprot.skip(ftype)
18162 
      else:
18163 
        iprot.skip(ftype)
18164 
      iprot.readFieldEnd()
18165 
    iprot.readStructEnd()
18166 
 
18167 
  def write(self, oprot):
18168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18170 
      return
18171 
    oprot.writeStructBegin('getCounterName_args')
18172 
    if self.userIds is not None:
18173 
      oprot.writeFieldBegin('userIds', TType.LIST, 1)
18174 
      oprot.writeListBegin(TType.I64, len(self.userIds))
18175 
      for iter284 in self.userIds:
18176 
        oprot.writeI64(iter284)
18177 
      oprot.writeListEnd()
18178 
      oprot.writeFieldEnd()
18179 
    oprot.writeFieldStop()
18180 
    oprot.writeStructEnd()
18181 
 
18182 
  def validate(self):
18183 
    return
18184 
 
18185 
 
18186 
  def __repr__(self):
18187 
    L = ['%s=%r' % (key, value)
18188 
      for key, value in self.__dict__.iteritems()]
18189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18190 
 
18191 
  def __eq__(self, other):
18192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18193 
 
18194 
  def __ne__(self, other):
18195 
    return not (self == other)
18196 
 
18197 
class getCounterName_result:
18198 
  """
18199 
  Attributes:
18200 
   - success
18201 
  """
18202 
 
18203 
  thrift_spec = (
18204 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18205 
  )
18206 
 
18207 
  def __init__(self, success=None,):
18208 
    self.success = success
18209 
 
18210 
  def read(self, iprot):
18211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18213 
      return
18214 
    iprot.readStructBegin()
18215 
    while True:
18216 
      (fname, ftype, fid) = iprot.readFieldBegin()
18217 
      if ftype == TType.STOP:
18218 
        break
18219 
      if fid == 0:
18220 
        if ftype == TType.MAP:
18221 
          self.success = {}
18222 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
18223 
          for _i289 in xrange(_size285):
18224 
            _key290 = iprot.readI64();
18225 
            _val291 = iprot.readString();
18226 
            self.success[_key290] = _val291
18227 
          iprot.readMapEnd()
18228 
        else:
18229 
          iprot.skip(ftype)
18230 
      else:
18231 
        iprot.skip(ftype)
18232 
      iprot.readFieldEnd()
18233 
    iprot.readStructEnd()
18234 
 
18235 
  def write(self, oprot):
18236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18238 
      return
18239 
    oprot.writeStructBegin('getCounterName_result')
18240 
    if self.success is not None:
18241 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18242 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
18243 
      for kiter292,viter293 in self.success.items():
18244 
        oprot.writeI64(kiter292)
18245 
        oprot.writeString(viter293)
18246 
      oprot.writeMapEnd()
18247 
      oprot.writeFieldEnd()
18248 
    oprot.writeFieldStop()
18249 
    oprot.writeStructEnd()
18250 
 
18251 
  def validate(self):
18252 
    return
18253 
 
18254 
 
18255 
  def __repr__(self):
18256 
    L = ['%s=%r' % (key, value)
18257 
      for key, value in self.__dict__.iteritems()]
18258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18259 
 
18260 
  def __eq__(self, other):
18261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18262 
 
18263 
  def __ne__(self, other):
18264 
    return not (self == other)
20873 kshitij.so 18265 
 
18266 
class setWalletAmountInCart_args:
18267 
  """
18268 
  Attributes:
18269 
   - cartId
18270 
   - wallet_amount
18271 
  """
18272 
 
18273 
  thrift_spec = (
18274 
    None, # 0
18275 
    (1, TType.I64, 'cartId', None, None, ), # 1
18276 
    (2, TType.DOUBLE, 'wallet_amount', None, None, ), # 2
18277 
  )
18278 
 
18279 
  def __init__(self, cartId=None, wallet_amount=None,):
18280 
    self.cartId = cartId
18281 
    self.wallet_amount = wallet_amount
18282 
 
18283 
  def read(self, iprot):
18284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18286 
      return
18287 
    iprot.readStructBegin()
18288 
    while True:
18289 
      (fname, ftype, fid) = iprot.readFieldBegin()
18290 
      if ftype == TType.STOP:
18291 
        break
18292 
      if fid == 1:
18293 
        if ftype == TType.I64:
18294 
          self.cartId = iprot.readI64();
18295 
        else:
18296 
          iprot.skip(ftype)
18297 
      elif fid == 2:
18298 
        if ftype == TType.DOUBLE:
18299 
          self.wallet_amount = iprot.readDouble();
18300 
        else:
18301 
          iprot.skip(ftype)
18302 
      else:
18303 
        iprot.skip(ftype)
18304 
      iprot.readFieldEnd()
18305 
    iprot.readStructEnd()
18306 
 
18307 
  def write(self, oprot):
18308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18310 
      return
18311 
    oprot.writeStructBegin('setWalletAmountInCart_args')
18312 
    if self.cartId is not None:
18313 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
18314 
      oprot.writeI64(self.cartId)
18315 
      oprot.writeFieldEnd()
18316 
    if self.wallet_amount is not None:
18317 
      oprot.writeFieldBegin('wallet_amount', TType.DOUBLE, 2)
18318 
      oprot.writeDouble(self.wallet_amount)
18319 
      oprot.writeFieldEnd()
18320 
    oprot.writeFieldStop()
18321 
    oprot.writeStructEnd()
18322 
 
18323 
  def validate(self):
18324 
    return
18325 
 
18326 
 
18327 
  def __repr__(self):
18328 
    L = ['%s=%r' % (key, value)
18329 
      for key, value in self.__dict__.iteritems()]
18330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18331 
 
18332 
  def __eq__(self, other):
18333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18334 
 
18335 
  def __ne__(self, other):
18336 
    return not (self == other)
18337 
 
18338 
class setWalletAmountInCart_result:
18339 
  """
18340 
  Attributes:
18341 
   - success
18342 
  """
18343 
 
18344 
  thrift_spec = (
18345 
    (0, TType.BOOL, 'success', None, None, ), # 0
18346 
  )
18347 
 
18348 
  def __init__(self, success=None,):
18349 
    self.success = success
18350 
 
18351 
  def read(self, iprot):
18352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18354 
      return
18355 
    iprot.readStructBegin()
18356 
    while True:
18357 
      (fname, ftype, fid) = iprot.readFieldBegin()
18358 
      if ftype == TType.STOP:
18359 
        break
18360 
      if fid == 0:
18361 
        if ftype == TType.BOOL:
18362 
          self.success = iprot.readBool();
18363 
        else:
18364 
          iprot.skip(ftype)
18365 
      else:
18366 
        iprot.skip(ftype)
18367 
      iprot.readFieldEnd()
18368 
    iprot.readStructEnd()
18369 
 
18370 
  def write(self, oprot):
18371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18373 
      return
18374 
    oprot.writeStructBegin('setWalletAmountInCart_result')
18375 
    if self.success is not None:
18376 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18377 
      oprot.writeBool(self.success)
18378 
      oprot.writeFieldEnd()
18379 
    oprot.writeFieldStop()
18380 
    oprot.writeStructEnd()
18381 
 
18382 
  def validate(self):
18383 
    return
18384 
 
18385 
 
18386 
  def __repr__(self):
18387 
    L = ['%s=%r' % (key, value)
18388 
      for key, value in self.__dict__.iteritems()]
18389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18390 
 
18391 
  def __eq__(self, other):
18392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18393 
 
18394 
  def __ne__(self, other):
18395 
    return not (self == other)