Subversion Repositories SmartDukaan

Rev

Rev 22364 | 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 
 
22364 ashik.ali 111 
  def updateCounter(self, counter):
112 
    """
113 
    Parameters:
114 
     - counter
115 
    """
116 
    pass
117 
 
94 ashish 118 
  def setUserAsLoggedIn(self, userId, timestamp):
119 
    """
120 
    Parameters:
121 
     - userId
122 
     - timestamp
123 
    """
124 
    pass
125 
 
126 
  def setUserAsLoggedOut(self, userid, timestamp):
127 
    """
128 
    Parameters:
129 
     - userid
130 
     - timestamp
131 
    """
132 
    pass
133 
 
504 rajveer 134 
  def setDefaultAddress(self, userid, addressId):
135 
    """
136 
    Parameters:
137 
     - userid
138 
     - addressId
139 
    """
140 
    pass
141 
 
594 rajveer 142 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 143 
    """
144 
    Parameters:
145 
     - userid
594 rajveer 146 
     - oldPassword
147 
     - newPassword
94 ashish 148 
    """
149 
    pass
150 
 
884 rajveer 151 
  def forgotPassword(self, email, newPassword):
581 rajveer 152 
    """
153 
    Parameters:
154 
     - email
884 rajveer 155 
     - newPassword
581 rajveer 156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getAllAddressesForUser(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
1894 vikas 166 
  def getAddressById(self, addressId):
167 
    """
168 
    Parameters:
169 
     - addressId
170 
    """
171 
    pass
172 
 
594 rajveer 173 
  def getDefaultAddressId(self, userId):
174 
    """
175 
    Parameters:
176 
     - userId
177 
    """
178 
    pass
179 
 
785 rajveer 180 
  def getDefaultPincode(self, userId):
181 
    """
182 
    Parameters:
183 
     - userId
184 
    """
185 
    pass
186 
 
1274 varun.gupt 187 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
188 
    """
189 
    Parameters:
190 
     - userId
191 
     - replyTo
192 
     - communicationType
193 
     - orderId
194 
     - airwaybillNo
195 
     - productName
196 
     - subject
197 
     - message
198 
    """
199 
    pass
200 
 
1590 varun.gupt 201 
  def getUserCommunicationById(self, id):
202 
    """
203 
    Parameters:
204 
     - id
205 
    """
206 
    pass
207 
 
208 
  def getUserCommunicationByUser(self, userId):
209 
    """
210 
    Parameters:
211 
     - userId
212 
    """
213 
    pass
214 
 
215 
  def getAllUserCommunications(self, ):
216 
    pass
217 
 
5407 amar.kumar 218 
  def removeUserCommunication(self, id):
219 
    """
220 
    Parameters:
221 
     - id
222 
    """
223 
    pass
224 
 
1859 vikas 225 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 226 
    """
227 
    Parameters:
228 
     - name
1859 vikas 229 
     - addedOn
1845 vikas 230 
    """
231 
    pass
232 
 
1899 vikas 233 
  def getAllMasterAffiliates(self, ):
234 
    pass
235 
 
1845 vikas 236 
  def getMasterAffiliateById(self, id):
237 
    """
238 
    Parameters:
239 
     - id
240 
    """
241 
    pass
242 
 
243 
  def getMasterAffiliateByName(self, name):
244 
    """
245 
    Parameters:
246 
     - name
247 
    """
248 
    pass
249 
 
1859 vikas 250 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 251 
    """
252 
    Parameters:
253 
     - name
254 
     - url
255 
     - masterAffiliateId
1859 vikas 256 
     - addedOn
1845 vikas 257 
    """
258 
    pass
259 
 
260 
  def getAffiliateById(self, id):
261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
267 
  def getAffiliateByName(self, name):
268 
    """
269 
    Parameters:
270 
     - name
271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def getTrackerById(self, id):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - id
278 
    """
279 
    pass
280 
 
1996 vikas 281 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 282 
    """
283 
    Parameters:
1996 vikas 284 
     - id
1845 vikas 285 
    """
286 
    pass
287 
 
1996 vikas 288 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 289 
    """
290 
    Parameters:
291 
     - affiliateId
292 
     - userId
293 
     - event
294 
     - url
295 
     - data
1859 vikas 296 
     - addedOn
1845 vikas 297 
    """
298 
    pass
299 
 
300 
  def getTrackLogById(self, id):
301 
    """
302 
    Parameters:
303 
     - id
304 
    """
305 
    pass
306 
 
3293 vikas 307 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 308 
    """
309 
    Parameters:
1996 vikas 310 
     - affiliateId
3293 vikas 311 
     - startDate
312 
     - endDate
1845 vikas 313 
    """
314 
    pass
315 
 
316 
  def getTrackLogsByUser(self, userId):
317 
    """
318 
    Parameters:
319 
     - userId
320 
    """
321 
    pass
322 
 
1996 vikas 323 
  def getTrackLogs(self, userId, event, url):
1845 vikas 324 
    """
325 
    Parameters:
326 
     - userId
327 
     - event
328 
     - url
329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCurrentCart(self, userId):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - userId
94 ashish 336 
    """
337 
    pass
338 
 
559 chandransh 339 
  def getCart(self, cartId):
94 ashish 340 
    """
341 
    Parameters:
559 chandransh 342 
     - cartId
94 ashish 343 
    """
344 
    pass
345 
 
559 chandransh 346 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 347 
    """
348 
    Parameters:
559 chandransh 349 
     - from_time
350 
     - to_time
351 
     - status
94 ashish 352 
    """
353 
    pass
354 
 
3557 rajveer 355 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 356 
    """
357 
    Parameters:
559 chandransh 358 
     - cartId
359 
     - itemId
360 
     - quantity
3557 rajveer 361 
     - sourceId
130 ashish 362 
    """
363 
    pass
364 
 
559 chandransh 365 
  def deleteItemFromCart(self, cartId, itemId):
366 
    """
367 
    Parameters:
368 
     - cartId
369 
     - itemId
370 
    """
371 
    pass
130 ashish 372 
 
559 chandransh 373 
  def addAddressToCart(self, cartId, addressId):
374 
    """
375 
    Parameters:
376 
     - cartId
377 
     - addressId
378 
    """
379 
    pass
380 
 
5553 rajveer 381 
  def addStoreToCart(self, cartId, storeId):
382 
    """
383 
    Parameters:
384 
     - cartId
385 
     - storeId
386 
    """
387 
    pass
388 
 
6922 anupam.sin 389 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 390 
    """
391 
    Parameters:
6922 anupam.sin 392 
     - cart
1976 varun.gupt 393 
     - couponCode
394 
    """
395 
    pass
396 
 
397 
  def removeCoupon(self, cartId):
398 
    """
399 
    Parameters:
400 
     - cartId
401 
    """
402 
    pass
403 
 
3554 varun.gupt 404 
  def deleteDiscountsFromCart(self, cartId):
405 
    """
406 
    Deletes all the discounts associated with the cart
407 
 
408 
    Parameters:
409 
     - cartId
410 
    """
411 
    pass
412 
 
413 
  def saveDiscounts(self, discounts):
414 
    """
415 
    Accepts a list of thrift objects of Discount type and saves them
416 
 
417 
    Parameters:
418 
     - discounts
419 
    """
420 
    pass
421 
 
21454 amit.gupta 422 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 423 
    """
690 chandransh 424 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 425 
 
559 chandransh 426 
    Parameters:
427 
     - cartId
2815 vikas 428 
     - sessionSource
429 
     - sessionStartTime
3858 vikas 430 
     - firstSource
431 
     - firstSourceTime
5326 rajveer 432 
     - userId
6389 rajveer 433 
     - schemeId
11526 amit.gupta 434 
     - orderSource
21454 amit.gupta 435 
     - selfPickup
559 chandransh 436 
    """
437 
    pass
438 
 
3557 rajveer 439 
  def validateCart(self, cartId, sourceId):
559 chandransh 440 
    """
690 chandransh 441 
    Validates that:
442 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 443 
    2. All of the lines in the cart are active items.
690 chandransh 444 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 445 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 446 
 
559 chandransh 447 
    Parameters:
448 
     - cartId
3557 rajveer 449 
     - sourceId
559 chandransh 450 
    """
451 
    pass
452 
 
11980 amit.gupta 453 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
454 
    """
455 
    Validates that:
456 
    1. The checkout timestamp is greater than the updatedOn timestamp.
457 
    2. All of the lines in the cart are active items.
458 
    3. The estimate for any of the lines in cart doesn't change.
459 
    If all three are true, returns empty string; else returns appropriate message.
460 
 
461 
    Parameters:
462 
     - cartId
463 
     - sourceId
464 
     - dealCoupon
465 
    """
466 
    pass
467 
 
690 chandransh 468 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 469 
    """
690 chandransh 470 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 471 
 
575 chandransh 472 
    Parameters:
690 chandransh 473 
     - fromCartId
474 
     - toCartId
475 
    """
476 
    pass
477 
 
478 
  def checkOut(self, cartId):
479 
    """
480 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 481 
 
690 chandransh 482 
    Parameters:
575 chandransh 483 
     - cartId
484 
    """
485 
    pass
486 
 
690 chandransh 487 
  def resetCart(self, cartId, items):
559 chandransh 488 
    """
690 chandransh 489 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
490 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 491 
 
559 chandransh 492 
    Parameters:
690 chandransh 493 
     - cartId
494 
     - items
559 chandransh 495 
    """
496 
    pass
497 
 
2981 rajveer 498 
  def getUserCount(self, userType):
559 chandransh 499 
    """
2981 rajveer 500 
    Returns number of registered users.
501 
    If userType = null, then it returns count of all users, including anonymous
502 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
503 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 504 
 
559 chandransh 505 
    Parameters:
2981 rajveer 506 
     - userType
559 chandransh 507 
    """
508 
    pass
509 
 
2981 rajveer 510 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 511 
    """
2981 rajveer 512 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
513 
    If any of startDate or endDate is -1, then that filter is ignored.
514 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 515 
 
516 
 
559 chandransh 517 
    Parameters:
2981 rajveer 518 
     - userType
519 
     - startDate
520 
     - endDate
559 chandransh 521 
    """
522 
    pass
523 
 
2981 rajveer 524 
  def getMyResearchItems(self, userId):
559 chandransh 525 
    """
2981 rajveer 526 
    Returns list of item ids in myresearch for the user
3431 rajveer 527 
 
559 chandransh 528 
    Parameters:
529 
     - userId
530 
    """
531 
    pass
532 
 
2981 rajveer 533 
  def updateMyResearch(self, userId, itemId):
559 chandransh 534 
    """
2981 rajveer 535 
    add item to my research for a user
3431 rajveer 536 
 
559 chandransh 537 
    Parameters:
2981 rajveer 538 
     - userId
539 
     - itemId
559 chandransh 540 
    """
541 
    pass
542 
 
2981 rajveer 543 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 544 
    """
2981 rajveer 545 
    delete item from my research for a user
3431 rajveer 546 
 
1596 ankur.sing 547 
    Parameters:
2981 rajveer 548 
     - userId
549 
     - itemId
1596 ankur.sing 550 
    """
551 
    pass
559 chandransh 552 
 
2981 rajveer 553 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 554 
    """
2981 rajveer 555 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 556 
 
1673 ankur.sing 557 
    Parameters:
2981 rajveer 558 
     - userId
1673 ankur.sing 559 
    """
560 
    pass
1596 ankur.sing 561 
 
2981 rajveer 562 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 563 
    """
2981 rajveer 564 
    add item to browse history for a user
3431 rajveer 565 
 
2642 varun.gupt 566 
    Parameters:
2981 rajveer 567 
     - userId
568 
     - itemId
2642 varun.gupt 569 
    """
570 
    pass
1673 ankur.sing 571 
 
3385 varun.gupt 572 
  def getCartsWithCouponCount(self, couponCode):
573 
    """
574 
    Returns count of Carts with given coupon applied
3431 rajveer 575 
 
3385 varun.gupt 576 
    Parameters:
577 
     - couponCode
578 
    """
579 
    pass
2642 varun.gupt 580 
 
3499 mandeep.dh 581 
  def increaseTrustLevel(self, userId, trustLevelDelta):
582 
    """
583 
    Updates COD trust level of a user
3385 varun.gupt 584 
 
3499 mandeep.dh 585 
    Parameters:
586 
     - userId
587 
     - trustLevelDelta
588 
    """
589 
    pass
590 
 
5407 amar.kumar 591 
  def getTrustLevel(self, userId):
592 
    """
593 
    Get trust level of a user
594 
 
595 
    Parameters:
596 
     - userId
597 
    """
598 
    pass
599 
 
4668 varun.gupt 600 
  def showCODOption(self, cartId, sourceId, pincode):
601 
    """
602 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 603 
 
4668 varun.gupt 604 
    Parameters:
605 
     - cartId
606 
     - sourceId
607 
     - pincode
608 
    """
609 
    pass
610 
 
5623 anupam.sin 611 
  def getUserEmails(self, startDate, endDate):
612 
    """
613 
    Get email addresses for users activated within a given date range
4668 varun.gupt 614 
 
5623 anupam.sin 615 
    Parameters:
616 
     - startDate
617 
     - endDate
618 
    """
619 
    pass
620 
 
9299 kshitij.so 621 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 622 
    """
623 
    Mark a cart lineitem as insured. Returns true/false.
624 
 
625 
    Parameters:
626 
     - itemId
627 
     - cartId
628 
     - toInsure
9299 kshitij.so 629 
     - insurerType
6903 anupam.sin 630 
    """
631 
    pass
632 
 
633 
  def cancelInsurance(self, cartId):
634 
    """
635 
    Cancel insurance for all items in the cart
636 
 
637 
    Parameters:
638 
     - cartId
639 
    """
640 
    pass
641 
 
642 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
643 
    """
644 
    Stores insurance specific details like date of birth and guardianName
645 
 
646 
    Parameters:
647 
     - addressId
648 
     - dob
649 
     - guardianName
650 
    """
651 
    pass
652 
 
653 
  def isInsuranceDetailPresent(self, addressId):
654 
    """
655 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
656 
 
657 
    Parameters:
658 
     - addressId
659 
    """
660 
    pass
661 
 
9791 rajveer 662 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 663 
    """
9791 rajveer 664 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 665 
 
6821 amar.kumar 666 
    Parameters:
667 
     - startDate
668 
     - endDate
669 
    """
670 
    pass
671 
 
11980 amit.gupta 672 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 673 
    """
674 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 675 
 
11592 amit.gupta 676 
    Parameters:
677 
     - cartId
678 
     - sourceId
11980 amit.gupta 679 
     - dealerCoupon
11592 amit.gupta 680 
    """
681 
    pass
682 
 
11679 vikram.rag 683 
  def isPrivateDealUser(self, userId):
684 
    """
685 
    Parameters:
686 
     - userId
687 
    """
688 
    pass
11592 amit.gupta 689 
 
11890 kshitij.so 690 
  def addPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
11679 vikram.rag 696 
 
11890 kshitij.so 697 
  def changePrivateDealUserStatus(self, userId, isActive):
698 
    """
699 
    Parameters:
700 
     - userId
701 
     - isActive
702 
    """
703 
    pass
704 
 
705 
  def getPrivateDealUser(self, userId):
706 
    """
707 
    Parameters:
708 
     - userId
709 
    """
710 
    pass
711 
 
12696 amit.gupta 712 
  def registerCounter(self, counter, userId):
713 
    """
714 
    Parameters:
715 
     - counter
716 
     - userId
717 
    """
718 
    pass
11890 kshitij.so 719 
 
12722 amit.gupta 720 
  def searchCounter(self, type1, searchString):
721 
    """
722 
    Parameters:
723 
     - type1
724 
     - searchString
725 
    """
726 
    pass
12696 amit.gupta 727 
 
18977 amit.gupta 728 
  def getCounterByUserId(self, userId):
729 
    """
730 
    Parameters:
731 
     - userId
732 
    """
733 
    pass
734 
 
12722 amit.gupta 735 
  def getAllUsersByCounter(self, counterId):
736 
    """
737 
    Parameters:
738 
     - counterId
739 
    """
740 
    pass
741 
 
15251 manish.sha 742 
  def getActiveAccessTokenForUser(self, userId, source):
743 
    """
744 
    Parameters:
745 
     - userId
746 
     - source
747 
    """
748 
    pass
12722 amit.gupta 749 
 
15251 manish.sha 750 
  def validateAccessToken(self, accessToken):
751 
    """
752 
    Parameters:
753 
     - accessToken
754 
    """
755 
    pass
756 
 
17782 amit.gupta 757 
  def addItemsToCart(self, cartId, itemQty, couponCode):
758 
    """
759 
    Parameters:
760 
     - cartId
761 
     - itemQty
762 
     - couponCode
763 
    """
764 
    pass
15251 manish.sha 765 
 
17782 amit.gupta 766 
  def validateCartNew(self, cartId, pinCode, sourceId):
767 
    """
768 
    Parameters:
769 
     - cartId
770 
     - pinCode
771 
     - sourceId
772 
    """
773 
    pass
774 
 
18644 manish.sha 775 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 776 
    """
777 
    Parameters:
778 
     - userId
779 
    """
780 
    pass
17782 amit.gupta 781 
 
18530 manish.sha 782 
  def getBillingAddressForUser(self, userId):
783 
    """
784 
    Parameters:
785 
     - userId
786 
    """
787 
    pass
788 
 
18590 manish.sha 789 
  def isCreditorAssigned(self, userId):
790 
    """
791 
    Parameters:
792 
     - userId
793 
    """
794 
    pass
18530 manish.sha 795 
 
18735 manish.sha 796 
  def isTaxInvoiceEnabledUser(self, userId):
797 
    """
798 
    Parameters:
799 
     - userId
800 
    """
801 
    pass
18590 manish.sha 802 
 
19182 amit.gupta 803 
  def taxInvoiceAvailable(self, addressId):
804 
    """
805 
    Parameters:
806 
     - addressId
807 
    """
808 
    pass
809 
 
18764 kshitij.so 810 
  def getCartByValue(self, cartIds):
811 
    """
812 
    Parameters:
813 
     - cartIds
814 
    """
815 
    pass
18735 manish.sha 816 
 
19889 manas 817 
  def getCounterName(self, userIds):
818 
    """
819 
    Parameters:
820 
     - userIds
821 
    """
822 
    pass
18764 kshitij.so 823 
 
20873 kshitij.so 824 
  def setWalletAmountInCart(self, cartId, wallet_amount):
825 
    """
826 
    Parameters:
827 
     - cartId
828 
     - wallet_amount
829 
    """
830 
    pass
19889 manas 831 
 
22452 amit.gupta 832 
  def addItemPricingToCart(self, cartId, itemPriceQuantityList):
833 
    """
834 
    Parameters:
835 
     - cartId
836 
     - itemPriceQuantityList
837 
    """
838 
    pass
20873 kshitij.so 839 
 
22452 amit.gupta 840 
 
3376 rajveer 841 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 842 
  """
843 
  service
844 
  """
845 
  def __init__(self, iprot, oprot=None):
3376 rajveer 846 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 847 
 
559 chandransh 848 
  def createAnonymousUser(self, jsessionId):
94 ashish 849 
    """
850 
    Parameters:
559 chandransh 851 
     - jsessionId
94 ashish 852 
    """
559 chandransh 853 
    self.send_createAnonymousUser(jsessionId)
854 
    return self.recv_createAnonymousUser()
94 ashish 855 
 
559 chandransh 856 
  def send_createAnonymousUser(self, jsessionId):
857 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
858 
    args = createAnonymousUser_args()
859 
    args.jsessionId = jsessionId
94 ashish 860 
    args.write(self._oprot)
861 
    self._oprot.writeMessageEnd()
862 
    self._oprot.trans.flush()
863 
 
559 chandransh 864 
  def recv_createAnonymousUser(self, ):
94 ashish 865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
866 
    if mtype == TMessageType.EXCEPTION:
867 
      x = TApplicationException()
868 
      x.read(self._iprot)
869 
      self._iprot.readMessageEnd()
870 
      raise x
559 chandransh 871 
    result = createAnonymousUser_result()
94 ashish 872 
    result.read(self._iprot)
873 
    self._iprot.readMessageEnd()
3431 rajveer 874 
    if result.success is not None:
94 ashish 875 
      return result.success
3431 rajveer 876 
    if result.ucex is not None:
559 chandransh 877 
      raise result.ucex
878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 879 
 
559 chandransh 880 
  def getUserById(self, userId):
94 ashish 881 
    """
882 
    Parameters:
883 
     - userId
884 
    """
559 chandransh 885 
    self.send_getUserById(userId)
886 
    return self.recv_getUserById()
94 ashish 887 
 
559 chandransh 888 
  def send_getUserById(self, userId):
889 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
890 
    args = getUserById_args()
94 ashish 891 
    args.userId = userId
892 
    args.write(self._oprot)
893 
    self._oprot.writeMessageEnd()
894 
    self._oprot.trans.flush()
895 
 
559 chandransh 896 
  def recv_getUserById(self, ):
94 ashish 897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
898 
    if mtype == TMessageType.EXCEPTION:
899 
      x = TApplicationException()
900 
      x.read(self._iprot)
901 
      self._iprot.readMessageEnd()
902 
      raise x
559 chandransh 903 
    result = getUserById_result()
94 ashish 904 
    result.read(self._iprot)
905 
    self._iprot.readMessageEnd()
3431 rajveer 906 
    if result.success is not None:
94 ashish 907 
      return result.success
3431 rajveer 908 
    if result.ucex is not None:
559 chandransh 909 
      raise result.ucex
910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 911 
 
5326 rajveer 912 
  def getUserByCartId(self, cartId):
913 
    """
914 
    Parameters:
915 
     - cartId
916 
    """
917 
    self.send_getUserByCartId(cartId)
918 
    return self.recv_getUserByCartId()
919 
 
920 
  def send_getUserByCartId(self, cartId):
921 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
922 
    args = getUserByCartId_args()
923 
    args.cartId = cartId
924 
    args.write(self._oprot)
925 
    self._oprot.writeMessageEnd()
926 
    self._oprot.trans.flush()
927 
 
928 
  def recv_getUserByCartId(self, ):
929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
930 
    if mtype == TMessageType.EXCEPTION:
931 
      x = TApplicationException()
932 
      x.read(self._iprot)
933 
      self._iprot.readMessageEnd()
934 
      raise x
935 
    result = getUserByCartId_result()
936 
    result.read(self._iprot)
937 
    self._iprot.readMessageEnd()
938 
    if result.success is not None:
939 
      return result.success
940 
    if result.ucex is not None:
941 
      raise result.ucex
942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
943 
 
1491 vikas 944 
  def getUserByEmail(self, email):
945 
    """
946 
    Parameters:
947 
     - email
948 
    """
949 
    self.send_getUserByEmail(email)
950 
    return self.recv_getUserByEmail()
951 
 
952 
  def send_getUserByEmail(self, email):
953 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
954 
    args = getUserByEmail_args()
955 
    args.email = email
956 
    args.write(self._oprot)
957 
    self._oprot.writeMessageEnd()
958 
    self._oprot.trans.flush()
959 
 
960 
  def recv_getUserByEmail(self, ):
961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
962 
    if mtype == TMessageType.EXCEPTION:
963 
      x = TApplicationException()
964 
      x.read(self._iprot)
965 
      self._iprot.readMessageEnd()
966 
      raise x
967 
    result = getUserByEmail_result()
968 
    result.read(self._iprot)
969 
    self._iprot.readMessageEnd()
3431 rajveer 970 
    if result.success is not None:
1491 vikas 971 
      return result.success
3431 rajveer 972 
    if result.ucex is not None:
1491 vikas 973 
      raise result.ucex
974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
975 
 
3032 mandeep.dh 976 
  def getUserByMobileNumber(self, mobileNumber):
977 
    """
978 
    Parameters:
979 
     - mobileNumber
980 
    """
981 
    self.send_getUserByMobileNumber(mobileNumber)
982 
    return self.recv_getUserByMobileNumber()
983 
 
984 
  def send_getUserByMobileNumber(self, mobileNumber):
985 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
986 
    args = getUserByMobileNumber_args()
987 
    args.mobileNumber = mobileNumber
988 
    args.write(self._oprot)
989 
    self._oprot.writeMessageEnd()
990 
    self._oprot.trans.flush()
991 
 
992 
  def recv_getUserByMobileNumber(self, ):
993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
994 
    if mtype == TMessageType.EXCEPTION:
995 
      x = TApplicationException()
996 
      x.read(self._iprot)
997 
      self._iprot.readMessageEnd()
998 
      raise x
999 
    result = getUserByMobileNumber_result()
1000 
    result.read(self._iprot)
1001 
    self._iprot.readMessageEnd()
3431 rajveer 1002 
    if result.success is not None:
3032 mandeep.dh 1003 
      return result.success
3431 rajveer 1004 
    if result.ucex is not None:
3032 mandeep.dh 1005 
      raise result.ucex
1006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
1007 
 
559 chandransh 1008 
  def createUser(self, user):
94 ashish 1009 
    """
1010 
    Parameters:
559 chandransh 1011 
     - user
94 ashish 1012 
    """
559 chandransh 1013 
    self.send_createUser(user)
1014 
    return self.recv_createUser()
94 ashish 1015 
 
559 chandransh 1016 
  def send_createUser(self, user):
1017 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
1018 
    args = createUser_args()
1019 
    args.user = user
94 ashish 1020 
    args.write(self._oprot)
1021 
    self._oprot.writeMessageEnd()
1022 
    self._oprot.trans.flush()
1023 
 
559 chandransh 1024 
  def recv_createUser(self, ):
94 ashish 1025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1026 
    if mtype == TMessageType.EXCEPTION:
1027 
      x = TApplicationException()
1028 
      x.read(self._iprot)
1029 
      self._iprot.readMessageEnd()
1030 
      raise x
559 chandransh 1031 
    result = createUser_result()
94 ashish 1032 
    result.read(self._iprot)
1033 
    self._iprot.readMessageEnd()
3431 rajveer 1034 
    if result.success is not None:
94 ashish 1035 
      return result.success
3431 rajveer 1036 
    if result.ucex is not None:
559 chandransh 1037 
      raise result.ucex
1038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1039 
 
559 chandransh 1040 
  def updateUser(self, user):
94 ashish 1041 
    """
1042 
    Parameters:
559 chandransh 1043 
     - user
94 ashish 1044 
    """
559 chandransh 1045 
    self.send_updateUser(user)
1046 
    return self.recv_updateUser()
94 ashish 1047 
 
559 chandransh 1048 
  def send_updateUser(self, user):
1049 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1050 
    args = updateUser_args()
1051 
    args.user = user
94 ashish 1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
559 chandransh 1056 
  def recv_updateUser(self, ):
94 ashish 1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
559 chandransh 1063 
    result = updateUser_result()
94 ashish 1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
3431 rajveer 1066 
    if result.success is not None:
94 ashish 1067 
      return result.success
3431 rajveer 1068 
    if result.ucex is not None:
559 chandransh 1069 
      raise result.ucex
1070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1071 
 
559 chandransh 1072 
  def authenticateUser(self, email, password):
94 ashish 1073 
    """
1074 
    Parameters:
1075 
     - email
1076 
     - password
1077 
    """
559 chandransh 1078 
    self.send_authenticateUser(email, password)
122 ashish 1079 
    return self.recv_authenticateUser()
1080 
 
559 chandransh 1081 
  def send_authenticateUser(self, email, password):
122 ashish 1082 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1083 
    args = authenticateUser_args()
559 chandransh 1084 
    args.email = email
122 ashish 1085 
    args.password = password
1086 
    args.write(self._oprot)
1087 
    self._oprot.writeMessageEnd()
1088 
    self._oprot.trans.flush()
1089 
 
1090 
  def recv_authenticateUser(self, ):
1091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1092 
    if mtype == TMessageType.EXCEPTION:
1093 
      x = TApplicationException()
1094 
      x.read(self._iprot)
1095 
      self._iprot.readMessageEnd()
1096 
      raise x
1097 
    result = authenticateUser_result()
1098 
    result.read(self._iprot)
1099 
    self._iprot.readMessageEnd()
3431 rajveer 1100 
    if result.success is not None:
122 ashish 1101 
      return result.success
3431 rajveer 1102 
    if result.auex is not None:
559 chandransh 1103 
      raise result.auex
122 ashish 1104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1105 
 
94 ashish 1106 
  def userExists(self, email):
1107 
    """
1108 
    Parameters:
1109 
     - email
1110 
    """
1111 
    self.send_userExists(email)
1112 
    return self.recv_userExists()
1113 
 
1114 
  def send_userExists(self, email):
1115 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1116 
    args = userExists_args()
1117 
    args.email = email
1118 
    args.write(self._oprot)
1119 
    self._oprot.writeMessageEnd()
1120 
    self._oprot.trans.flush()
1121 
 
1122 
  def recv_userExists(self, ):
1123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1124 
    if mtype == TMessageType.EXCEPTION:
1125 
      x = TApplicationException()
1126 
      x.read(self._iprot)
1127 
      self._iprot.readMessageEnd()
1128 
      raise x
1129 
    result = userExists_result()
1130 
    result.read(self._iprot)
1131 
    self._iprot.readMessageEnd()
3431 rajveer 1132 
    if result.success is not None:
94 ashish 1133 
      return result.success
3431 rajveer 1134 
    if result.ucx is not None:
94 ashish 1135 
      raise result.ucx
1136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1137 
 
567 rajveer 1138 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1139 
    """
1140 
    Parameters:
1141 
     - userId
1142 
     - address
513 rajveer 1143 
     - setDefault
94 ashish 1144 
    """
567 rajveer 1145 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1146 
    return self.recv_addAddressForUser()
1147 
 
567 rajveer 1148 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1149 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1150 
    args = addAddressForUser_args()
559 chandransh 1151 
    args.userId = userId
94 ashish 1152 
    args.address = address
513 rajveer 1153 
    args.setDefault = setDefault
94 ashish 1154 
    args.write(self._oprot)
1155 
    self._oprot.writeMessageEnd()
1156 
    self._oprot.trans.flush()
1157 
 
1158 
  def recv_addAddressForUser(self, ):
1159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1160 
    if mtype == TMessageType.EXCEPTION:
1161 
      x = TApplicationException()
1162 
      x.read(self._iprot)
1163 
      self._iprot.readMessageEnd()
1164 
      raise x
1165 
    result = addAddressForUser_result()
1166 
    result.read(self._iprot)
1167 
    self._iprot.readMessageEnd()
3431 rajveer 1168 
    if result.success is not None:
94 ashish 1169 
      return result.success
3431 rajveer 1170 
    if result.ucx is not None:
94 ashish 1171 
      raise result.ucx
1172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1173 
 
1174 
  def removeAddressForUser(self, userid, addressId):
1175 
    """
1176 
    Parameters:
1177 
     - userid
1178 
     - addressId
1179 
    """
1180 
    self.send_removeAddressForUser(userid, addressId)
1181 
    return self.recv_removeAddressForUser()
1182 
 
1183 
  def send_removeAddressForUser(self, userid, addressId):
1184 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1185 
    args = removeAddressForUser_args()
1186 
    args.userid = userid
1187 
    args.addressId = addressId
1188 
    args.write(self._oprot)
1189 
    self._oprot.writeMessageEnd()
1190 
    self._oprot.trans.flush()
1191 
 
1192 
  def recv_removeAddressForUser(self, ):
1193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1194 
    if mtype == TMessageType.EXCEPTION:
1195 
      x = TApplicationException()
1196 
      x.read(self._iprot)
1197 
      self._iprot.readMessageEnd()
1198 
      raise x
1199 
    result = removeAddressForUser_result()
1200 
    result.read(self._iprot)
1201 
    self._iprot.readMessageEnd()
3431 rajveer 1202 
    if result.success is not None:
94 ashish 1203 
      return result.success
3431 rajveer 1204 
    if result.ucx is not None:
94 ashish 1205 
      raise result.ucx
1206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1207 
 
22358 ashik.ali 1208 
  def updateAddress(self, address):
1209 
    """
1210 
    Parameters:
1211 
     - address
1212 
    """
1213 
    self.send_updateAddress(address)
1214 
    return self.recv_updateAddress()
1215 
 
1216 
  def send_updateAddress(self, address):
1217 
    self._oprot.writeMessageBegin('updateAddress', TMessageType.CALL, self._seqid)
1218 
    args = updateAddress_args()
1219 
    args.address = address
1220 
    args.write(self._oprot)
1221 
    self._oprot.writeMessageEnd()
1222 
    self._oprot.trans.flush()
1223 
 
1224 
  def recv_updateAddress(self, ):
1225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1226 
    if mtype == TMessageType.EXCEPTION:
1227 
      x = TApplicationException()
1228 
      x.read(self._iprot)
1229 
      self._iprot.readMessageEnd()
1230 
      raise x
1231 
    result = updateAddress_result()
1232 
    result.read(self._iprot)
1233 
    self._iprot.readMessageEnd()
1234 
    if result.success is not None:
1235 
      return result.success
1236 
    if result.ucx is not None:
1237 
      raise result.ucx
1238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAddress failed: unknown result");
1239 
 
22364 ashik.ali 1240 
  def updateCounter(self, counter):
1241 
    """
1242 
    Parameters:
1243 
     - counter
1244 
    """
1245 
    self.send_updateCounter(counter)
1246 
    return self.recv_updateCounter()
1247 
 
1248 
  def send_updateCounter(self, counter):
1249 
    self._oprot.writeMessageBegin('updateCounter', TMessageType.CALL, self._seqid)
1250 
    args = updateCounter_args()
1251 
    args.counter = counter
1252 
    args.write(self._oprot)
1253 
    self._oprot.writeMessageEnd()
1254 
    self._oprot.trans.flush()
1255 
 
1256 
  def recv_updateCounter(self, ):
1257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1258 
    if mtype == TMessageType.EXCEPTION:
1259 
      x = TApplicationException()
1260 
      x.read(self._iprot)
1261 
      self._iprot.readMessageEnd()
1262 
      raise x
1263 
    result = updateCounter_result()
1264 
    result.read(self._iprot)
1265 
    self._iprot.readMessageEnd()
1266 
    if result.success is not None:
1267 
      return result.success
1268 
    if result.ucx is not None:
1269 
      raise result.ucx
1270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateCounter failed: unknown result");
1271 
 
94 ashish 1272 
  def setUserAsLoggedIn(self, userId, timestamp):
1273 
    """
1274 
    Parameters:
1275 
     - userId
1276 
     - timestamp
1277 
    """
1278 
    self.send_setUserAsLoggedIn(userId, timestamp)
1279 
    return self.recv_setUserAsLoggedIn()
1280 
 
1281 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1282 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1283 
    args = setUserAsLoggedIn_args()
1284 
    args.userId = userId
1285 
    args.timestamp = timestamp
1286 
    args.write(self._oprot)
1287 
    self._oprot.writeMessageEnd()
1288 
    self._oprot.trans.flush()
1289 
 
1290 
  def recv_setUserAsLoggedIn(self, ):
1291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1292 
    if mtype == TMessageType.EXCEPTION:
1293 
      x = TApplicationException()
1294 
      x.read(self._iprot)
1295 
      self._iprot.readMessageEnd()
1296 
      raise x
1297 
    result = setUserAsLoggedIn_result()
1298 
    result.read(self._iprot)
1299 
    self._iprot.readMessageEnd()
3431 rajveer 1300 
    if result.success is not None:
94 ashish 1301 
      return result.success
3431 rajveer 1302 
    if result.ucx is not None:
94 ashish 1303 
      raise result.ucx
1304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1305 
 
1306 
  def setUserAsLoggedOut(self, userid, timestamp):
1307 
    """
1308 
    Parameters:
1309 
     - userid
1310 
     - timestamp
1311 
    """
1312 
    self.send_setUserAsLoggedOut(userid, timestamp)
1313 
    return self.recv_setUserAsLoggedOut()
1314 
 
1315 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1316 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1317 
    args = setUserAsLoggedOut_args()
1318 
    args.userid = userid
1319 
    args.timestamp = timestamp
1320 
    args.write(self._oprot)
1321 
    self._oprot.writeMessageEnd()
1322 
    self._oprot.trans.flush()
1323 
 
1324 
  def recv_setUserAsLoggedOut(self, ):
1325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1326 
    if mtype == TMessageType.EXCEPTION:
1327 
      x = TApplicationException()
1328 
      x.read(self._iprot)
1329 
      self._iprot.readMessageEnd()
1330 
      raise x
1331 
    result = setUserAsLoggedOut_result()
1332 
    result.read(self._iprot)
1333 
    self._iprot.readMessageEnd()
3431 rajveer 1334 
    if result.success is not None:
94 ashish 1335 
      return result.success
3431 rajveer 1336 
    if result.ucx is not None:
94 ashish 1337 
      raise result.ucx
1338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1339 
 
504 rajveer 1340 
  def setDefaultAddress(self, userid, addressId):
1341 
    """
1342 
    Parameters:
1343 
     - userid
1344 
     - addressId
1345 
    """
1346 
    self.send_setDefaultAddress(userid, addressId)
1347 
    return self.recv_setDefaultAddress()
1348 
 
1349 
  def send_setDefaultAddress(self, userid, addressId):
1350 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1351 
    args = setDefaultAddress_args()
1352 
    args.userid = userid
1353 
    args.addressId = addressId
1354 
    args.write(self._oprot)
1355 
    self._oprot.writeMessageEnd()
1356 
    self._oprot.trans.flush()
1357 
 
1358 
  def recv_setDefaultAddress(self, ):
1359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1360 
    if mtype == TMessageType.EXCEPTION:
1361 
      x = TApplicationException()
1362 
      x.read(self._iprot)
1363 
      self._iprot.readMessageEnd()
1364 
      raise x
1365 
    result = setDefaultAddress_result()
1366 
    result.read(self._iprot)
1367 
    self._iprot.readMessageEnd()
3431 rajveer 1368 
    if result.success is not None:
504 rajveer 1369 
      return result.success
3431 rajveer 1370 
    if result.ucx is not None:
504 rajveer 1371 
      raise result.ucx
1372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1373 
 
594 rajveer 1374 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1375 
    """
1376 
    Parameters:
1377 
     - userid
594 rajveer 1378 
     - oldPassword
1379 
     - newPassword
94 ashish 1380 
    """
594 rajveer 1381 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1382 
    return self.recv_updatePassword()
1383 
 
594 rajveer 1384 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1385 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1386 
    args = updatePassword_args()
1387 
    args.userid = userid
594 rajveer 1388 
    args.oldPassword = oldPassword
1389 
    args.newPassword = newPassword
94 ashish 1390 
    args.write(self._oprot)
1391 
    self._oprot.writeMessageEnd()
1392 
    self._oprot.trans.flush()
1393 
 
1394 
  def recv_updatePassword(self, ):
1395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1396 
    if mtype == TMessageType.EXCEPTION:
1397 
      x = TApplicationException()
1398 
      x.read(self._iprot)
1399 
      self._iprot.readMessageEnd()
1400 
      raise x
1401 
    result = updatePassword_result()
1402 
    result.read(self._iprot)
1403 
    self._iprot.readMessageEnd()
3431 rajveer 1404 
    if result.success is not None:
94 ashish 1405 
      return result.success
3431 rajveer 1406 
    if result.ucx is not None:
94 ashish 1407 
      raise result.ucx
1408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1409 
 
884 rajveer 1410 
  def forgotPassword(self, email, newPassword):
581 rajveer 1411 
    """
1412 
    Parameters:
1413 
     - email
884 rajveer 1414 
     - newPassword
581 rajveer 1415 
    """
884 rajveer 1416 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1417 
    return self.recv_forgotPassword()
1418 
 
884 rajveer 1419 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1420 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1421 
    args = forgotPassword_args()
1422 
    args.email = email
884 rajveer 1423 
    args.newPassword = newPassword
581 rajveer 1424 
    args.write(self._oprot)
1425 
    self._oprot.writeMessageEnd()
1426 
    self._oprot.trans.flush()
1427 
 
1428 
  def recv_forgotPassword(self, ):
1429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1430 
    if mtype == TMessageType.EXCEPTION:
1431 
      x = TApplicationException()
1432 
      x.read(self._iprot)
1433 
      self._iprot.readMessageEnd()
1434 
      raise x
1435 
    result = forgotPassword_result()
1436 
    result.read(self._iprot)
1437 
    self._iprot.readMessageEnd()
3431 rajveer 1438 
    if result.success is not None:
581 rajveer 1439 
      return result.success
3431 rajveer 1440 
    if result.ucx is not None:
581 rajveer 1441 
      raise result.ucx
1442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1443 
 
594 rajveer 1444 
  def getAllAddressesForUser(self, userId):
1445 
    """
1446 
    Parameters:
1447 
     - userId
1448 
    """
1449 
    self.send_getAllAddressesForUser(userId)
1450 
    return self.recv_getAllAddressesForUser()
1451 
 
1452 
  def send_getAllAddressesForUser(self, userId):
1453 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1454 
    args = getAllAddressesForUser_args()
1455 
    args.userId = userId
1456 
    args.write(self._oprot)
1457 
    self._oprot.writeMessageEnd()
1458 
    self._oprot.trans.flush()
1459 
 
1460 
  def recv_getAllAddressesForUser(self, ):
1461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1462 
    if mtype == TMessageType.EXCEPTION:
1463 
      x = TApplicationException()
1464 
      x.read(self._iprot)
1465 
      self._iprot.readMessageEnd()
1466 
      raise x
1467 
    result = getAllAddressesForUser_result()
1468 
    result.read(self._iprot)
1469 
    self._iprot.readMessageEnd()
3431 rajveer 1470 
    if result.success is not None:
594 rajveer 1471 
      return result.success
3431 rajveer 1472 
    if result.ucx is not None:
594 rajveer 1473 
      raise result.ucx
1474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1475 
 
1894 vikas 1476 
  def getAddressById(self, addressId):
1477 
    """
1478 
    Parameters:
1479 
     - addressId
1480 
    """
1481 
    self.send_getAddressById(addressId)
1482 
    return self.recv_getAddressById()
1483 
 
1484 
  def send_getAddressById(self, addressId):
1485 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1486 
    args = getAddressById_args()
1487 
    args.addressId = addressId
1488 
    args.write(self._oprot)
1489 
    self._oprot.writeMessageEnd()
1490 
    self._oprot.trans.flush()
1491 
 
1492 
  def recv_getAddressById(self, ):
1493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1494 
    if mtype == TMessageType.EXCEPTION:
1495 
      x = TApplicationException()
1496 
      x.read(self._iprot)
1497 
      self._iprot.readMessageEnd()
1498 
      raise x
1499 
    result = getAddressById_result()
1500 
    result.read(self._iprot)
1501 
    self._iprot.readMessageEnd()
3431 rajveer 1502 
    if result.success is not None:
1894 vikas 1503 
      return result.success
3431 rajveer 1504 
    if result.ucx is not None:
1894 vikas 1505 
      raise result.ucx
1506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1507 
 
594 rajveer 1508 
  def getDefaultAddressId(self, userId):
1509 
    """
1510 
    Parameters:
1511 
     - userId
1512 
    """
1513 
    self.send_getDefaultAddressId(userId)
1514 
    return self.recv_getDefaultAddressId()
1515 
 
1516 
  def send_getDefaultAddressId(self, userId):
1517 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1518 
    args = getDefaultAddressId_args()
1519 
    args.userId = userId
1520 
    args.write(self._oprot)
1521 
    self._oprot.writeMessageEnd()
1522 
    self._oprot.trans.flush()
1523 
 
1524 
  def recv_getDefaultAddressId(self, ):
1525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1526 
    if mtype == TMessageType.EXCEPTION:
1527 
      x = TApplicationException()
1528 
      x.read(self._iprot)
1529 
      self._iprot.readMessageEnd()
1530 
      raise x
1531 
    result = getDefaultAddressId_result()
1532 
    result.read(self._iprot)
1533 
    self._iprot.readMessageEnd()
3431 rajveer 1534 
    if result.success is not None:
594 rajveer 1535 
      return result.success
3431 rajveer 1536 
    if result.ucx is not None:
594 rajveer 1537 
      raise result.ucx
1538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1539 
 
785 rajveer 1540 
  def getDefaultPincode(self, userId):
1541 
    """
1542 
    Parameters:
1543 
     - userId
1544 
    """
1545 
    self.send_getDefaultPincode(userId)
1546 
    return self.recv_getDefaultPincode()
1547 
 
1548 
  def send_getDefaultPincode(self, userId):
1549 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1550 
    args = getDefaultPincode_args()
1551 
    args.userId = userId
1552 
    args.write(self._oprot)
1553 
    self._oprot.writeMessageEnd()
1554 
    self._oprot.trans.flush()
1555 
 
1556 
  def recv_getDefaultPincode(self, ):
1557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1558 
    if mtype == TMessageType.EXCEPTION:
1559 
      x = TApplicationException()
1560 
      x.read(self._iprot)
1561 
      self._iprot.readMessageEnd()
1562 
      raise x
1563 
    result = getDefaultPincode_result()
1564 
    result.read(self._iprot)
1565 
    self._iprot.readMessageEnd()
3431 rajveer 1566 
    if result.success is not None:
785 rajveer 1567 
      return result.success
3431 rajveer 1568 
    if result.ucx is not None:
785 rajveer 1569 
      raise result.ucx
1570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1571 
 
1274 varun.gupt 1572 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1573 
    """
1574 
    Parameters:
1575 
     - userId
1576 
     - replyTo
1577 
     - communicationType
1578 
     - orderId
1579 
     - airwaybillNo
1580 
     - productName
1581 
     - subject
1582 
     - message
1583 
    """
1584 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1585 
    return self.recv_saveUserCommunication()
1586 
 
1587 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1588 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1589 
    args = saveUserCommunication_args()
1590 
    args.userId = userId
1591 
    args.replyTo = replyTo
1592 
    args.communicationType = communicationType
1593 
    args.orderId = orderId
1594 
    args.airwaybillNo = airwaybillNo
1595 
    args.productName = productName
1596 
    args.subject = subject
1597 
    args.message = message
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_saveUserCommunication(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = saveUserCommunication_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
3431 rajveer 1612 
    if result.success is not None:
1274 varun.gupt 1613 
      return result.success
3431 rajveer 1614 
    if result.ucx is not None:
1274 varun.gupt 1615 
      raise result.ucx
1616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1617 
 
1590 varun.gupt 1618 
  def getUserCommunicationById(self, id):
1619 
    """
1620 
    Parameters:
1621 
     - id
1622 
    """
1623 
    self.send_getUserCommunicationById(id)
1624 
    return self.recv_getUserCommunicationById()
1625 
 
1626 
  def send_getUserCommunicationById(self, id):
1627 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1628 
    args = getUserCommunicationById_args()
1629 
    args.id = id
1630 
    args.write(self._oprot)
1631 
    self._oprot.writeMessageEnd()
1632 
    self._oprot.trans.flush()
1633 
 
1634 
  def recv_getUserCommunicationById(self, ):
1635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1636 
    if mtype == TMessageType.EXCEPTION:
1637 
      x = TApplicationException()
1638 
      x.read(self._iprot)
1639 
      self._iprot.readMessageEnd()
1640 
      raise x
1641 
    result = getUserCommunicationById_result()
1642 
    result.read(self._iprot)
1643 
    self._iprot.readMessageEnd()
3431 rajveer 1644 
    if result.success is not None:
1590 varun.gupt 1645 
      return result.success
3431 rajveer 1646 
    if result.ucx is not None:
1590 varun.gupt 1647 
      raise result.ucx
1648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1649 
 
1650 
  def getUserCommunicationByUser(self, userId):
1651 
    """
1652 
    Parameters:
1653 
     - userId
1654 
    """
1655 
    self.send_getUserCommunicationByUser(userId)
1656 
    return self.recv_getUserCommunicationByUser()
1657 
 
1658 
  def send_getUserCommunicationByUser(self, userId):
1659 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1660 
    args = getUserCommunicationByUser_args()
1661 
    args.userId = userId
1662 
    args.write(self._oprot)
1663 
    self._oprot.writeMessageEnd()
1664 
    self._oprot.trans.flush()
1665 
 
1666 
  def recv_getUserCommunicationByUser(self, ):
1667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1668 
    if mtype == TMessageType.EXCEPTION:
1669 
      x = TApplicationException()
1670 
      x.read(self._iprot)
1671 
      self._iprot.readMessageEnd()
1672 
      raise x
1673 
    result = getUserCommunicationByUser_result()
1674 
    result.read(self._iprot)
1675 
    self._iprot.readMessageEnd()
3431 rajveer 1676 
    if result.success is not None:
1590 varun.gupt 1677 
      return result.success
3431 rajveer 1678 
    if result.ucx is not None:
1590 varun.gupt 1679 
      raise result.ucx
1680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1681 
 
1682 
  def getAllUserCommunications(self, ):
1683 
    self.send_getAllUserCommunications()
1684 
    return self.recv_getAllUserCommunications()
1685 
 
1686 
  def send_getAllUserCommunications(self, ):
1687 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1688 
    args = getAllUserCommunications_args()
1689 
    args.write(self._oprot)
1690 
    self._oprot.writeMessageEnd()
1691 
    self._oprot.trans.flush()
1692 
 
1693 
  def recv_getAllUserCommunications(self, ):
1694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1695 
    if mtype == TMessageType.EXCEPTION:
1696 
      x = TApplicationException()
1697 
      x.read(self._iprot)
1698 
      self._iprot.readMessageEnd()
1699 
      raise x
1700 
    result = getAllUserCommunications_result()
1701 
    result.read(self._iprot)
1702 
    self._iprot.readMessageEnd()
3431 rajveer 1703 
    if result.success is not None:
1590 varun.gupt 1704 
      return result.success
3431 rajveer 1705 
    if result.ucx is not None:
1590 varun.gupt 1706 
      raise result.ucx
1707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1708 
 
5407 amar.kumar 1709 
  def removeUserCommunication(self, id):
1710 
    """
1711 
    Parameters:
1712 
     - id
1713 
    """
1714 
    self.send_removeUserCommunication(id)
1715 
    self.recv_removeUserCommunication()
1716 
 
1717 
  def send_removeUserCommunication(self, id):
1718 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1719 
    args = removeUserCommunication_args()
1720 
    args.id = id
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_removeUserCommunication(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = removeUserCommunication_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
1735 
    if result.ucx is not None:
1736 
      raise result.ucx
1737 
    return
1738 
 
1859 vikas 1739 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1740 
    """
1741 
    Parameters:
1742 
     - name
1859 vikas 1743 
     - addedOn
1845 vikas 1744 
    """
1859 vikas 1745 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1746 
    return self.recv_createMasterAffiliate()
1747 
 
1859 vikas 1748 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1749 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1750 
    args = createMasterAffiliate_args()
1751 
    args.name = name
1859 vikas 1752 
    args.addedOn = addedOn
1845 vikas 1753 
    args.write(self._oprot)
1754 
    self._oprot.writeMessageEnd()
1755 
    self._oprot.trans.flush()
1756 
 
1757 
  def recv_createMasterAffiliate(self, ):
1758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1759 
    if mtype == TMessageType.EXCEPTION:
1760 
      x = TApplicationException()
1761 
      x.read(self._iprot)
1762 
      self._iprot.readMessageEnd()
1763 
      raise x
1764 
    result = createMasterAffiliate_result()
1765 
    result.read(self._iprot)
1766 
    self._iprot.readMessageEnd()
3431 rajveer 1767 
    if result.success is not None:
1845 vikas 1768 
      return result.success
3431 rajveer 1769 
    if result.utx is not None:
1845 vikas 1770 
      raise result.utx
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1772 
 
1899 vikas 1773 
  def getAllMasterAffiliates(self, ):
1774 
    self.send_getAllMasterAffiliates()
1775 
    return self.recv_getAllMasterAffiliates()
1776 
 
1777 
  def send_getAllMasterAffiliates(self, ):
1778 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1779 
    args = getAllMasterAffiliates_args()
1780 
    args.write(self._oprot)
1781 
    self._oprot.writeMessageEnd()
1782 
    self._oprot.trans.flush()
1783 
 
1784 
  def recv_getAllMasterAffiliates(self, ):
1785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1786 
    if mtype == TMessageType.EXCEPTION:
1787 
      x = TApplicationException()
1788 
      x.read(self._iprot)
1789 
      self._iprot.readMessageEnd()
1790 
      raise x
1791 
    result = getAllMasterAffiliates_result()
1792 
    result.read(self._iprot)
1793 
    self._iprot.readMessageEnd()
3431 rajveer 1794 
    if result.success is not None:
1899 vikas 1795 
      return result.success
3431 rajveer 1796 
    if result.utx is not None:
1899 vikas 1797 
      raise result.utx
1798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1799 
 
1845 vikas 1800 
  def getMasterAffiliateById(self, id):
1801 
    """
1802 
    Parameters:
1803 
     - id
1804 
    """
1805 
    self.send_getMasterAffiliateById(id)
1806 
    return self.recv_getMasterAffiliateById()
1807 
 
1808 
  def send_getMasterAffiliateById(self, id):
1809 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1810 
    args = getMasterAffiliateById_args()
1811 
    args.id = id
1812 
    args.write(self._oprot)
1813 
    self._oprot.writeMessageEnd()
1814 
    self._oprot.trans.flush()
1815 
 
1816 
  def recv_getMasterAffiliateById(self, ):
1817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1818 
    if mtype == TMessageType.EXCEPTION:
1819 
      x = TApplicationException()
1820 
      x.read(self._iprot)
1821 
      self._iprot.readMessageEnd()
1822 
      raise x
1823 
    result = getMasterAffiliateById_result()
1824 
    result.read(self._iprot)
1825 
    self._iprot.readMessageEnd()
3431 rajveer 1826 
    if result.success is not None:
1845 vikas 1827 
      return result.success
3431 rajveer 1828 
    if result.utx is not None:
1845 vikas 1829 
      raise result.utx
1830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1831 
 
1832 
  def getMasterAffiliateByName(self, name):
1833 
    """
1834 
    Parameters:
1835 
     - name
1836 
    """
1837 
    self.send_getMasterAffiliateByName(name)
1838 
    return self.recv_getMasterAffiliateByName()
1839 
 
1840 
  def send_getMasterAffiliateByName(self, name):
1841 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1842 
    args = getMasterAffiliateByName_args()
1843 
    args.name = name
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_getMasterAffiliateByName(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = getMasterAffiliateByName_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
3431 rajveer 1858 
    if result.success is not None:
1845 vikas 1859 
      return result.success
3431 rajveer 1860 
    if result.utx is not None:
1845 vikas 1861 
      raise result.utx
1862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1863 
 
1859 vikas 1864 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1865 
    """
1866 
    Parameters:
1867 
     - name
1868 
     - url
1869 
     - masterAffiliateId
1859 vikas 1870 
     - addedOn
1845 vikas 1871 
    """
1859 vikas 1872 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1873 
    return self.recv_createAffiliate()
1874 
 
1859 vikas 1875 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1876 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1877 
    args = createAffiliate_args()
1878 
    args.name = name
1879 
    args.url = url
1880 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1881 
    args.addedOn = addedOn
1845 vikas 1882 
    args.write(self._oprot)
1883 
    self._oprot.writeMessageEnd()
1884 
    self._oprot.trans.flush()
1885 
 
1886 
  def recv_createAffiliate(self, ):
1887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1888 
    if mtype == TMessageType.EXCEPTION:
1889 
      x = TApplicationException()
1890 
      x.read(self._iprot)
1891 
      self._iprot.readMessageEnd()
1892 
      raise x
1893 
    result = createAffiliate_result()
1894 
    result.read(self._iprot)
1895 
    self._iprot.readMessageEnd()
3431 rajveer 1896 
    if result.success is not None:
1845 vikas 1897 
      return result.success
3431 rajveer 1898 
    if result.utx is not None:
1845 vikas 1899 
      raise result.utx
1900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1901 
 
1902 
  def getAffiliateById(self, id):
1903 
    """
1904 
    Parameters:
1905 
     - id
1906 
    """
1907 
    self.send_getAffiliateById(id)
1908 
    return self.recv_getAffiliateById()
1909 
 
1910 
  def send_getAffiliateById(self, id):
1911 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1912 
    args = getAffiliateById_args()
1913 
    args.id = id
1914 
    args.write(self._oprot)
1915 
    self._oprot.writeMessageEnd()
1916 
    self._oprot.trans.flush()
1917 
 
1918 
  def recv_getAffiliateById(self, ):
1919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1920 
    if mtype == TMessageType.EXCEPTION:
1921 
      x = TApplicationException()
1922 
      x.read(self._iprot)
1923 
      self._iprot.readMessageEnd()
1924 
      raise x
1925 
    result = getAffiliateById_result()
1926 
    result.read(self._iprot)
1927 
    self._iprot.readMessageEnd()
3431 rajveer 1928 
    if result.success is not None:
1845 vikas 1929 
      return result.success
3431 rajveer 1930 
    if result.utx is not None:
1845 vikas 1931 
      raise result.utx
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1933 
 
1934 
  def getAffiliateByName(self, name):
1935 
    """
1936 
    Parameters:
1937 
     - name
1938 
    """
1939 
    self.send_getAffiliateByName(name)
1940 
    return self.recv_getAffiliateByName()
1941 
 
1942 
  def send_getAffiliateByName(self, name):
1943 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1944 
    args = getAffiliateByName_args()
1945 
    args.name = name
1946 
    args.write(self._oprot)
1947 
    self._oprot.writeMessageEnd()
1948 
    self._oprot.trans.flush()
1949 
 
1950 
  def recv_getAffiliateByName(self, ):
1951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1952 
    if mtype == TMessageType.EXCEPTION:
1953 
      x = TApplicationException()
1954 
      x.read(self._iprot)
1955 
      self._iprot.readMessageEnd()
1956 
      raise x
1957 
    result = getAffiliateByName_result()
1958 
    result.read(self._iprot)
1959 
    self._iprot.readMessageEnd()
3431 rajveer 1960 
    if result.success is not None:
1845 vikas 1961 
      return result.success
3431 rajveer 1962 
    if result.utx is not None:
1845 vikas 1963 
      raise result.utx
1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1965 
 
1996 vikas 1966 
  def getTrackerById(self, id):
1845 vikas 1967 
    """
1968 
    Parameters:
1969 
     - id
1970 
    """
1996 vikas 1971 
    self.send_getTrackerById(id)
1845 vikas 1972 
    return self.recv_getTrackerById()
1973 
 
1996 vikas 1974 
  def send_getTrackerById(self, id):
1845 vikas 1975 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1976 
    args = getTrackerById_args()
1996 vikas 1977 
    args.id = id
1845 vikas 1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_getTrackerById(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = getTrackerById_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
3431 rajveer 1992 
    if result.success is not None:
1845 vikas 1993 
      return result.success
3431 rajveer 1994 
    if result.utx is not None:
1845 vikas 1995 
      raise result.utx
1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1997 
 
1996 vikas 1998 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1999 
    """
2000 
    Parameters:
1996 vikas 2001 
     - id
1845 vikas 2002 
    """
1996 vikas 2003 
    self.send_getAffiliatesByMasterAffiliate(id)
2004 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 2005 
 
1996 vikas 2006 
  def send_getAffiliatesByMasterAffiliate(self, id):
2007 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
2008 
    args = getAffiliatesByMasterAffiliate_args()
2009 
    args.id = id
1845 vikas 2010 
    args.write(self._oprot)
2011 
    self._oprot.writeMessageEnd()
2012 
    self._oprot.trans.flush()
2013 
 
1996 vikas 2014 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 2015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2016 
    if mtype == TMessageType.EXCEPTION:
2017 
      x = TApplicationException()
2018 
      x.read(self._iprot)
2019 
      self._iprot.readMessageEnd()
2020 
      raise x
1996 vikas 2021 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 2022 
    result.read(self._iprot)
2023 
    self._iprot.readMessageEnd()
3431 rajveer 2024 
    if result.success is not None:
1845 vikas 2025 
      return result.success
3431 rajveer 2026 
    if result.utx is not None:
1845 vikas 2027 
      raise result.utx
1996 vikas 2028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 2029 
 
1996 vikas 2030 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 2031 
    """
2032 
    Parameters:
1996 vikas 2033 
     - affiliateId
1845 vikas 2034 
     - userId
2035 
     - event
2036 
     - url
2037 
     - data
1859 vikas 2038 
     - addedOn
1845 vikas 2039 
    """
1996 vikas 2040 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 2041 
    return self.recv_addTrackLog()
2042 
 
1996 vikas 2043 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 2044 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
2045 
    args = addTrackLog_args()
1996 vikas 2046 
    args.affiliateId = affiliateId
1845 vikas 2047 
    args.userId = userId
2048 
    args.event = event
2049 
    args.url = url
2050 
    args.data = data
1859 vikas 2051 
    args.addedOn = addedOn
1845 vikas 2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
2056 
  def recv_addTrackLog(self, ):
2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
2063 
    result = addTrackLog_result()
2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
3431 rajveer 2066 
    if result.success is not None:
1845 vikas 2067 
      return result.success
3431 rajveer 2068 
    if result.utx is not None:
1845 vikas 2069 
      raise result.utx
2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
2071 
 
2072 
  def getTrackLogById(self, id):
2073 
    """
2074 
    Parameters:
2075 
     - id
2076 
    """
2077 
    self.send_getTrackLogById(id)
2078 
    return self.recv_getTrackLogById()
2079 
 
2080 
  def send_getTrackLogById(self, id):
2081 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
2082 
    args = getTrackLogById_args()
2083 
    args.id = id
2084 
    args.write(self._oprot)
2085 
    self._oprot.writeMessageEnd()
2086 
    self._oprot.trans.flush()
2087 
 
2088 
  def recv_getTrackLogById(self, ):
2089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2090 
    if mtype == TMessageType.EXCEPTION:
2091 
      x = TApplicationException()
2092 
      x.read(self._iprot)
2093 
      self._iprot.readMessageEnd()
2094 
      raise x
2095 
    result = getTrackLogById_result()
2096 
    result.read(self._iprot)
2097 
    self._iprot.readMessageEnd()
3431 rajveer 2098 
    if result.success is not None:
1845 vikas 2099 
      return result.success
3431 rajveer 2100 
    if result.utx is not None:
1845 vikas 2101 
      raise result.utx
2102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2103 
 
3293 vikas 2104 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2105 
    """
2106 
    Parameters:
1996 vikas 2107 
     - affiliateId
3293 vikas 2108 
     - startDate
2109 
     - endDate
1845 vikas 2110 
    """
3293 vikas 2111 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2112 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2113 
 
3293 vikas 2114 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2115 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2116 
    args = getTrackLogsByAffiliate_args()
2117 
    args.affiliateId = affiliateId
3293 vikas 2118 
    args.startDate = startDate
2119 
    args.endDate = endDate
1845 vikas 2120 
    args.write(self._oprot)
2121 
    self._oprot.writeMessageEnd()
2122 
    self._oprot.trans.flush()
2123 
 
1996 vikas 2124 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2126 
    if mtype == TMessageType.EXCEPTION:
2127 
      x = TApplicationException()
2128 
      x.read(self._iprot)
2129 
      self._iprot.readMessageEnd()
2130 
      raise x
1996 vikas 2131 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2132 
    result.read(self._iprot)
2133 
    self._iprot.readMessageEnd()
3431 rajveer 2134 
    if result.success is not None:
1845 vikas 2135 
      return result.success
3431 rajveer 2136 
    if result.utx is not None:
1845 vikas 2137 
      raise result.utx
1996 vikas 2138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2139 
 
2140 
  def getTrackLogsByUser(self, userId):
2141 
    """
2142 
    Parameters:
2143 
     - userId
2144 
    """
2145 
    self.send_getTrackLogsByUser(userId)
2146 
    return self.recv_getTrackLogsByUser()
2147 
 
2148 
  def send_getTrackLogsByUser(self, userId):
2149 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2150 
    args = getTrackLogsByUser_args()
2151 
    args.userId = userId
2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
2156 
  def recv_getTrackLogsByUser(self, ):
2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
2163 
    result = getTrackLogsByUser_result()
2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
3431 rajveer 2166 
    if result.success is not None:
1845 vikas 2167 
      return result.success
3431 rajveer 2168 
    if result.utx is not None:
1845 vikas 2169 
      raise result.utx
2170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2171 
 
1996 vikas 2172 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2173 
    """
2174 
    Parameters:
2175 
     - userId
2176 
     - event
2177 
     - url
2178 
    """
1996 vikas 2179 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2180 
    return self.recv_getTrackLogs()
2181 
 
1996 vikas 2182 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2183 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2184 
    args = getTrackLogs_args()
2185 
    args.userId = userId
2186 
    args.event = event
2187 
    args.url = url
2188 
    args.write(self._oprot)
2189 
    self._oprot.writeMessageEnd()
2190 
    self._oprot.trans.flush()
2191 
 
2192 
  def recv_getTrackLogs(self, ):
2193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2194 
    if mtype == TMessageType.EXCEPTION:
2195 
      x = TApplicationException()
2196 
      x.read(self._iprot)
2197 
      self._iprot.readMessageEnd()
2198 
      raise x
2199 
    result = getTrackLogs_result()
2200 
    result.read(self._iprot)
2201 
    self._iprot.readMessageEnd()
3431 rajveer 2202 
    if result.success is not None:
1845 vikas 2203 
      return result.success
3431 rajveer 2204 
    if result.utx is not None:
1845 vikas 2205 
      raise result.utx
2206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2207 
 
559 chandransh 2208 
  def getCurrentCart(self, userId):
94 ashish 2209 
    """
2210 
    Parameters:
559 chandransh 2211 
     - userId
94 ashish 2212 
    """
559 chandransh 2213 
    self.send_getCurrentCart(userId)
2214 
    return self.recv_getCurrentCart()
94 ashish 2215 
 
559 chandransh 2216 
  def send_getCurrentCart(self, userId):
2217 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2218 
    args = getCurrentCart_args()
2219 
    args.userId = userId
94 ashish 2220 
    args.write(self._oprot)
2221 
    self._oprot.writeMessageEnd()
2222 
    self._oprot.trans.flush()
2223 
 
559 chandransh 2224 
  def recv_getCurrentCart(self, ):
94 ashish 2225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2226 
    if mtype == TMessageType.EXCEPTION:
2227 
      x = TApplicationException()
2228 
      x.read(self._iprot)
2229 
      self._iprot.readMessageEnd()
2230 
      raise x
559 chandransh 2231 
    result = getCurrentCart_result()
94 ashish 2232 
    result.read(self._iprot)
2233 
    self._iprot.readMessageEnd()
3431 rajveer 2234 
    if result.success is not None:
94 ashish 2235 
      return result.success
3431 rajveer 2236 
    if result.scx is not None:
559 chandransh 2237 
      raise result.scx
2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2239 
 
559 chandransh 2240 
  def getCart(self, cartId):
94 ashish 2241 
    """
2242 
    Parameters:
559 chandransh 2243 
     - cartId
94 ashish 2244 
    """
559 chandransh 2245 
    self.send_getCart(cartId)
2246 
    return self.recv_getCart()
94 ashish 2247 
 
559 chandransh 2248 
  def send_getCart(self, cartId):
2249 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2250 
    args = getCart_args()
2251 
    args.cartId = cartId
94 ashish 2252 
    args.write(self._oprot)
2253 
    self._oprot.writeMessageEnd()
2254 
    self._oprot.trans.flush()
2255 
 
559 chandransh 2256 
  def recv_getCart(self, ):
94 ashish 2257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2258 
    if mtype == TMessageType.EXCEPTION:
2259 
      x = TApplicationException()
2260 
      x.read(self._iprot)
2261 
      self._iprot.readMessageEnd()
2262 
      raise x
559 chandransh 2263 
    result = getCart_result()
94 ashish 2264 
    result.read(self._iprot)
2265 
    self._iprot.readMessageEnd()
3431 rajveer 2266 
    if result.success is not None:
94 ashish 2267 
      return result.success
3431 rajveer 2268 
    if result.scx is not None:
559 chandransh 2269 
      raise result.scx
2270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2271 
 
559 chandransh 2272 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2273 
    """
2274 
    Parameters:
559 chandransh 2275 
     - from_time
2276 
     - to_time
2277 
     - status
94 ashish 2278 
    """
559 chandransh 2279 
    self.send_getCartsByTime(from_time, to_time, status)
2280 
    return self.recv_getCartsByTime()
94 ashish 2281 
 
559 chandransh 2282 
  def send_getCartsByTime(self, from_time, to_time, status):
2283 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2284 
    args = getCartsByTime_args()
2285 
    args.from_time = from_time
2286 
    args.to_time = to_time
2287 
    args.status = status
94 ashish 2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
559 chandransh 2292 
  def recv_getCartsByTime(self, ):
94 ashish 2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
559 chandransh 2299 
    result = getCartsByTime_result()
94 ashish 2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
3431 rajveer 2302 
    if result.success is not None:
94 ashish 2303 
      return result.success
3431 rajveer 2304 
    if result.scx is not None:
559 chandransh 2305 
      raise result.scx
2306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2307 
 
3557 rajveer 2308 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2309 
    """
2310 
    Parameters:
2311 
     - cartId
2312 
     - itemId
2313 
     - quantity
3557 rajveer 2314 
     - sourceId
559 chandransh 2315 
    """
3557 rajveer 2316 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2317 
    return self.recv_addItemToCart()
559 chandransh 2318 
 
3557 rajveer 2319 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2320 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2321 
    args = addItemToCart_args()
2322 
    args.cartId = cartId
2323 
    args.itemId = itemId
2324 
    args.quantity = quantity
3557 rajveer 2325 
    args.sourceId = sourceId
559 chandransh 2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
2330 
  def recv_addItemToCart(self, ):
2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
2337 
    result = addItemToCart_result()
2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.success is not None:
2035 rajveer 2341 
      return result.success
3431 rajveer 2342 
    if result.scx is not None:
559 chandransh 2343 
      raise result.scx
2035 rajveer 2344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2345 
 
2346 
  def deleteItemFromCart(self, cartId, itemId):
2347 
    """
2348 
    Parameters:
2349 
     - cartId
2350 
     - itemId
2351 
    """
2352 
    self.send_deleteItemFromCart(cartId, itemId)
2353 
    self.recv_deleteItemFromCart()
2354 
 
2355 
  def send_deleteItemFromCart(self, cartId, itemId):
2356 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2357 
    args = deleteItemFromCart_args()
2358 
    args.cartId = cartId
2359 
    args.itemId = itemId
2360 
    args.write(self._oprot)
2361 
    self._oprot.writeMessageEnd()
2362 
    self._oprot.trans.flush()
2363 
 
2364 
  def recv_deleteItemFromCart(self, ):
2365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2366 
    if mtype == TMessageType.EXCEPTION:
2367 
      x = TApplicationException()
2368 
      x.read(self._iprot)
2369 
      self._iprot.readMessageEnd()
2370 
      raise x
2371 
    result = deleteItemFromCart_result()
2372 
    result.read(self._iprot)
2373 
    self._iprot.readMessageEnd()
3431 rajveer 2374 
    if result.scx is not None:
559 chandransh 2375 
      raise result.scx
2376 
    return
2377 
 
2378 
  def addAddressToCart(self, cartId, addressId):
2379 
    """
2380 
    Parameters:
2381 
     - cartId
2382 
     - addressId
2383 
    """
2384 
    self.send_addAddressToCart(cartId, addressId)
2385 
    self.recv_addAddressToCart()
2386 
 
2387 
  def send_addAddressToCart(self, cartId, addressId):
2388 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2389 
    args = addAddressToCart_args()
2390 
    args.cartId = cartId
2391 
    args.addressId = addressId
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_addAddressToCart(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = addAddressToCart_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
3431 rajveer 2406 
    if result.scx is not None:
575 chandransh 2407 
      raise result.scx
559 chandransh 2408 
    return
2409 
 
5553 rajveer 2410 
  def addStoreToCart(self, cartId, storeId):
2411 
    """
2412 
    Parameters:
2413 
     - cartId
2414 
     - storeId
2415 
    """
2416 
    self.send_addStoreToCart(cartId, storeId)
2417 
    self.recv_addStoreToCart()
2418 
 
2419 
  def send_addStoreToCart(self, cartId, storeId):
2420 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2421 
    args = addStoreToCart_args()
2422 
    args.cartId = cartId
2423 
    args.storeId = storeId
2424 
    args.write(self._oprot)
2425 
    self._oprot.writeMessageEnd()
2426 
    self._oprot.trans.flush()
2427 
 
2428 
  def recv_addStoreToCart(self, ):
2429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2430 
    if mtype == TMessageType.EXCEPTION:
2431 
      x = TApplicationException()
2432 
      x.read(self._iprot)
2433 
      self._iprot.readMessageEnd()
2434 
      raise x
2435 
    result = addStoreToCart_result()
2436 
    result.read(self._iprot)
2437 
    self._iprot.readMessageEnd()
2438 
    if result.scx is not None:
2439 
      raise result.scx
2440 
    return
2441 
 
6922 anupam.sin 2442 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2443 
    """
2444 
    Parameters:
6922 anupam.sin 2445 
     - cart
1976 varun.gupt 2446 
     - couponCode
2447 
    """
6922 anupam.sin 2448 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2449 
    self.recv_applyCouponToCart()
2450 
 
6922 anupam.sin 2451 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2452 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2453 
    args = applyCouponToCart_args()
6922 anupam.sin 2454 
    args.cart = cart
1976 varun.gupt 2455 
    args.couponCode = couponCode
2456 
    args.write(self._oprot)
2457 
    self._oprot.writeMessageEnd()
2458 
    self._oprot.trans.flush()
2459 
 
2460 
  def recv_applyCouponToCart(self, ):
2461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2462 
    if mtype == TMessageType.EXCEPTION:
2463 
      x = TApplicationException()
2464 
      x.read(self._iprot)
2465 
      self._iprot.readMessageEnd()
2466 
      raise x
2467 
    result = applyCouponToCart_result()
2468 
    result.read(self._iprot)
2469 
    self._iprot.readMessageEnd()
3431 rajveer 2470 
    if result.scx is not None:
1976 varun.gupt 2471 
      raise result.scx
2472 
    return
2473 
 
2474 
  def removeCoupon(self, cartId):
2475 
    """
2476 
    Parameters:
2477 
     - cartId
2478 
    """
2479 
    self.send_removeCoupon(cartId)
2480 
    self.recv_removeCoupon()
2481 
 
2482 
  def send_removeCoupon(self, cartId):
2483 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2484 
    args = removeCoupon_args()
2485 
    args.cartId = cartId
2486 
    args.write(self._oprot)
2487 
    self._oprot.writeMessageEnd()
2488 
    self._oprot.trans.flush()
2489 
 
2490 
  def recv_removeCoupon(self, ):
2491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2492 
    if mtype == TMessageType.EXCEPTION:
2493 
      x = TApplicationException()
2494 
      x.read(self._iprot)
2495 
      self._iprot.readMessageEnd()
2496 
      raise x
2497 
    result = removeCoupon_result()
2498 
    result.read(self._iprot)
2499 
    self._iprot.readMessageEnd()
3431 rajveer 2500 
    if result.scx is not None:
1976 varun.gupt 2501 
      raise result.scx
2502 
    return
2503 
 
3554 varun.gupt 2504 
  def deleteDiscountsFromCart(self, cartId):
2505 
    """
2506 
    Deletes all the discounts associated with the cart
2507 
 
2508 
    Parameters:
2509 
     - cartId
2510 
    """
2511 
    self.send_deleteDiscountsFromCart(cartId)
2512 
    self.recv_deleteDiscountsFromCart()
2513 
 
2514 
  def send_deleteDiscountsFromCart(self, cartId):
2515 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2516 
    args = deleteDiscountsFromCart_args()
2517 
    args.cartId = cartId
2518 
    args.write(self._oprot)
2519 
    self._oprot.writeMessageEnd()
2520 
    self._oprot.trans.flush()
2521 
 
2522 
  def recv_deleteDiscountsFromCart(self, ):
2523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2524 
    if mtype == TMessageType.EXCEPTION:
2525 
      x = TApplicationException()
2526 
      x.read(self._iprot)
2527 
      self._iprot.readMessageEnd()
2528 
      raise x
2529 
    result = deleteDiscountsFromCart_result()
2530 
    result.read(self._iprot)
2531 
    self._iprot.readMessageEnd()
2532 
    if result.scx is not None:
2533 
      raise result.scx
2534 
    return
2535 
 
2536 
  def saveDiscounts(self, discounts):
2537 
    """
2538 
    Accepts a list of thrift objects of Discount type and saves them
2539 
 
2540 
    Parameters:
2541 
     - discounts
2542 
    """
2543 
    self.send_saveDiscounts(discounts)
2544 
    self.recv_saveDiscounts()
2545 
 
2546 
  def send_saveDiscounts(self, discounts):
2547 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2548 
    args = saveDiscounts_args()
2549 
    args.discounts = discounts
2550 
    args.write(self._oprot)
2551 
    self._oprot.writeMessageEnd()
2552 
    self._oprot.trans.flush()
2553 
 
2554 
  def recv_saveDiscounts(self, ):
2555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2556 
    if mtype == TMessageType.EXCEPTION:
2557 
      x = TApplicationException()
2558 
      x.read(self._iprot)
2559 
      self._iprot.readMessageEnd()
2560 
      raise x
2561 
    result = saveDiscounts_result()
2562 
    result.read(self._iprot)
2563 
    self._iprot.readMessageEnd()
2564 
    if result.scx is not None:
2565 
      raise result.scx
2566 
    return
2567 
 
21454 amit.gupta 2568 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 2569 
    """
690 chandransh 2570 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2571 
 
559 chandransh 2572 
    Parameters:
2573 
     - cartId
2815 vikas 2574 
     - sessionSource
2575 
     - sessionStartTime
3858 vikas 2576 
     - firstSource
2577 
     - firstSourceTime
5326 rajveer 2578 
     - userId
6389 rajveer 2579 
     - schemeId
11526 amit.gupta 2580 
     - orderSource
21454 amit.gupta 2581 
     - selfPickup
559 chandransh 2582 
    """
21454 amit.gupta 2583 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup)
690 chandransh 2584 
    return self.recv_createOrders()
559 chandransh 2585 
 
21454 amit.gupta 2586 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
690 chandransh 2587 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2588 
    args = createOrders_args()
559 chandransh 2589 
    args.cartId = cartId
2815 vikas 2590 
    args.sessionSource = sessionSource
2591 
    args.sessionStartTime = sessionStartTime
3858 vikas 2592 
    args.firstSource = firstSource
2593 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2594 
    args.userId = userId
6389 rajveer 2595 
    args.schemeId = schemeId
11526 amit.gupta 2596 
    args.orderSource = orderSource
21454 amit.gupta 2597 
    args.selfPickup = selfPickup
559 chandransh 2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
690 chandransh 2602 
  def recv_createOrders(self, ):
559 chandransh 2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
690 chandransh 2609 
    result = createOrders_result()
559 chandransh 2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
3431 rajveer 2612 
    if result.success is not None:
130 ashish 2613 
      return result.success
3431 rajveer 2614 
    if result.scx is not None:
559 chandransh 2615 
      raise result.scx
690 chandransh 2616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2617 
 
3557 rajveer 2618 
  def validateCart(self, cartId, sourceId):
130 ashish 2619 
    """
690 chandransh 2620 
    Validates that:
2621 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2622 
    2. All of the lines in the cart are active items.
690 chandransh 2623 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2624 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2625 
 
130 ashish 2626 
    Parameters:
559 chandransh 2627 
     - cartId
3557 rajveer 2628 
     - sourceId
130 ashish 2629 
    """
3557 rajveer 2630 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2631 
    return self.recv_validateCart()
130 ashish 2632 
 
3557 rajveer 2633 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2634 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2635 
    args = validateCart_args()
2636 
    args.cartId = cartId
3557 rajveer 2637 
    args.sourceId = sourceId
130 ashish 2638 
    args.write(self._oprot)
2639 
    self._oprot.writeMessageEnd()
2640 
    self._oprot.trans.flush()
2641 
 
559 chandransh 2642 
  def recv_validateCart(self, ):
130 ashish 2643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2644 
    if mtype == TMessageType.EXCEPTION:
2645 
      x = TApplicationException()
2646 
      x.read(self._iprot)
2647 
      self._iprot.readMessageEnd()
2648 
      raise x
559 chandransh 2649 
    result = validateCart_result()
130 ashish 2650 
    result.read(self._iprot)
2651 
    self._iprot.readMessageEnd()
3431 rajveer 2652 
    if result.success is not None:
130 ashish 2653 
      return result.success
3431 rajveer 2654 
    if result.scex is not None:
575 chandransh 2655 
      raise result.scex
559 chandransh 2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2657 
 
11980 amit.gupta 2658 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2659 
    """
2660 
    Validates that:
2661 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2662 
    2. All of the lines in the cart are active items.
2663 
    3. The estimate for any of the lines in cart doesn't change.
2664 
    If all three are true, returns empty string; else returns appropriate message.
2665 
 
2666 
    Parameters:
2667 
     - cartId
2668 
     - sourceId
2669 
     - dealCoupon
2670 
    """
2671 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2672 
    return self.recv_validateCartWithDealerCoupon()
2673 
 
2674 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2675 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2676 
    args = validateCartWithDealerCoupon_args()
2677 
    args.cartId = cartId
2678 
    args.sourceId = sourceId
2679 
    args.dealCoupon = dealCoupon
2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
2684 
  def recv_validateCartWithDealerCoupon(self, ):
2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
2691 
    result = validateCartWithDealerCoupon_result()
2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.success is not None:
2695 
      return result.success
2696 
    if result.scex is not None:
2697 
      raise result.scex
2698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2699 
 
690 chandransh 2700 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2701 
    """
690 chandransh 2702 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2703 
 
575 chandransh 2704 
    Parameters:
690 chandransh 2705 
     - fromCartId
2706 
     - toCartId
2707 
    """
2708 
    self.send_mergeCart(fromCartId, toCartId)
2709 
    self.recv_mergeCart()
2710 
 
2711 
  def send_mergeCart(self, fromCartId, toCartId):
2712 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2713 
    args = mergeCart_args()
2714 
    args.fromCartId = fromCartId
2715 
    args.toCartId = toCartId
2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2720 
  def recv_mergeCart(self, ):
2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2727 
    result = mergeCart_result()
2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
2730 
    return
2731 
 
2732 
  def checkOut(self, cartId):
2733 
    """
2734 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2735 
 
690 chandransh 2736 
    Parameters:
575 chandransh 2737 
     - cartId
2738 
    """
690 chandransh 2739 
    self.send_checkOut(cartId)
2740 
    return self.recv_checkOut()
575 chandransh 2741 
 
690 chandransh 2742 
  def send_checkOut(self, cartId):
2743 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2744 
    args = checkOut_args()
575 chandransh 2745 
    args.cartId = cartId
2746 
    args.write(self._oprot)
2747 
    self._oprot.writeMessageEnd()
2748 
    self._oprot.trans.flush()
2749 
 
690 chandransh 2750 
  def recv_checkOut(self, ):
575 chandransh 2751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2752 
    if mtype == TMessageType.EXCEPTION:
2753 
      x = TApplicationException()
2754 
      x.read(self._iprot)
2755 
      self._iprot.readMessageEnd()
2756 
      raise x
690 chandransh 2757 
    result = checkOut_result()
575 chandransh 2758 
    result.read(self._iprot)
2759 
    self._iprot.readMessageEnd()
3431 rajveer 2760 
    if result.success is not None:
575 chandransh 2761 
      return result.success
3431 rajveer 2762 
    if result.scex is not None:
575 chandransh 2763 
      raise result.scex
690 chandransh 2764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2765 
 
690 chandransh 2766 
  def resetCart(self, cartId, items):
559 chandransh 2767 
    """
690 chandransh 2768 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2769 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2770 
 
559 chandransh 2771 
    Parameters:
690 chandransh 2772 
     - cartId
2773 
     - items
559 chandransh 2774 
    """
690 chandransh 2775 
    self.send_resetCart(cartId, items)
2776 
    return self.recv_resetCart()
130 ashish 2777 
 
690 chandransh 2778 
  def send_resetCart(self, cartId, items):
2779 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2780 
    args = resetCart_args()
2781 
    args.cartId = cartId
2782 
    args.items = items
559 chandransh 2783 
    args.write(self._oprot)
2784 
    self._oprot.writeMessageEnd()
2785 
    self._oprot.trans.flush()
2786 
 
690 chandransh 2787 
  def recv_resetCart(self, ):
559 chandransh 2788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2789 
    if mtype == TMessageType.EXCEPTION:
2790 
      x = TApplicationException()
2791 
      x.read(self._iprot)
2792 
      self._iprot.readMessageEnd()
2793 
      raise x
690 chandransh 2794 
    result = resetCart_result()
559 chandransh 2795 
    result.read(self._iprot)
2796 
    self._iprot.readMessageEnd()
3431 rajveer 2797 
    if result.success is not None:
690 chandransh 2798 
      return result.success
3431 rajveer 2799 
    if result.scex is not None:
690 chandransh 2800 
      raise result.scex
2801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2802 
 
2981 rajveer 2803 
  def getUserCount(self, userType):
559 chandransh 2804 
    """
2981 rajveer 2805 
    Returns number of registered users.
2806 
    If userType = null, then it returns count of all users, including anonymous
2807 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2808 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2809 
 
559 chandransh 2810 
    Parameters:
2981 rajveer 2811 
     - userType
559 chandransh 2812 
    """
2981 rajveer 2813 
    self.send_getUserCount(userType)
2814 
    return self.recv_getUserCount()
559 chandransh 2815 
 
2981 rajveer 2816 
  def send_getUserCount(self, userType):
2817 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2818 
    args = getUserCount_args()
2819 
    args.userType = userType
559 chandransh 2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2981 rajveer 2824 
  def recv_getUserCount(self, ):
559 chandransh 2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2981 rajveer 2831 
    result = getUserCount_result()
559 chandransh 2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
3431 rajveer 2834 
    if result.success is not None:
559 chandransh 2835 
      return result.success
2981 rajveer 2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2837 
 
2981 rajveer 2838 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2839 
    """
2981 rajveer 2840 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2841 
    If any of startDate or endDate is -1, then that filter is ignored.
2842 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2843 
 
2844 
 
559 chandransh 2845 
    Parameters:
2981 rajveer 2846 
     - userType
2847 
     - startDate
2848 
     - endDate
559 chandransh 2849 
    """
2981 rajveer 2850 
    self.send_getAllUsers(userType, startDate, endDate)
2851 
    return self.recv_getAllUsers()
559 chandransh 2852 
 
2981 rajveer 2853 
  def send_getAllUsers(self, userType, startDate, endDate):
2854 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2855 
    args = getAllUsers_args()
2856 
    args.userType = userType
2857 
    args.startDate = startDate
2858 
    args.endDate = endDate
559 chandransh 2859 
    args.write(self._oprot)
2860 
    self._oprot.writeMessageEnd()
2861 
    self._oprot.trans.flush()
2862 
 
2981 rajveer 2863 
  def recv_getAllUsers(self, ):
559 chandransh 2864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2865 
    if mtype == TMessageType.EXCEPTION:
2866 
      x = TApplicationException()
2867 
      x.read(self._iprot)
2868 
      self._iprot.readMessageEnd()
2869 
      raise x
2981 rajveer 2870 
    result = getAllUsers_result()
559 chandransh 2871 
    result.read(self._iprot)
2872 
    self._iprot.readMessageEnd()
3431 rajveer 2873 
    if result.success is not None:
559 chandransh 2874 
      return result.success
2981 rajveer 2875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2876 
 
2981 rajveer 2877 
  def getMyResearchItems(self, userId):
559 chandransh 2878 
    """
2981 rajveer 2879 
    Returns list of item ids in myresearch for the user
3431 rajveer 2880 
 
559 chandransh 2881 
    Parameters:
772 rajveer 2882 
     - userId
559 chandransh 2883 
    """
2981 rajveer 2884 
    self.send_getMyResearchItems(userId)
2885 
    return self.recv_getMyResearchItems()
559 chandransh 2886 
 
2981 rajveer 2887 
  def send_getMyResearchItems(self, userId):
2888 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2889 
    args = getMyResearchItems_args()
772 rajveer 2890 
    args.userId = userId
559 chandransh 2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2981 rajveer 2895 
  def recv_getMyResearchItems(self, ):
559 chandransh 2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2981 rajveer 2902 
    result = getMyResearchItems_result()
559 chandransh 2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
3431 rajveer 2905 
    if result.success is not None:
559 chandransh 2906 
      return result.success
3431 rajveer 2907 
    if result.scx is not None:
559 chandransh 2908 
      raise result.scx
2981 rajveer 2909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2910 
 
2981 rajveer 2911 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2912 
    """
2981 rajveer 2913 
    add item to my research for a user
3431 rajveer 2914 
 
559 chandransh 2915 
    Parameters:
2981 rajveer 2916 
     - userId
2917 
     - itemId
559 chandransh 2918 
    """
2981 rajveer 2919 
    self.send_updateMyResearch(userId, itemId)
2920 
    return self.recv_updateMyResearch()
559 chandransh 2921 
 
2981 rajveer 2922 
  def send_updateMyResearch(self, userId, itemId):
2923 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2924 
    args = updateMyResearch_args()
2925 
    args.userId = userId
2926 
    args.itemId = itemId
559 chandransh 2927 
    args.write(self._oprot)
2928 
    self._oprot.writeMessageEnd()
2929 
    self._oprot.trans.flush()
2930 
 
2981 rajveer 2931 
  def recv_updateMyResearch(self, ):
559 chandransh 2932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2933 
    if mtype == TMessageType.EXCEPTION:
2934 
      x = TApplicationException()
2935 
      x.read(self._iprot)
2936 
      self._iprot.readMessageEnd()
2937 
      raise x
2981 rajveer 2938 
    result = updateMyResearch_result()
559 chandransh 2939 
    result.read(self._iprot)
2940 
    self._iprot.readMessageEnd()
3431 rajveer 2941 
    if result.success is not None:
2981 rajveer 2942 
      return result.success
3431 rajveer 2943 
    if result.scx is not None:
2981 rajveer 2944 
      raise result.scx
2945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2946 
 
2981 rajveer 2947 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2948 
    """
2981 rajveer 2949 
    delete item from my research for a user
3431 rajveer 2950 
 
1596 ankur.sing 2951 
    Parameters:
2981 rajveer 2952 
     - userId
2953 
     - itemId
1596 ankur.sing 2954 
    """
2981 rajveer 2955 
    self.send_deleteItemFromMyResearch(userId, itemId)
2956 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2957 
 
2981 rajveer 2958 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2959 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2960 
    args = deleteItemFromMyResearch_args()
2961 
    args.userId = userId
2962 
    args.itemId = itemId
1596 ankur.sing 2963 
    args.write(self._oprot)
2964 
    self._oprot.writeMessageEnd()
2965 
    self._oprot.trans.flush()
2966 
 
2981 rajveer 2967 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2969 
    if mtype == TMessageType.EXCEPTION:
2970 
      x = TApplicationException()
2971 
      x.read(self._iprot)
2972 
      self._iprot.readMessageEnd()
2973 
      raise x
2981 rajveer 2974 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2975 
    result.read(self._iprot)
2976 
    self._iprot.readMessageEnd()
3431 rajveer 2977 
    if result.scx is not None:
2981 rajveer 2978 
      raise result.scx
2979 
    return
1596 ankur.sing 2980 
 
2981 rajveer 2981 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2982 
    """
2981 rajveer 2983 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2984 
 
1673 ankur.sing 2985 
    Parameters:
2981 rajveer 2986 
     - userId
1673 ankur.sing 2987 
    """
2981 rajveer 2988 
    self.send_getBrowseHistoryItems(userId)
2989 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2990 
 
2981 rajveer 2991 
  def send_getBrowseHistoryItems(self, userId):
2992 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2993 
    args = getBrowseHistoryItems_args()
2994 
    args.userId = userId
1673 ankur.sing 2995 
    args.write(self._oprot)
2996 
    self._oprot.writeMessageEnd()
2997 
    self._oprot.trans.flush()
2998 
 
2981 rajveer 2999 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 3000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3001 
    if mtype == TMessageType.EXCEPTION:
3002 
      x = TApplicationException()
3003 
      x.read(self._iprot)
3004 
      self._iprot.readMessageEnd()
3005 
      raise x
2981 rajveer 3006 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 3007 
    result.read(self._iprot)
3008 
    self._iprot.readMessageEnd()
3431 rajveer 3009 
    if result.success is not None:
1673 ankur.sing 3010 
      return result.success
3431 rajveer 3011 
    if result.scx is not None:
2981 rajveer 3012 
      raise result.scx
3013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 3014 
 
2981 rajveer 3015 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 3016 
    """
2981 rajveer 3017 
    add item to browse history for a user
3431 rajveer 3018 
 
2642 varun.gupt 3019 
    Parameters:
2981 rajveer 3020 
     - userId
3021 
     - itemId
2642 varun.gupt 3022 
    """
2981 rajveer 3023 
    self.send_updateBrowseHistory(userId, itemId)
3024 
    self.recv_updateBrowseHistory()
1673 ankur.sing 3025 
 
2981 rajveer 3026 
  def send_updateBrowseHistory(self, userId, itemId):
3027 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
3028 
    args = updateBrowseHistory_args()
3029 
    args.userId = userId
3030 
    args.itemId = itemId
2642 varun.gupt 3031 
    args.write(self._oprot)
3032 
    self._oprot.writeMessageEnd()
3033 
    self._oprot.trans.flush()
3034 
 
2981 rajveer 3035 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 3036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3037 
    if mtype == TMessageType.EXCEPTION:
3038 
      x = TApplicationException()
3039 
      x.read(self._iprot)
3040 
      self._iprot.readMessageEnd()
3041 
      raise x
2981 rajveer 3042 
    result = updateBrowseHistory_result()
2642 varun.gupt 3043 
    result.read(self._iprot)
3044 
    self._iprot.readMessageEnd()
3045 
    return
3046 
 
3385 varun.gupt 3047 
  def getCartsWithCouponCount(self, couponCode):
3048 
    """
3049 
    Returns count of Carts with given coupon applied
3431 rajveer 3050 
 
3385 varun.gupt 3051 
    Parameters:
3052 
     - couponCode
3053 
    """
3054 
    self.send_getCartsWithCouponCount(couponCode)
3055 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 3056 
 
3385 varun.gupt 3057 
  def send_getCartsWithCouponCount(self, couponCode):
3058 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
3059 
    args = getCartsWithCouponCount_args()
3060 
    args.couponCode = couponCode
3061 
    args.write(self._oprot)
3062 
    self._oprot.writeMessageEnd()
3063 
    self._oprot.trans.flush()
3064 
 
3065 
  def recv_getCartsWithCouponCount(self, ):
3066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3067 
    if mtype == TMessageType.EXCEPTION:
3068 
      x = TApplicationException()
3069 
      x.read(self._iprot)
3070 
      self._iprot.readMessageEnd()
3071 
      raise x
3072 
    result = getCartsWithCouponCount_result()
3073 
    result.read(self._iprot)
3074 
    self._iprot.readMessageEnd()
3431 rajveer 3075 
    if result.success is not None:
3385 varun.gupt 3076 
      return result.success
3077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
3078 
 
3499 mandeep.dh 3079 
  def increaseTrustLevel(self, userId, trustLevelDelta):
3080 
    """
3081 
    Updates COD trust level of a user
3385 varun.gupt 3082 
 
3499 mandeep.dh 3083 
    Parameters:
3084 
     - userId
3085 
     - trustLevelDelta
3086 
    """
3087 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
3088 
 
3089 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
3090 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
3091 
    args = increaseTrustLevel_args()
3092 
    args.userId = userId
3093 
    args.trustLevelDelta = trustLevelDelta
3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
5407 amar.kumar 3097 
  def getTrustLevel(self, userId):
3098 
    """
3099 
    Get trust level of a user
3100 
 
3101 
    Parameters:
3102 
     - userId
3103 
    """
3104 
    self.send_getTrustLevel(userId)
3105 
    return self.recv_getTrustLevel()
3106 
 
3107 
  def send_getTrustLevel(self, userId):
3108 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3109 
    args = getTrustLevel_args()
3110 
    args.userId = userId
3111 
    args.write(self._oprot)
3112 
    self._oprot.writeMessageEnd()
3113 
    self._oprot.trans.flush()
3114 
 
3115 
  def recv_getTrustLevel(self, ):
3116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3117 
    if mtype == TMessageType.EXCEPTION:
3118 
      x = TApplicationException()
3119 
      x.read(self._iprot)
3120 
      self._iprot.readMessageEnd()
3121 
      raise x
3122 
    result = getTrustLevel_result()
3123 
    result.read(self._iprot)
3124 
    self._iprot.readMessageEnd()
3125 
    if result.success is not None:
3126 
      return result.success
3127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3128 
 
4668 varun.gupt 3129 
  def showCODOption(self, cartId, sourceId, pincode):
3130 
    """
3131 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3132 
 
4668 varun.gupt 3133 
    Parameters:
3134 
     - cartId
3135 
     - sourceId
3136 
     - pincode
3137 
    """
3138 
    self.send_showCODOption(cartId, sourceId, pincode)
3139 
    return self.recv_showCODOption()
3140 
 
3141 
  def send_showCODOption(self, cartId, sourceId, pincode):
3142 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3143 
    args = showCODOption_args()
3144 
    args.cartId = cartId
3145 
    args.sourceId = sourceId
3146 
    args.pincode = pincode
3147 
    args.write(self._oprot)
3148 
    self._oprot.writeMessageEnd()
3149 
    self._oprot.trans.flush()
3150 
 
3151 
  def recv_showCODOption(self, ):
3152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3153 
    if mtype == TMessageType.EXCEPTION:
3154 
      x = TApplicationException()
3155 
      x.read(self._iprot)
3156 
      self._iprot.readMessageEnd()
3157 
      raise x
3158 
    result = showCODOption_result()
3159 
    result.read(self._iprot)
3160 
    self._iprot.readMessageEnd()
3161 
    if result.success is not None:
3162 
      return result.success
3163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3164 
 
5623 anupam.sin 3165 
  def getUserEmails(self, startDate, endDate):
3166 
    """
3167 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3168 
 
5623 anupam.sin 3169 
    Parameters:
3170 
     - startDate
3171 
     - endDate
3172 
    """
3173 
    self.send_getUserEmails(startDate, endDate)
3174 
    return self.recv_getUserEmails()
3175 
 
3176 
  def send_getUserEmails(self, startDate, endDate):
3177 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3178 
    args = getUserEmails_args()
3179 
    args.startDate = startDate
3180 
    args.endDate = endDate
3181 
    args.write(self._oprot)
3182 
    self._oprot.writeMessageEnd()
3183 
    self._oprot.trans.flush()
3184 
 
3185 
  def recv_getUserEmails(self, ):
3186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3187 
    if mtype == TMessageType.EXCEPTION:
3188 
      x = TApplicationException()
3189 
      x.read(self._iprot)
3190 
      self._iprot.readMessageEnd()
3191 
      raise x
3192 
    result = getUserEmails_result()
3193 
    result.read(self._iprot)
3194 
    self._iprot.readMessageEnd()
3195 
    if result.success is not None:
3196 
      return result.success
3197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3198 
 
9299 kshitij.so 3199 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3200 
    """
3201 
    Mark a cart lineitem as insured. Returns true/false.
3202 
 
3203 
    Parameters:
3204 
     - itemId
3205 
     - cartId
3206 
     - toInsure
9299 kshitij.so 3207 
     - insurerType
6903 anupam.sin 3208 
    """
9299 kshitij.so 3209 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3210 
    return self.recv_insureItem()
3211 
 
9299 kshitij.so 3212 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3213 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3214 
    args = insureItem_args()
3215 
    args.itemId = itemId
3216 
    args.cartId = cartId
3217 
    args.toInsure = toInsure
9299 kshitij.so 3218 
    args.insurerType = insurerType
6903 anupam.sin 3219 
    args.write(self._oprot)
3220 
    self._oprot.writeMessageEnd()
3221 
    self._oprot.trans.flush()
3222 
 
3223 
  def recv_insureItem(self, ):
3224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3225 
    if mtype == TMessageType.EXCEPTION:
3226 
      x = TApplicationException()
3227 
      x.read(self._iprot)
3228 
      self._iprot.readMessageEnd()
3229 
      raise x
3230 
    result = insureItem_result()
3231 
    result.read(self._iprot)
3232 
    self._iprot.readMessageEnd()
3233 
    if result.success is not None:
3234 
      return result.success
3235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3236 
 
3237 
  def cancelInsurance(self, cartId):
3238 
    """
3239 
    Cancel insurance for all items in the cart
3240 
 
3241 
    Parameters:
3242 
     - cartId
3243 
    """
3244 
    self.send_cancelInsurance(cartId)
3245 
    return self.recv_cancelInsurance()
3246 
 
3247 
  def send_cancelInsurance(self, cartId):
3248 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3249 
    args = cancelInsurance_args()
3250 
    args.cartId = cartId
3251 
    args.write(self._oprot)
3252 
    self._oprot.writeMessageEnd()
3253 
    self._oprot.trans.flush()
3254 
 
3255 
  def recv_cancelInsurance(self, ):
3256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3257 
    if mtype == TMessageType.EXCEPTION:
3258 
      x = TApplicationException()
3259 
      x.read(self._iprot)
3260 
      self._iprot.readMessageEnd()
3261 
      raise x
3262 
    result = cancelInsurance_result()
3263 
    result.read(self._iprot)
3264 
    self._iprot.readMessageEnd()
3265 
    if result.success is not None:
3266 
      return result.success
3267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3268 
 
3269 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3270 
    """
3271 
    Stores insurance specific details like date of birth and guardianName
3272 
 
3273 
    Parameters:
3274 
     - addressId
3275 
     - dob
3276 
     - guardianName
3277 
    """
3278 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3279 
    return self.recv_storeInsuranceSpecificDetails()
3280 
 
3281 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3282 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3283 
    args = storeInsuranceSpecificDetails_args()
3284 
    args.addressId = addressId
3285 
    args.dob = dob
3286 
    args.guardianName = guardianName
3287 
    args.write(self._oprot)
3288 
    self._oprot.writeMessageEnd()
3289 
    self._oprot.trans.flush()
3290 
 
3291 
  def recv_storeInsuranceSpecificDetails(self, ):
3292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3293 
    if mtype == TMessageType.EXCEPTION:
3294 
      x = TApplicationException()
3295 
      x.read(self._iprot)
3296 
      self._iprot.readMessageEnd()
3297 
      raise x
3298 
    result = storeInsuranceSpecificDetails_result()
3299 
    result.read(self._iprot)
3300 
    self._iprot.readMessageEnd()
3301 
    if result.success is not None:
3302 
      return result.success
3303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3304 
 
3305 
  def isInsuranceDetailPresent(self, addressId):
3306 
    """
3307 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3308 
 
3309 
    Parameters:
3310 
     - addressId
3311 
    """
3312 
    self.send_isInsuranceDetailPresent(addressId)
3313 
    return self.recv_isInsuranceDetailPresent()
3314 
 
3315 
  def send_isInsuranceDetailPresent(self, addressId):
3316 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3317 
    args = isInsuranceDetailPresent_args()
3318 
    args.addressId = addressId
3319 
    args.write(self._oprot)
3320 
    self._oprot.writeMessageEnd()
3321 
    self._oprot.trans.flush()
3322 
 
3323 
  def recv_isInsuranceDetailPresent(self, ):
3324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3325 
    if mtype == TMessageType.EXCEPTION:
3326 
      x = TApplicationException()
3327 
      x.read(self._iprot)
3328 
      self._iprot.readMessageEnd()
3329 
      raise x
3330 
    result = isInsuranceDetailPresent_result()
3331 
    result.read(self._iprot)
3332 
    self._iprot.readMessageEnd()
3333 
    if result.success is not None:
3334 
      return result.success
3335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3336 
 
9791 rajveer 3337 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3338 
    """
9791 rajveer 3339 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3340 
 
6821 amar.kumar 3341 
    Parameters:
3342 
     - startDate
3343 
     - endDate
3344 
    """
9791 rajveer 3345 
    self.send_getProductsAddedToCart(startDate, endDate)
3346 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3347 
 
9791 rajveer 3348 
  def send_getProductsAddedToCart(self, startDate, endDate):
3349 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3350 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3351 
    args.startDate = startDate
3352 
    args.endDate = endDate
3353 
    args.write(self._oprot)
3354 
    self._oprot.writeMessageEnd()
3355 
    self._oprot.trans.flush()
3356 
 
9791 rajveer 3357 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3359 
    if mtype == TMessageType.EXCEPTION:
3360 
      x = TApplicationException()
3361 
      x.read(self._iprot)
3362 
      self._iprot.readMessageEnd()
3363 
      raise x
9791 rajveer 3364 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3365 
    result.read(self._iprot)
3366 
    self._iprot.readMessageEnd()
3367 
    if result.success is not None:
3368 
      return result.success
9791 rajveer 3369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3370 
 
11980 amit.gupta 3371 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3372 
    """
3373 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3374 
 
11592 amit.gupta 3375 
    Parameters:
3376 
     - cartId
3377 
     - sourceId
11980 amit.gupta 3378 
     - dealerCoupon
11592 amit.gupta 3379 
    """
11980 amit.gupta 3380 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3381 
    return self.recv_validateCartPlus()
3382 
 
11980 amit.gupta 3383 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3384 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3385 
    args = validateCartPlus_args()
3386 
    args.cartId = cartId
3387 
    args.sourceId = sourceId
11980 amit.gupta 3388 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3389 
    args.write(self._oprot)
3390 
    self._oprot.writeMessageEnd()
3391 
    self._oprot.trans.flush()
3392 
 
3393 
  def recv_validateCartPlus(self, ):
3394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3395 
    if mtype == TMessageType.EXCEPTION:
3396 
      x = TApplicationException()
3397 
      x.read(self._iprot)
3398 
      self._iprot.readMessageEnd()
3399 
      raise x
3400 
    result = validateCartPlus_result()
3401 
    result.read(self._iprot)
3402 
    self._iprot.readMessageEnd()
3403 
    if result.success is not None:
3404 
      return result.success
3405 
    if result.scex is not None:
3406 
      raise result.scex
3407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3408 
 
11679 vikram.rag 3409 
  def isPrivateDealUser(self, userId):
3410 
    """
3411 
    Parameters:
3412 
     - userId
3413 
    """
3414 
    self.send_isPrivateDealUser(userId)
3415 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3416 
 
11679 vikram.rag 3417 
  def send_isPrivateDealUser(self, userId):
3418 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3419 
    args = isPrivateDealUser_args()
3420 
    args.userId = userId
3421 
    args.write(self._oprot)
3422 
    self._oprot.writeMessageEnd()
3423 
    self._oprot.trans.flush()
3424 
 
3425 
  def recv_isPrivateDealUser(self, ):
3426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3427 
    if mtype == TMessageType.EXCEPTION:
3428 
      x = TApplicationException()
3429 
      x.read(self._iprot)
3430 
      self._iprot.readMessageEnd()
3431 
      raise x
3432 
    result = isPrivateDealUser_result()
3433 
    result.read(self._iprot)
3434 
    self._iprot.readMessageEnd()
3435 
    if result.success is not None:
3436 
      return result.success
3437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3438 
 
11890 kshitij.so 3439 
  def addPrivateDealUser(self, userId):
3440 
    """
3441 
    Parameters:
3442 
     - userId
3443 
    """
3444 
    self.send_addPrivateDealUser(userId)
3445 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3446 
 
11890 kshitij.so 3447 
  def send_addPrivateDealUser(self, userId):
3448 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3449 
    args = addPrivateDealUser_args()
3450 
    args.userId = userId
3451 
    args.write(self._oprot)
3452 
    self._oprot.writeMessageEnd()
3453 
    self._oprot.trans.flush()
3454 
 
3455 
  def recv_addPrivateDealUser(self, ):
3456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3457 
    if mtype == TMessageType.EXCEPTION:
3458 
      x = TApplicationException()
3459 
      x.read(self._iprot)
3460 
      self._iprot.readMessageEnd()
3461 
      raise x
3462 
    result = addPrivateDealUser_result()
3463 
    result.read(self._iprot)
3464 
    self._iprot.readMessageEnd()
3465 
    if result.success is not None:
3466 
      return result.success
3467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3468 
 
3469 
  def changePrivateDealUserStatus(self, userId, isActive):
3470 
    """
3471 
    Parameters:
3472 
     - userId
3473 
     - isActive
3474 
    """
3475 
    self.send_changePrivateDealUserStatus(userId, isActive)
3476 
    return self.recv_changePrivateDealUserStatus()
3477 
 
3478 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3479 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3480 
    args = changePrivateDealUserStatus_args()
3481 
    args.userId = userId
3482 
    args.isActive = isActive
3483 
    args.write(self._oprot)
3484 
    self._oprot.writeMessageEnd()
3485 
    self._oprot.trans.flush()
3486 
 
3487 
  def recv_changePrivateDealUserStatus(self, ):
3488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3489 
    if mtype == TMessageType.EXCEPTION:
3490 
      x = TApplicationException()
3491 
      x.read(self._iprot)
3492 
      self._iprot.readMessageEnd()
3493 
      raise x
3494 
    result = changePrivateDealUserStatus_result()
3495 
    result.read(self._iprot)
3496 
    self._iprot.readMessageEnd()
3497 
    if result.success is not None:
3498 
      return result.success
3499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3500 
 
3501 
  def getPrivateDealUser(self, userId):
3502 
    """
3503 
    Parameters:
3504 
     - userId
3505 
    """
3506 
    self.send_getPrivateDealUser(userId)
3507 
    return self.recv_getPrivateDealUser()
3508 
 
3509 
  def send_getPrivateDealUser(self, userId):
3510 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3511 
    args = getPrivateDealUser_args()
3512 
    args.userId = userId
3513 
    args.write(self._oprot)
3514 
    self._oprot.writeMessageEnd()
3515 
    self._oprot.trans.flush()
3516 
 
3517 
  def recv_getPrivateDealUser(self, ):
3518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3519 
    if mtype == TMessageType.EXCEPTION:
3520 
      x = TApplicationException()
3521 
      x.read(self._iprot)
3522 
      self._iprot.readMessageEnd()
3523 
      raise x
3524 
    result = getPrivateDealUser_result()
3525 
    result.read(self._iprot)
3526 
    self._iprot.readMessageEnd()
3527 
    if result.success is not None:
3528 
      return result.success
3529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3530 
 
12696 amit.gupta 3531 
  def registerCounter(self, counter, userId):
3532 
    """
3533 
    Parameters:
3534 
     - counter
3535 
     - userId
3536 
    """
3537 
    self.send_registerCounter(counter, userId)
3538 
    return self.recv_registerCounter()
11890 kshitij.so 3539 
 
12696 amit.gupta 3540 
  def send_registerCounter(self, counter, userId):
3541 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3542 
    args = registerCounter_args()
3543 
    args.counter = counter
3544 
    args.userId = userId
3545 
    args.write(self._oprot)
3546 
    self._oprot.writeMessageEnd()
3547 
    self._oprot.trans.flush()
3548 
 
3549 
  def recv_registerCounter(self, ):
3550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3551 
    if mtype == TMessageType.EXCEPTION:
3552 
      x = TApplicationException()
3553 
      x.read(self._iprot)
3554 
      self._iprot.readMessageEnd()
3555 
      raise x
3556 
    result = registerCounter_result()
3557 
    result.read(self._iprot)
3558 
    self._iprot.readMessageEnd()
3559 
    if result.success is not None:
3560 
      return result.success
3561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3562 
 
12722 amit.gupta 3563 
  def searchCounter(self, type1, searchString):
3564 
    """
3565 
    Parameters:
3566 
     - type1
3567 
     - searchString
3568 
    """
3569 
    self.send_searchCounter(type1, searchString)
3570 
    return self.recv_searchCounter()
12696 amit.gupta 3571 
 
12722 amit.gupta 3572 
  def send_searchCounter(self, type1, searchString):
3573 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3574 
    args = searchCounter_args()
3575 
    args.type1 = type1
3576 
    args.searchString = searchString
3577 
    args.write(self._oprot)
3578 
    self._oprot.writeMessageEnd()
3579 
    self._oprot.trans.flush()
3580 
 
3581 
  def recv_searchCounter(self, ):
3582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3583 
    if mtype == TMessageType.EXCEPTION:
3584 
      x = TApplicationException()
3585 
      x.read(self._iprot)
3586 
      self._iprot.readMessageEnd()
3587 
      raise x
3588 
    result = searchCounter_result()
3589 
    result.read(self._iprot)
3590 
    self._iprot.readMessageEnd()
3591 
    if result.success is not None:
3592 
      return result.success
3593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3594 
 
18977 amit.gupta 3595 
  def getCounterByUserId(self, userId):
3596 
    """
3597 
    Parameters:
3598 
     - userId
3599 
    """
3600 
    self.send_getCounterByUserId(userId)
3601 
    return self.recv_getCounterByUserId()
3602 
 
3603 
  def send_getCounterByUserId(self, userId):
3604 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3605 
    args = getCounterByUserId_args()
3606 
    args.userId = userId
3607 
    args.write(self._oprot)
3608 
    self._oprot.writeMessageEnd()
3609 
    self._oprot.trans.flush()
3610 
 
3611 
  def recv_getCounterByUserId(self, ):
3612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3613 
    if mtype == TMessageType.EXCEPTION:
3614 
      x = TApplicationException()
3615 
      x.read(self._iprot)
3616 
      self._iprot.readMessageEnd()
3617 
      raise x
3618 
    result = getCounterByUserId_result()
3619 
    result.read(self._iprot)
3620 
    self._iprot.readMessageEnd()
3621 
    if result.success is not None:
3622 
      return result.success
3623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3624 
 
12722 amit.gupta 3625 
  def getAllUsersByCounter(self, counterId):
3626 
    """
3627 
    Parameters:
3628 
     - counterId
3629 
    """
3630 
    self.send_getAllUsersByCounter(counterId)
3631 
    return self.recv_getAllUsersByCounter()
3632 
 
3633 
  def send_getAllUsersByCounter(self, counterId):
3634 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3635 
    args = getAllUsersByCounter_args()
3636 
    args.counterId = counterId
3637 
    args.write(self._oprot)
3638 
    self._oprot.writeMessageEnd()
3639 
    self._oprot.trans.flush()
3640 
 
3641 
  def recv_getAllUsersByCounter(self, ):
3642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3643 
    if mtype == TMessageType.EXCEPTION:
3644 
      x = TApplicationException()
3645 
      x.read(self._iprot)
3646 
      self._iprot.readMessageEnd()
3647 
      raise x
3648 
    result = getAllUsersByCounter_result()
3649 
    result.read(self._iprot)
3650 
    self._iprot.readMessageEnd()
3651 
    if result.success is not None:
3652 
      return result.success
3653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3654 
 
15251 manish.sha 3655 
  def getActiveAccessTokenForUser(self, userId, source):
3656 
    """
3657 
    Parameters:
3658 
     - userId
3659 
     - source
3660 
    """
3661 
    self.send_getActiveAccessTokenForUser(userId, source)
3662 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3663 
 
15251 manish.sha 3664 
  def send_getActiveAccessTokenForUser(self, userId, source):
3665 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3666 
    args = getActiveAccessTokenForUser_args()
3667 
    args.userId = userId
3668 
    args.source = source
3669 
    args.write(self._oprot)
3670 
    self._oprot.writeMessageEnd()
3671 
    self._oprot.trans.flush()
3672 
 
3673 
  def recv_getActiveAccessTokenForUser(self, ):
3674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3675 
    if mtype == TMessageType.EXCEPTION:
3676 
      x = TApplicationException()
3677 
      x.read(self._iprot)
3678 
      self._iprot.readMessageEnd()
3679 
      raise x
3680 
    result = getActiveAccessTokenForUser_result()
3681 
    result.read(self._iprot)
3682 
    self._iprot.readMessageEnd()
3683 
    if result.success is not None:
3684 
      return result.success
3685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3686 
 
3687 
  def validateAccessToken(self, accessToken):
3688 
    """
3689 
    Parameters:
3690 
     - accessToken
3691 
    """
3692 
    self.send_validateAccessToken(accessToken)
3693 
    return self.recv_validateAccessToken()
3694 
 
3695 
  def send_validateAccessToken(self, accessToken):
3696 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3697 
    args = validateAccessToken_args()
3698 
    args.accessToken = accessToken
3699 
    args.write(self._oprot)
3700 
    self._oprot.writeMessageEnd()
3701 
    self._oprot.trans.flush()
3702 
 
3703 
  def recv_validateAccessToken(self, ):
3704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3705 
    if mtype == TMessageType.EXCEPTION:
3706 
      x = TApplicationException()
3707 
      x.read(self._iprot)
3708 
      self._iprot.readMessageEnd()
3709 
      raise x
3710 
    result = validateAccessToken_result()
3711 
    result.read(self._iprot)
3712 
    self._iprot.readMessageEnd()
3713 
    if result.success is not None:
3714 
      return result.success
3715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3716 
 
17782 amit.gupta 3717 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3718 
    """
3719 
    Parameters:
3720 
     - cartId
3721 
     - itemQty
3722 
     - couponCode
3723 
    """
3724 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3725 
    return self.recv_addItemsToCart()
15251 manish.sha 3726 
 
17782 amit.gupta 3727 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3728 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3729 
    args = addItemsToCart_args()
3730 
    args.cartId = cartId
3731 
    args.itemQty = itemQty
3732 
    args.couponCode = couponCode
3733 
    args.write(self._oprot)
3734 
    self._oprot.writeMessageEnd()
3735 
    self._oprot.trans.flush()
3736 
 
3737 
  def recv_addItemsToCart(self, ):
3738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3739 
    if mtype == TMessageType.EXCEPTION:
3740 
      x = TApplicationException()
3741 
      x.read(self._iprot)
3742 
      self._iprot.readMessageEnd()
3743 
      raise x
3744 
    result = addItemsToCart_result()
3745 
    result.read(self._iprot)
3746 
    self._iprot.readMessageEnd()
3747 
    if result.success is not None:
3748 
      return result.success
3749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3750 
 
3751 
  def validateCartNew(self, cartId, pinCode, sourceId):
3752 
    """
3753 
    Parameters:
3754 
     - cartId
3755 
     - pinCode
3756 
     - sourceId
3757 
    """
3758 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3759 
    return self.recv_validateCartNew()
3760 
 
3761 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3762 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3763 
    args = validateCartNew_args()
3764 
    args.cartId = cartId
3765 
    args.pinCode = pinCode
3766 
    args.sourceId = sourceId
3767 
    args.write(self._oprot)
3768 
    self._oprot.writeMessageEnd()
3769 
    self._oprot.trans.flush()
3770 
 
3771 
  def recv_validateCartNew(self, ):
3772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3773 
    if mtype == TMessageType.EXCEPTION:
3774 
      x = TApplicationException()
3775 
      x.read(self._iprot)
3776 
      self._iprot.readMessageEnd()
3777 
      raise x
3778 
    result = validateCartNew_result()
3779 
    result.read(self._iprot)
3780 
    self._iprot.readMessageEnd()
3781 
    if result.success is not None:
3782 
      return result.success
3783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3784 
 
18644 manish.sha 3785 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3786 
    """
3787 
    Parameters:
3788 
     - userId
3789 
    """
18644 manish.sha 3790 
    self.send_isAddressEditableForCounter(userId)
3791 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3792 
 
18644 manish.sha 3793 
  def send_isAddressEditableForCounter(self, userId):
3794 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3795 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3796 
    args.userId = userId
3797 
    args.write(self._oprot)
3798 
    self._oprot.writeMessageEnd()
3799 
    self._oprot.trans.flush()
3800 
 
18644 manish.sha 3801 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3803 
    if mtype == TMessageType.EXCEPTION:
3804 
      x = TApplicationException()
3805 
      x.read(self._iprot)
3806 
      self._iprot.readMessageEnd()
3807 
      raise x
18644 manish.sha 3808 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3809 
    result.read(self._iprot)
3810 
    self._iprot.readMessageEnd()
3811 
    if result.success is not None:
3812 
      return result.success
18644 manish.sha 3813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3814 
 
3815 
  def getBillingAddressForUser(self, userId):
3816 
    """
3817 
    Parameters:
3818 
     - userId
3819 
    """
3820 
    self.send_getBillingAddressForUser(userId)
3821 
    return self.recv_getBillingAddressForUser()
3822 
 
3823 
  def send_getBillingAddressForUser(self, userId):
3824 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3825 
    args = getBillingAddressForUser_args()
3826 
    args.userId = userId
3827 
    args.write(self._oprot)
3828 
    self._oprot.writeMessageEnd()
3829 
    self._oprot.trans.flush()
3830 
 
3831 
  def recv_getBillingAddressForUser(self, ):
3832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3833 
    if mtype == TMessageType.EXCEPTION:
3834 
      x = TApplicationException()
3835 
      x.read(self._iprot)
3836 
      self._iprot.readMessageEnd()
3837 
      raise x
3838 
    result = getBillingAddressForUser_result()
3839 
    result.read(self._iprot)
3840 
    self._iprot.readMessageEnd()
3841 
    if result.success is not None:
3842 
      return result.success
3843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3844 
 
18590 manish.sha 3845 
  def isCreditorAssigned(self, userId):
3846 
    """
3847 
    Parameters:
3848 
     - userId
3849 
    """
3850 
    self.send_isCreditorAssigned(userId)
3851 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3852 
 
18590 manish.sha 3853 
  def send_isCreditorAssigned(self, userId):
3854 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3855 
    args = isCreditorAssigned_args()
3856 
    args.userId = userId
3857 
    args.write(self._oprot)
3858 
    self._oprot.writeMessageEnd()
3859 
    self._oprot.trans.flush()
3860 
 
3861 
  def recv_isCreditorAssigned(self, ):
3862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3863 
    if mtype == TMessageType.EXCEPTION:
3864 
      x = TApplicationException()
3865 
      x.read(self._iprot)
3866 
      self._iprot.readMessageEnd()
3867 
      raise x
3868 
    result = isCreditorAssigned_result()
3869 
    result.read(self._iprot)
3870 
    self._iprot.readMessageEnd()
3871 
    if result.success is not None:
3872 
      return result.success
3873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3874 
 
18735 manish.sha 3875 
  def isTaxInvoiceEnabledUser(self, userId):
3876 
    """
3877 
    Parameters:
3878 
     - userId
3879 
    """
3880 
    self.send_isTaxInvoiceEnabledUser(userId)
3881 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3882 
 
18735 manish.sha 3883 
  def send_isTaxInvoiceEnabledUser(self, userId):
3884 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3885 
    args = isTaxInvoiceEnabledUser_args()
3886 
    args.userId = userId
3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_isTaxInvoiceEnabledUser(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = isTaxInvoiceEnabledUser_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3901 
    if result.success is not None:
3902 
      return result.success
3903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3904 
 
19182 amit.gupta 3905 
  def taxInvoiceAvailable(self, addressId):
3906 
    """
3907 
    Parameters:
3908 
     - addressId
3909 
    """
3910 
    self.send_taxInvoiceAvailable(addressId)
3911 
    return self.recv_taxInvoiceAvailable()
3912 
 
3913 
  def send_taxInvoiceAvailable(self, addressId):
3914 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3915 
    args = taxInvoiceAvailable_args()
3916 
    args.addressId = addressId
3917 
    args.write(self._oprot)
3918 
    self._oprot.writeMessageEnd()
3919 
    self._oprot.trans.flush()
3920 
 
3921 
  def recv_taxInvoiceAvailable(self, ):
3922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3923 
    if mtype == TMessageType.EXCEPTION:
3924 
      x = TApplicationException()
3925 
      x.read(self._iprot)
3926 
      self._iprot.readMessageEnd()
3927 
      raise x
3928 
    result = taxInvoiceAvailable_result()
3929 
    result.read(self._iprot)
3930 
    self._iprot.readMessageEnd()
3931 
    if result.success is not None:
3932 
      return result.success
3933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3934 
 
18764 kshitij.so 3935 
  def getCartByValue(self, cartIds):
3936 
    """
3937 
    Parameters:
3938 
     - cartIds
3939 
    """
3940 
    self.send_getCartByValue(cartIds)
3941 
    return self.recv_getCartByValue()
18735 manish.sha 3942 
 
18764 kshitij.so 3943 
  def send_getCartByValue(self, cartIds):
3944 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3945 
    args = getCartByValue_args()
3946 
    args.cartIds = cartIds
3947 
    args.write(self._oprot)
3948 
    self._oprot.writeMessageEnd()
3949 
    self._oprot.trans.flush()
3950 
 
3951 
  def recv_getCartByValue(self, ):
3952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3953 
    if mtype == TMessageType.EXCEPTION:
3954 
      x = TApplicationException()
3955 
      x.read(self._iprot)
3956 
      self._iprot.readMessageEnd()
3957 
      raise x
3958 
    result = getCartByValue_result()
3959 
    result.read(self._iprot)
3960 
    self._iprot.readMessageEnd()
3961 
    if result.success is not None:
3962 
      return result.success
3963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3964 
 
19889 manas 3965 
  def getCounterName(self, userIds):
3966 
    """
3967 
    Parameters:
3968 
     - userIds
3969 
    """
3970 
    self.send_getCounterName(userIds)
3971 
    return self.recv_getCounterName()
18764 kshitij.so 3972 
 
19889 manas 3973 
  def send_getCounterName(self, userIds):
3974 
    self._oprot.writeMessageBegin('getCounterName', TMessageType.CALL, self._seqid)
3975 
    args = getCounterName_args()
3976 
    args.userIds = userIds
3977 
    args.write(self._oprot)
3978 
    self._oprot.writeMessageEnd()
3979 
    self._oprot.trans.flush()
3980 
 
3981 
  def recv_getCounterName(self, ):
3982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3983 
    if mtype == TMessageType.EXCEPTION:
3984 
      x = TApplicationException()
3985 
      x.read(self._iprot)
3986 
      self._iprot.readMessageEnd()
3987 
      raise x
3988 
    result = getCounterName_result()
3989 
    result.read(self._iprot)
3990 
    self._iprot.readMessageEnd()
3991 
    if result.success is not None:
3992 
      return result.success
3993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterName failed: unknown result");
3994 
 
20873 kshitij.so 3995 
  def setWalletAmountInCart(self, cartId, wallet_amount):
3996 
    """
3997 
    Parameters:
3998 
     - cartId
3999 
     - wallet_amount
4000 
    """
4001 
    self.send_setWalletAmountInCart(cartId, wallet_amount)
4002 
    return self.recv_setWalletAmountInCart()
19889 manas 4003 
 
20873 kshitij.so 4004 
  def send_setWalletAmountInCart(self, cartId, wallet_amount):
4005 
    self._oprot.writeMessageBegin('setWalletAmountInCart', TMessageType.CALL, self._seqid)
4006 
    args = setWalletAmountInCart_args()
4007 
    args.cartId = cartId
4008 
    args.wallet_amount = wallet_amount
4009 
    args.write(self._oprot)
4010 
    self._oprot.writeMessageEnd()
4011 
    self._oprot.trans.flush()
4012 
 
4013 
  def recv_setWalletAmountInCart(self, ):
4014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4015 
    if mtype == TMessageType.EXCEPTION:
4016 
      x = TApplicationException()
4017 
      x.read(self._iprot)
4018 
      self._iprot.readMessageEnd()
4019 
      raise x
4020 
    result = setWalletAmountInCart_result()
4021 
    result.read(self._iprot)
4022 
    self._iprot.readMessageEnd()
4023 
    if result.success is not None:
4024 
      return result.success
4025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setWalletAmountInCart failed: unknown result");
4026 
 
22452 amit.gupta 4027 
  def addItemPricingToCart(self, cartId, itemPriceQuantityList):
4028 
    """
4029 
    Parameters:
4030 
     - cartId
4031 
     - itemPriceQuantityList
4032 
    """
4033 
    self.send_addItemPricingToCart(cartId, itemPriceQuantityList)
4034 
    return self.recv_addItemPricingToCart()
20873 kshitij.so 4035 
 
22452 amit.gupta 4036 
  def send_addItemPricingToCart(self, cartId, itemPriceQuantityList):
4037 
    self._oprot.writeMessageBegin('addItemPricingToCart', TMessageType.CALL, self._seqid)
4038 
    args = addItemPricingToCart_args()
4039 
    args.cartId = cartId
4040 
    args.itemPriceQuantityList = itemPriceQuantityList
4041 
    args.write(self._oprot)
4042 
    self._oprot.writeMessageEnd()
4043 
    self._oprot.trans.flush()
4044 
 
4045 
  def recv_addItemPricingToCart(self, ):
4046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4047 
    if mtype == TMessageType.EXCEPTION:
4048 
      x = TApplicationException()
4049 
      x.read(self._iprot)
4050 
      self._iprot.readMessageEnd()
4051 
      raise x
4052 
    result = addItemPricingToCart_result()
4053 
    result.read(self._iprot)
4054 
    self._iprot.readMessageEnd()
4055 
    if result.success is not None:
4056 
      return result.success
4057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemPricingToCart failed: unknown result");
4058 
 
4059 
 
3376 rajveer 4060 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4061 
  def __init__(self, handler):
3376 rajveer 4062 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 4063 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
4064 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 4065 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 4066 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 4067 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 4068 
    self._processMap["createUser"] = Processor.process_createUser
4069 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 4070 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 4071 
    self._processMap["userExists"] = Processor.process_userExists
4072 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
4073 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
22358 ashik.ali 4074 
    self._processMap["updateAddress"] = Processor.process_updateAddress
22364 ashik.ali 4075 
    self._processMap["updateCounter"] = Processor.process_updateCounter
94 ashish 4076 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
4077 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 4078 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 4079 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 4080 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 4081 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 4082 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 4083 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 4084 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 4085 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 4086 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
4087 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
4088 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 4089 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 4090 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 4091 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 4092 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
4093 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
4094 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
4095 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
4096 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 4097 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 4098 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
4099 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
4100 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 4101 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 4102 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
4103 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 4104 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
4105 
    self._processMap["getCart"] = Processor.process_getCart
4106 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
4107 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
4108 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
4109 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 4110 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 4111 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
4112 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 4113 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
4114 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 4115 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 4116 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 4117 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 4118 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 4119 
    self._processMap["checkOut"] = Processor.process_checkOut
4120 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 4121 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 4122 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 4123 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
4124 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
4125 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
4126 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
4127 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 4128 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 4129 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 4130 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 4131 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 4132 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 4133 
    self._processMap["insureItem"] = Processor.process_insureItem
4134 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
4135 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
4136 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 4137 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 4138 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 4139 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 4140 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
4141 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
4142 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 4143 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 4144 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 4145 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 4146 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 4147 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
4148 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 4149 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
4150 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 4151 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 4152 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 4153 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 4154 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 4155 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 4156 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
19889 manas 4157 
    self._processMap["getCounterName"] = Processor.process_getCounterName
20873 kshitij.so 4158 
    self._processMap["setWalletAmountInCart"] = Processor.process_setWalletAmountInCart
22452 amit.gupta 4159 
    self._processMap["addItemPricingToCart"] = Processor.process_addItemPricingToCart
94 ashish 4160 
 
4161 
  def process(self, iprot, oprot):
4162 
    (name, type, seqid) = iprot.readMessageBegin()
4163 
    if name not in self._processMap:
4164 
      iprot.skip(TType.STRUCT)
4165 
      iprot.readMessageEnd()
4166 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4167 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4168 
      x.write(oprot)
4169 
      oprot.writeMessageEnd()
4170 
      oprot.trans.flush()
4171 
      return
4172 
    else:
4173 
      self._processMap[name](self, seqid, iprot, oprot)
4174 
    return True
4175 
 
559 chandransh 4176 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
4177 
    args = createAnonymousUser_args()
94 ashish 4178 
    args.read(iprot)
4179 
    iprot.readMessageEnd()
559 chandransh 4180 
    result = createAnonymousUser_result()
94 ashish 4181 
    try:
559 chandransh 4182 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
4183 
    except UserContextException, ucex:
4184 
      result.ucex = ucex
4185 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 4186 
    result.write(oprot)
4187 
    oprot.writeMessageEnd()
4188 
    oprot.trans.flush()
4189 
 
559 chandransh 4190 
  def process_getUserById(self, seqid, iprot, oprot):
4191 
    args = getUserById_args()
94 ashish 4192 
    args.read(iprot)
4193 
    iprot.readMessageEnd()
559 chandransh 4194 
    result = getUserById_result()
94 ashish 4195 
    try:
559 chandransh 4196 
      result.success = self._handler.getUserById(args.userId)
4197 
    except UserContextException, ucex:
4198 
      result.ucex = ucex
4199 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
4203 
 
5326 rajveer 4204 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4205 
    args = getUserByCartId_args()
4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
4208 
    result = getUserByCartId_result()
4209 
    try:
4210 
      result.success = self._handler.getUserByCartId(args.cartId)
4211 
    except UserContextException, ucex:
4212 
      result.ucex = ucex
4213 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4214 
    result.write(oprot)
4215 
    oprot.writeMessageEnd()
4216 
    oprot.trans.flush()
4217 
 
1491 vikas 4218 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4219 
    args = getUserByEmail_args()
4220 
    args.read(iprot)
4221 
    iprot.readMessageEnd()
4222 
    result = getUserByEmail_result()
4223 
    try:
4224 
      result.success = self._handler.getUserByEmail(args.email)
4225 
    except UserContextException, ucex:
4226 
      result.ucex = ucex
4227 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4228 
    result.write(oprot)
4229 
    oprot.writeMessageEnd()
4230 
    oprot.trans.flush()
4231 
 
3032 mandeep.dh 4232 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4233 
    args = getUserByMobileNumber_args()
4234 
    args.read(iprot)
4235 
    iprot.readMessageEnd()
4236 
    result = getUserByMobileNumber_result()
4237 
    try:
4238 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4239 
    except UserContextException, ucex:
4240 
      result.ucex = ucex
4241 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4242 
    result.write(oprot)
4243 
    oprot.writeMessageEnd()
4244 
    oprot.trans.flush()
4245 
 
559 chandransh 4246 
  def process_createUser(self, seqid, iprot, oprot):
4247 
    args = createUser_args()
94 ashish 4248 
    args.read(iprot)
4249 
    iprot.readMessageEnd()
559 chandransh 4250 
    result = createUser_result()
94 ashish 4251 
    try:
559 chandransh 4252 
      result.success = self._handler.createUser(args.user)
4253 
    except UserContextException, ucex:
4254 
      result.ucex = ucex
4255 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4256 
    result.write(oprot)
4257 
    oprot.writeMessageEnd()
4258 
    oprot.trans.flush()
4259 
 
559 chandransh 4260 
  def process_updateUser(self, seqid, iprot, oprot):
4261 
    args = updateUser_args()
94 ashish 4262 
    args.read(iprot)
4263 
    iprot.readMessageEnd()
559 chandransh 4264 
    result = updateUser_result()
94 ashish 4265 
    try:
559 chandransh 4266 
      result.success = self._handler.updateUser(args.user)
4267 
    except UserContextException, ucex:
4268 
      result.ucex = ucex
4269 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4270 
    result.write(oprot)
4271 
    oprot.writeMessageEnd()
4272 
    oprot.trans.flush()
4273 
 
122 ashish 4274 
  def process_authenticateUser(self, seqid, iprot, oprot):
4275 
    args = authenticateUser_args()
4276 
    args.read(iprot)
4277 
    iprot.readMessageEnd()
4278 
    result = authenticateUser_result()
4279 
    try:
559 chandransh 4280 
      result.success = self._handler.authenticateUser(args.email, args.password)
4281 
    except AuthenticationException, auex:
4282 
      result.auex = auex
122 ashish 4283 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4284 
    result.write(oprot)
4285 
    oprot.writeMessageEnd()
4286 
    oprot.trans.flush()
4287 
 
94 ashish 4288 
  def process_userExists(self, seqid, iprot, oprot):
4289 
    args = userExists_args()
4290 
    args.read(iprot)
4291 
    iprot.readMessageEnd()
4292 
    result = userExists_result()
4293 
    try:
4294 
      result.success = self._handler.userExists(args.email)
4295 
    except UserContextException, ucx:
4296 
      result.ucx = ucx
4297 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4298 
    result.write(oprot)
4299 
    oprot.writeMessageEnd()
4300 
    oprot.trans.flush()
4301 
 
4302 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4303 
    args = addAddressForUser_args()
4304 
    args.read(iprot)
4305 
    iprot.readMessageEnd()
4306 
    result = addAddressForUser_result()
4307 
    try:
567 rajveer 4308 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4309 
    except UserContextException, ucx:
4310 
      result.ucx = ucx
4311 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4312 
    result.write(oprot)
4313 
    oprot.writeMessageEnd()
4314 
    oprot.trans.flush()
4315 
 
4316 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4317 
    args = removeAddressForUser_args()
4318 
    args.read(iprot)
4319 
    iprot.readMessageEnd()
4320 
    result = removeAddressForUser_result()
4321 
    try:
4322 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4323 
    except UserContextException, ucx:
4324 
      result.ucx = ucx
4325 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4326 
    result.write(oprot)
4327 
    oprot.writeMessageEnd()
4328 
    oprot.trans.flush()
4329 
 
22358 ashik.ali 4330 
  def process_updateAddress(self, seqid, iprot, oprot):
4331 
    args = updateAddress_args()
4332 
    args.read(iprot)
4333 
    iprot.readMessageEnd()
4334 
    result = updateAddress_result()
4335 
    try:
4336 
      result.success = self._handler.updateAddress(args.address)
4337 
    except UserContextException, ucx:
4338 
      result.ucx = ucx
4339 
    oprot.writeMessageBegin("updateAddress", TMessageType.REPLY, seqid)
4340 
    result.write(oprot)
4341 
    oprot.writeMessageEnd()
4342 
    oprot.trans.flush()
4343 
 
22364 ashik.ali 4344 
  def process_updateCounter(self, seqid, iprot, oprot):
4345 
    args = updateCounter_args()
4346 
    args.read(iprot)
4347 
    iprot.readMessageEnd()
4348 
    result = updateCounter_result()
4349 
    try:
4350 
      result.success = self._handler.updateCounter(args.counter)
4351 
    except UserContextException, ucx:
4352 
      result.ucx = ucx
4353 
    oprot.writeMessageBegin("updateCounter", TMessageType.REPLY, seqid)
4354 
    result.write(oprot)
4355 
    oprot.writeMessageEnd()
4356 
    oprot.trans.flush()
4357 
 
94 ashish 4358 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4359 
    args = setUserAsLoggedIn_args()
4360 
    args.read(iprot)
4361 
    iprot.readMessageEnd()
4362 
    result = setUserAsLoggedIn_result()
4363 
    try:
4364 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4365 
    except UserContextException, ucx:
4366 
      result.ucx = ucx
4367 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4368 
    result.write(oprot)
4369 
    oprot.writeMessageEnd()
4370 
    oprot.trans.flush()
4371 
 
4372 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4373 
    args = setUserAsLoggedOut_args()
4374 
    args.read(iprot)
4375 
    iprot.readMessageEnd()
4376 
    result = setUserAsLoggedOut_result()
4377 
    try:
4378 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4379 
    except UserContextException, ucx:
4380 
      result.ucx = ucx
4381 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4382 
    result.write(oprot)
4383 
    oprot.writeMessageEnd()
4384 
    oprot.trans.flush()
4385 
 
504 rajveer 4386 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4387 
    args = setDefaultAddress_args()
4388 
    args.read(iprot)
4389 
    iprot.readMessageEnd()
4390 
    result = setDefaultAddress_result()
4391 
    try:
4392 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4393 
    except UserContextException, ucx:
4394 
      result.ucx = ucx
4395 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4396 
    result.write(oprot)
4397 
    oprot.writeMessageEnd()
4398 
    oprot.trans.flush()
4399 
 
94 ashish 4400 
  def process_updatePassword(self, seqid, iprot, oprot):
4401 
    args = updatePassword_args()
4402 
    args.read(iprot)
4403 
    iprot.readMessageEnd()
4404 
    result = updatePassword_result()
4405 
    try:
594 rajveer 4406 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4407 
    except UserContextException, ucx:
4408 
      result.ucx = ucx
4409 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4410 
    result.write(oprot)
4411 
    oprot.writeMessageEnd()
4412 
    oprot.trans.flush()
4413 
 
581 rajveer 4414 
  def process_forgotPassword(self, seqid, iprot, oprot):
4415 
    args = forgotPassword_args()
4416 
    args.read(iprot)
4417 
    iprot.readMessageEnd()
4418 
    result = forgotPassword_result()
4419 
    try:
884 rajveer 4420 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4421 
    except UserContextException, ucx:
4422 
      result.ucx = ucx
4423 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4424 
    result.write(oprot)
4425 
    oprot.writeMessageEnd()
4426 
    oprot.trans.flush()
4427 
 
594 rajveer 4428 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4429 
    args = getAllAddressesForUser_args()
4430 
    args.read(iprot)
4431 
    iprot.readMessageEnd()
4432 
    result = getAllAddressesForUser_result()
4433 
    try:
4434 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4435 
    except UserContextException, ucx:
4436 
      result.ucx = ucx
4437 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4438 
    result.write(oprot)
4439 
    oprot.writeMessageEnd()
4440 
    oprot.trans.flush()
4441 
 
1894 vikas 4442 
  def process_getAddressById(self, seqid, iprot, oprot):
4443 
    args = getAddressById_args()
4444 
    args.read(iprot)
4445 
    iprot.readMessageEnd()
4446 
    result = getAddressById_result()
4447 
    try:
4448 
      result.success = self._handler.getAddressById(args.addressId)
4449 
    except UserContextException, ucx:
4450 
      result.ucx = ucx
4451 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4452 
    result.write(oprot)
4453 
    oprot.writeMessageEnd()
4454 
    oprot.trans.flush()
4455 
 
594 rajveer 4456 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4457 
    args = getDefaultAddressId_args()
4458 
    args.read(iprot)
4459 
    iprot.readMessageEnd()
4460 
    result = getDefaultAddressId_result()
4461 
    try:
4462 
      result.success = self._handler.getDefaultAddressId(args.userId)
4463 
    except UserContextException, ucx:
4464 
      result.ucx = ucx
4465 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4466 
    result.write(oprot)
4467 
    oprot.writeMessageEnd()
4468 
    oprot.trans.flush()
4469 
 
785 rajveer 4470 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4471 
    args = getDefaultPincode_args()
4472 
    args.read(iprot)
4473 
    iprot.readMessageEnd()
4474 
    result = getDefaultPincode_result()
4475 
    try:
4476 
      result.success = self._handler.getDefaultPincode(args.userId)
4477 
    except UserContextException, ucx:
4478 
      result.ucx = ucx
4479 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4480 
    result.write(oprot)
4481 
    oprot.writeMessageEnd()
4482 
    oprot.trans.flush()
4483 
 
1274 varun.gupt 4484 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4485 
    args = saveUserCommunication_args()
4486 
    args.read(iprot)
4487 
    iprot.readMessageEnd()
4488 
    result = saveUserCommunication_result()
4489 
    try:
4490 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4491 
    except UserCommunicationException, ucx:
4492 
      result.ucx = ucx
4493 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4494 
    result.write(oprot)
4495 
    oprot.writeMessageEnd()
4496 
    oprot.trans.flush()
4497 
 
1590 varun.gupt 4498 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4499 
    args = getUserCommunicationById_args()
4500 
    args.read(iprot)
4501 
    iprot.readMessageEnd()
4502 
    result = getUserCommunicationById_result()
4503 
    try:
4504 
      result.success = self._handler.getUserCommunicationById(args.id)
4505 
    except UserCommunicationException, ucx:
4506 
      result.ucx = ucx
4507 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4508 
    result.write(oprot)
4509 
    oprot.writeMessageEnd()
4510 
    oprot.trans.flush()
4511 
 
4512 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4513 
    args = getUserCommunicationByUser_args()
4514 
    args.read(iprot)
4515 
    iprot.readMessageEnd()
4516 
    result = getUserCommunicationByUser_result()
4517 
    try:
4518 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4519 
    except UserCommunicationException, ucx:
4520 
      result.ucx = ucx
4521 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4522 
    result.write(oprot)
4523 
    oprot.writeMessageEnd()
4524 
    oprot.trans.flush()
4525 
 
4526 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4527 
    args = getAllUserCommunications_args()
4528 
    args.read(iprot)
4529 
    iprot.readMessageEnd()
4530 
    result = getAllUserCommunications_result()
4531 
    try:
4532 
      result.success = self._handler.getAllUserCommunications()
4533 
    except UserCommunicationException, ucx:
4534 
      result.ucx = ucx
4535 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4536 
    result.write(oprot)
4537 
    oprot.writeMessageEnd()
4538 
    oprot.trans.flush()
4539 
 
5407 amar.kumar 4540 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4541 
    args = removeUserCommunication_args()
4542 
    args.read(iprot)
4543 
    iprot.readMessageEnd()
4544 
    result = removeUserCommunication_result()
4545 
    try:
4546 
      self._handler.removeUserCommunication(args.id)
4547 
    except UserCommunicationException, ucx:
4548 
      result.ucx = ucx
4549 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4550 
    result.write(oprot)
4551 
    oprot.writeMessageEnd()
4552 
    oprot.trans.flush()
4553 
 
1845 vikas 4554 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4555 
    args = createMasterAffiliate_args()
4556 
    args.read(iprot)
4557 
    iprot.readMessageEnd()
4558 
    result = createMasterAffiliate_result()
4559 
    try:
1859 vikas 4560 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4561 
    except UserAffiliateException, utx:
1845 vikas 4562 
      result.utx = utx
4563 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4564 
    result.write(oprot)
4565 
    oprot.writeMessageEnd()
4566 
    oprot.trans.flush()
4567 
 
1899 vikas 4568 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4569 
    args = getAllMasterAffiliates_args()
4570 
    args.read(iprot)
4571 
    iprot.readMessageEnd()
4572 
    result = getAllMasterAffiliates_result()
4573 
    try:
4574 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4575 
    except UserAffiliateException, utx:
1899 vikas 4576 
      result.utx = utx
4577 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4578 
    result.write(oprot)
4579 
    oprot.writeMessageEnd()
4580 
    oprot.trans.flush()
4581 
 
1845 vikas 4582 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4583 
    args = getMasterAffiliateById_args()
4584 
    args.read(iprot)
4585 
    iprot.readMessageEnd()
4586 
    result = getMasterAffiliateById_result()
4587 
    try:
4588 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4589 
    except UserAffiliateException, utx:
1845 vikas 4590 
      result.utx = utx
4591 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4592 
    result.write(oprot)
4593 
    oprot.writeMessageEnd()
4594 
    oprot.trans.flush()
4595 
 
4596 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4597 
    args = getMasterAffiliateByName_args()
4598 
    args.read(iprot)
4599 
    iprot.readMessageEnd()
4600 
    result = getMasterAffiliateByName_result()
4601 
    try:
4602 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4603 
    except UserAffiliateException, utx:
1845 vikas 4604 
      result.utx = utx
4605 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4606 
    result.write(oprot)
4607 
    oprot.writeMessageEnd()
4608 
    oprot.trans.flush()
4609 
 
4610 
  def process_createAffiliate(self, seqid, iprot, oprot):
4611 
    args = createAffiliate_args()
4612 
    args.read(iprot)
4613 
    iprot.readMessageEnd()
4614 
    result = createAffiliate_result()
4615 
    try:
1859 vikas 4616 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4617 
    except UserAffiliateException, utx:
1845 vikas 4618 
      result.utx = utx
4619 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4620 
    result.write(oprot)
4621 
    oprot.writeMessageEnd()
4622 
    oprot.trans.flush()
4623 
 
4624 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4625 
    args = getAffiliateById_args()
4626 
    args.read(iprot)
4627 
    iprot.readMessageEnd()
4628 
    result = getAffiliateById_result()
4629 
    try:
4630 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4631 
    except UserAffiliateException, utx:
1845 vikas 4632 
      result.utx = utx
4633 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4634 
    result.write(oprot)
4635 
    oprot.writeMessageEnd()
4636 
    oprot.trans.flush()
4637 
 
4638 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4639 
    args = getAffiliateByName_args()
4640 
    args.read(iprot)
4641 
    iprot.readMessageEnd()
4642 
    result = getAffiliateByName_result()
4643 
    try:
4644 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4645 
    except UserAffiliateException, utx:
1845 vikas 4646 
      result.utx = utx
4647 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4648 
    result.write(oprot)
4649 
    oprot.writeMessageEnd()
4650 
    oprot.trans.flush()
4651 
 
4652 
  def process_getTrackerById(self, seqid, iprot, oprot):
4653 
    args = getTrackerById_args()
4654 
    args.read(iprot)
4655 
    iprot.readMessageEnd()
4656 
    result = getTrackerById_result()
4657 
    try:
1996 vikas 4658 
      result.success = self._handler.getTrackerById(args.id)
4659 
    except UserAffiliateException, utx:
1845 vikas 4660 
      result.utx = utx
4661 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
1996 vikas 4666 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4667 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
1996 vikas 4670 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4671 
    try:
1996 vikas 4672 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4673 
    except UserAffiliateException, utx:
1845 vikas 4674 
      result.utx = utx
1996 vikas 4675 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4676 
    result.write(oprot)
4677 
    oprot.writeMessageEnd()
4678 
    oprot.trans.flush()
4679 
 
4680 
  def process_addTrackLog(self, seqid, iprot, oprot):
4681 
    args = addTrackLog_args()
4682 
    args.read(iprot)
4683 
    iprot.readMessageEnd()
4684 
    result = addTrackLog_result()
4685 
    try:
1996 vikas 4686 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4687 
    except UserAffiliateException, utx:
1845 vikas 4688 
      result.utx = utx
4689 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4690 
    result.write(oprot)
4691 
    oprot.writeMessageEnd()
4692 
    oprot.trans.flush()
4693 
 
4694 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4695 
    args = getTrackLogById_args()
4696 
    args.read(iprot)
4697 
    iprot.readMessageEnd()
4698 
    result = getTrackLogById_result()
4699 
    try:
4700 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4701 
    except UserAffiliateException, utx:
1845 vikas 4702 
      result.utx = utx
4703 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4704 
    result.write(oprot)
4705 
    oprot.writeMessageEnd()
4706 
    oprot.trans.flush()
4707 
 
1996 vikas 4708 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4709 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4710 
    args.read(iprot)
4711 
    iprot.readMessageEnd()
1996 vikas 4712 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4713 
    try:
3293 vikas 4714 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4715 
    except UserAffiliateException, utx:
1845 vikas 4716 
      result.utx = utx
1996 vikas 4717 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4718 
    result.write(oprot)
4719 
    oprot.writeMessageEnd()
4720 
    oprot.trans.flush()
4721 
 
4722 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4723 
    args = getTrackLogsByUser_args()
4724 
    args.read(iprot)
4725 
    iprot.readMessageEnd()
4726 
    result = getTrackLogsByUser_result()
4727 
    try:
4728 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4729 
    except UserAffiliateException, utx:
1845 vikas 4730 
      result.utx = utx
4731 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4732 
    result.write(oprot)
4733 
    oprot.writeMessageEnd()
4734 
    oprot.trans.flush()
4735 
 
4736 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4737 
    args = getTrackLogs_args()
4738 
    args.read(iprot)
4739 
    iprot.readMessageEnd()
4740 
    result = getTrackLogs_result()
4741 
    try:
1996 vikas 4742 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4743 
    except UserAffiliateException, utx:
1845 vikas 4744 
      result.utx = utx
4745 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4746 
    result.write(oprot)
4747 
    oprot.writeMessageEnd()
4748 
    oprot.trans.flush()
4749 
 
559 chandransh 4750 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4751 
    args = getCurrentCart_args()
94 ashish 4752 
    args.read(iprot)
4753 
    iprot.readMessageEnd()
559 chandransh 4754 
    result = getCurrentCart_result()
94 ashish 4755 
    try:
559 chandransh 4756 
      result.success = self._handler.getCurrentCart(args.userId)
4757 
    except ShoppingCartException, scx:
4758 
      result.scx = scx
4759 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4763 
 
559 chandransh 4764 
  def process_getCart(self, seqid, iprot, oprot):
4765 
    args = getCart_args()
94 ashish 4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
559 chandransh 4768 
    result = getCart_result()
94 ashish 4769 
    try:
559 chandransh 4770 
      result.success = self._handler.getCart(args.cartId)
4771 
    except ShoppingCartException, scx:
4772 
      result.scx = scx
4773 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
4777 
 
559 chandransh 4778 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4779 
    args = getCartsByTime_args()
94 ashish 4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
559 chandransh 4782 
    result = getCartsByTime_result()
94 ashish 4783 
    try:
559 chandransh 4784 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4785 
    except ShoppingCartException, scx:
4786 
      result.scx = scx
4787 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
559 chandransh 4792 
  def process_addItemToCart(self, seqid, iprot, oprot):
4793 
    args = addItemToCart_args()
130 ashish 4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
559 chandransh 4796 
    result = addItemToCart_result()
130 ashish 4797 
    try:
3557 rajveer 4798 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4799 
    except ShoppingCartException, scx:
4800 
      result.scx = scx
4801 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
4805 
 
559 chandransh 4806 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4807 
    args = deleteItemFromCart_args()
4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
4810 
    result = deleteItemFromCart_result()
4811 
    try:
4812 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4813 
    except ShoppingCartException, scx:
4814 
      result.scx = scx
4815 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4816 
    result.write(oprot)
4817 
    oprot.writeMessageEnd()
4818 
    oprot.trans.flush()
130 ashish 4819 
 
559 chandransh 4820 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4821 
    args = addAddressToCart_args()
4822 
    args.read(iprot)
4823 
    iprot.readMessageEnd()
4824 
    result = addAddressToCart_result()
575 chandransh 4825 
    try:
4826 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4827 
    except ShoppingCartException, scx:
4828 
      result.scx = scx
559 chandransh 4829 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
4833 
 
5553 rajveer 4834 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4835 
    args = addStoreToCart_args()
4836 
    args.read(iprot)
4837 
    iprot.readMessageEnd()
4838 
    result = addStoreToCart_result()
4839 
    try:
4840 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4841 
    except ShoppingCartException, scx:
4842 
      result.scx = scx
4843 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4844 
    result.write(oprot)
4845 
    oprot.writeMessageEnd()
4846 
    oprot.trans.flush()
4847 
 
1976 varun.gupt 4848 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4849 
    args = applyCouponToCart_args()
4850 
    args.read(iprot)
4851 
    iprot.readMessageEnd()
4852 
    result = applyCouponToCart_result()
4853 
    try:
6922 anupam.sin 4854 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4855 
    except ShoppingCartException, scx:
4856 
      result.scx = scx
4857 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4858 
    result.write(oprot)
4859 
    oprot.writeMessageEnd()
4860 
    oprot.trans.flush()
4861 
 
4862 
  def process_removeCoupon(self, seqid, iprot, oprot):
4863 
    args = removeCoupon_args()
4864 
    args.read(iprot)
4865 
    iprot.readMessageEnd()
4866 
    result = removeCoupon_result()
4867 
    try:
4868 
      self._handler.removeCoupon(args.cartId)
4869 
    except ShoppingCartException, scx:
4870 
      result.scx = scx
4871 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4872 
    result.write(oprot)
4873 
    oprot.writeMessageEnd()
4874 
    oprot.trans.flush()
4875 
 
3554 varun.gupt 4876 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4877 
    args = deleteDiscountsFromCart_args()
4878 
    args.read(iprot)
4879 
    iprot.readMessageEnd()
4880 
    result = deleteDiscountsFromCart_result()
4881 
    try:
4882 
      self._handler.deleteDiscountsFromCart(args.cartId)
4883 
    except ShoppingCartException, scx:
4884 
      result.scx = scx
4885 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4886 
    result.write(oprot)
4887 
    oprot.writeMessageEnd()
4888 
    oprot.trans.flush()
4889 
 
4890 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4891 
    args = saveDiscounts_args()
4892 
    args.read(iprot)
4893 
    iprot.readMessageEnd()
4894 
    result = saveDiscounts_result()
4895 
    try:
4896 
      self._handler.saveDiscounts(args.discounts)
4897 
    except ShoppingCartException, scx:
4898 
      result.scx = scx
4899 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4900 
    result.write(oprot)
4901 
    oprot.writeMessageEnd()
4902 
    oprot.trans.flush()
4903 
 
690 chandransh 4904 
  def process_createOrders(self, seqid, iprot, oprot):
4905 
    args = createOrders_args()
559 chandransh 4906 
    args.read(iprot)
4907 
    iprot.readMessageEnd()
690 chandransh 4908 
    result = createOrders_result()
559 chandransh 4909 
    try:
21454 amit.gupta 4910 
      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 4911 
    except ShoppingCartException, scx:
4912 
      result.scx = scx
690 chandransh 4913 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4914 
    result.write(oprot)
4915 
    oprot.writeMessageEnd()
4916 
    oprot.trans.flush()
4917 
 
4918 
  def process_validateCart(self, seqid, iprot, oprot):
4919 
    args = validateCart_args()
4920 
    args.read(iprot)
4921 
    iprot.readMessageEnd()
4922 
    result = validateCart_result()
575 chandransh 4923 
    try:
3557 rajveer 4924 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4925 
    except ShoppingCartException, scex:
4926 
      result.scex = scex
559 chandransh 4927 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
4931 
 
11980 amit.gupta 4932 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4933 
    args = validateCartWithDealerCoupon_args()
4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
4936 
    result = validateCartWithDealerCoupon_result()
4937 
    try:
4938 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4939 
    except ShoppingCartException, scex:
4940 
      result.scex = scex
4941 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4942 
    result.write(oprot)
4943 
    oprot.writeMessageEnd()
4944 
    oprot.trans.flush()
4945 
 
690 chandransh 4946 
  def process_mergeCart(self, seqid, iprot, oprot):
4947 
    args = mergeCart_args()
575 chandransh 4948 
    args.read(iprot)
4949 
    iprot.readMessageEnd()
690 chandransh 4950 
    result = mergeCart_result()
4951 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4952 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4953 
    result.write(oprot)
4954 
    oprot.writeMessageEnd()
4955 
    oprot.trans.flush()
4956 
 
4957 
  def process_checkOut(self, seqid, iprot, oprot):
4958 
    args = checkOut_args()
4959 
    args.read(iprot)
4960 
    iprot.readMessageEnd()
4961 
    result = checkOut_result()
575 chandransh 4962 
    try:
690 chandransh 4963 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4964 
    except ShoppingCartException, scex:
4965 
      result.scex = scex
690 chandransh 4966 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4967 
    result.write(oprot)
4968 
    oprot.writeMessageEnd()
4969 
    oprot.trans.flush()
4970 
 
690 chandransh 4971 
  def process_resetCart(self, seqid, iprot, oprot):
4972 
    args = resetCart_args()
559 chandransh 4973 
    args.read(iprot)
4974 
    iprot.readMessageEnd()
690 chandransh 4975 
    result = resetCart_result()
4976 
    try:
4977 
      result.success = self._handler.resetCart(args.cartId, args.items)
4978 
    except ShoppingCartException, scex:
4979 
      result.scex = scex
4980 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
4984 
 
2981 rajveer 4985 
  def process_getUserCount(self, seqid, iprot, oprot):
4986 
    args = getUserCount_args()
559 chandransh 4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
2981 rajveer 4989 
    result = getUserCount_result()
4990 
    result.success = self._handler.getUserCount(args.userType)
4991 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4992 
    result.write(oprot)
4993 
    oprot.writeMessageEnd()
4994 
    oprot.trans.flush()
4995 
 
2981 rajveer 4996 
  def process_getAllUsers(self, seqid, iprot, oprot):
4997 
    args = getAllUsers_args()
559 chandransh 4998 
    args.read(iprot)
4999 
    iprot.readMessageEnd()
2981 rajveer 5000 
    result = getAllUsers_result()
5001 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
5002 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
2981 rajveer 5007 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
5008 
    args = getMyResearchItems_args()
559 chandransh 5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
2981 rajveer 5011 
    result = getMyResearchItems_result()
559 chandransh 5012 
    try:
2981 rajveer 5013 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 5014 
    except WidgetException, scx:
5015 
      result.scx = scx
2981 rajveer 5016 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
2981 rajveer 5021 
  def process_updateMyResearch(self, seqid, iprot, oprot):
5022 
    args = updateMyResearch_args()
772 rajveer 5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
2981 rajveer 5025 
    result = updateMyResearch_result()
5026 
    try:
5027 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
5028 
    except WidgetException, scx:
5029 
      result.scx = scx
5030 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
559 chandransh 5034 
 
2981 rajveer 5035 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
5036 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
2981 rajveer 5039 
    result = deleteItemFromMyResearch_result()
5040 
    try:
5041 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
5042 
    except WidgetException, scx:
5043 
      result.scx = scx
5044 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
772 rajveer 5048 
 
2981 rajveer 5049 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
5050 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
2981 rajveer 5053 
    result = getBrowseHistoryItems_result()
5054 
    try:
5055 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
5056 
    except WidgetException, scx:
5057 
      result.scx = scx
5058 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
1596 ankur.sing 5062 
 
2981 rajveer 5063 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
5064 
    args = updateBrowseHistory_args()
2642 varun.gupt 5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
2981 rajveer 5067 
    result = updateBrowseHistory_result()
5068 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
5069 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 5070 
    result.write(oprot)
5071 
    oprot.writeMessageEnd()
5072 
    oprot.trans.flush()
1673 ankur.sing 5073 
 
3385 varun.gupt 5074 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
5075 
    args = getCartsWithCouponCount_args()
5076 
    args.read(iprot)
5077 
    iprot.readMessageEnd()
5078 
    result = getCartsWithCouponCount_result()
5079 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
5080 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
5081 
    result.write(oprot)
5082 
    oprot.writeMessageEnd()
5083 
    oprot.trans.flush()
2642 varun.gupt 5084 
 
3499 mandeep.dh 5085 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
5086 
    args = increaseTrustLevel_args()
5087 
    args.read(iprot)
5088 
    iprot.readMessageEnd()
5089 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 5090 
    return
3385 varun.gupt 5091 
 
5407 amar.kumar 5092 
  def process_getTrustLevel(self, seqid, iprot, oprot):
5093 
    args = getTrustLevel_args()
5094 
    args.read(iprot)
5095 
    iprot.readMessageEnd()
5096 
    result = getTrustLevel_result()
5097 
    result.success = self._handler.getTrustLevel(args.userId)
5098 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
5099 
    result.write(oprot)
5100 
    oprot.writeMessageEnd()
5101 
    oprot.trans.flush()
5102 
 
4668 varun.gupt 5103 
  def process_showCODOption(self, seqid, iprot, oprot):
5104 
    args = showCODOption_args()
5105 
    args.read(iprot)
5106 
    iprot.readMessageEnd()
5107 
    result = showCODOption_result()
5108 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
5109 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
5110 
    result.write(oprot)
5111 
    oprot.writeMessageEnd()
5112 
    oprot.trans.flush()
3499 mandeep.dh 5113 
 
5623 anupam.sin 5114 
  def process_getUserEmails(self, seqid, iprot, oprot):
5115 
    args = getUserEmails_args()
5116 
    args.read(iprot)
5117 
    iprot.readMessageEnd()
5118 
    result = getUserEmails_result()
5119 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
5120 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
5121 
    result.write(oprot)
5122 
    oprot.writeMessageEnd()
5123 
    oprot.trans.flush()
4668 varun.gupt 5124 
 
6903 anupam.sin 5125 
  def process_insureItem(self, seqid, iprot, oprot):
5126 
    args = insureItem_args()
5127 
    args.read(iprot)
5128 
    iprot.readMessageEnd()
5129 
    result = insureItem_result()
9299 kshitij.so 5130 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 5131 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
5132 
    result.write(oprot)
5133 
    oprot.writeMessageEnd()
5134 
    oprot.trans.flush()
5135 
 
5136 
  def process_cancelInsurance(self, seqid, iprot, oprot):
5137 
    args = cancelInsurance_args()
5138 
    args.read(iprot)
5139 
    iprot.readMessageEnd()
5140 
    result = cancelInsurance_result()
5141 
    result.success = self._handler.cancelInsurance(args.cartId)
5142 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
5143 
    result.write(oprot)
5144 
    oprot.writeMessageEnd()
5145 
    oprot.trans.flush()
5146 
 
5147 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
5148 
    args = storeInsuranceSpecificDetails_args()
5149 
    args.read(iprot)
5150 
    iprot.readMessageEnd()
5151 
    result = storeInsuranceSpecificDetails_result()
5152 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
5153 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
5154 
    result.write(oprot)
5155 
    oprot.writeMessageEnd()
5156 
    oprot.trans.flush()
5157 
 
5158 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
5159 
    args = isInsuranceDetailPresent_args()
5160 
    args.read(iprot)
5161 
    iprot.readMessageEnd()
5162 
    result = isInsuranceDetailPresent_result()
5163 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
5164 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
5165 
    result.write(oprot)
5166 
    oprot.writeMessageEnd()
5167 
    oprot.trans.flush()
5168 
 
9791 rajveer 5169 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
5170 
    args = getProductsAddedToCart_args()
6821 amar.kumar 5171 
    args.read(iprot)
5172 
    iprot.readMessageEnd()
9791 rajveer 5173 
    result = getProductsAddedToCart_result()
5174 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
5175 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5623 anupam.sin 5179 
 
11592 amit.gupta 5180 
  def process_validateCartPlus(self, seqid, iprot, oprot):
5181 
    args = validateCartPlus_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = validateCartPlus_result()
5185 
    try:
11980 amit.gupta 5186 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 5187 
    except ShoppingCartException, scex:
5188 
      result.scex = scex
5189 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
5190 
    result.write(oprot)
5191 
    oprot.writeMessageEnd()
5192 
    oprot.trans.flush()
6821 amar.kumar 5193 
 
11679 vikram.rag 5194 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
5195 
    args = isPrivateDealUser_args()
5196 
    args.read(iprot)
5197 
    iprot.readMessageEnd()
5198 
    result = isPrivateDealUser_result()
5199 
    result.success = self._handler.isPrivateDealUser(args.userId)
5200 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
5201 
    result.write(oprot)
5202 
    oprot.writeMessageEnd()
5203 
    oprot.trans.flush()
11592 amit.gupta 5204 
 
11890 kshitij.so 5205 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
5206 
    args = addPrivateDealUser_args()
5207 
    args.read(iprot)
5208 
    iprot.readMessageEnd()
5209 
    result = addPrivateDealUser_result()
5210 
    result.success = self._handler.addPrivateDealUser(args.userId)
5211 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
5212 
    result.write(oprot)
5213 
    oprot.writeMessageEnd()
5214 
    oprot.trans.flush()
11679 vikram.rag 5215 
 
11890 kshitij.so 5216 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
5217 
    args = changePrivateDealUserStatus_args()
5218 
    args.read(iprot)
5219 
    iprot.readMessageEnd()
5220 
    result = changePrivateDealUserStatus_result()
5221 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
5222 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
5223 
    result.write(oprot)
5224 
    oprot.writeMessageEnd()
5225 
    oprot.trans.flush()
5226 
 
5227 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
5228 
    args = getPrivateDealUser_args()
5229 
    args.read(iprot)
5230 
    iprot.readMessageEnd()
5231 
    result = getPrivateDealUser_result()
5232 
    result.success = self._handler.getPrivateDealUser(args.userId)
5233 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5234 
    result.write(oprot)
5235 
    oprot.writeMessageEnd()
5236 
    oprot.trans.flush()
5237 
 
12696 amit.gupta 5238 
  def process_registerCounter(self, seqid, iprot, oprot):
5239 
    args = registerCounter_args()
5240 
    args.read(iprot)
5241 
    iprot.readMessageEnd()
5242 
    result = registerCounter_result()
5243 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5244 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5245 
    result.write(oprot)
5246 
    oprot.writeMessageEnd()
5247 
    oprot.trans.flush()
11890 kshitij.so 5248 
 
12722 amit.gupta 5249 
  def process_searchCounter(self, seqid, iprot, oprot):
5250 
    args = searchCounter_args()
5251 
    args.read(iprot)
5252 
    iprot.readMessageEnd()
5253 
    result = searchCounter_result()
5254 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5255 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5256 
    result.write(oprot)
5257 
    oprot.writeMessageEnd()
5258 
    oprot.trans.flush()
12696 amit.gupta 5259 
 
18977 amit.gupta 5260 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5261 
    args = getCounterByUserId_args()
5262 
    args.read(iprot)
5263 
    iprot.readMessageEnd()
5264 
    result = getCounterByUserId_result()
5265 
    result.success = self._handler.getCounterByUserId(args.userId)
5266 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5267 
    result.write(oprot)
5268 
    oprot.writeMessageEnd()
5269 
    oprot.trans.flush()
5270 
 
12722 amit.gupta 5271 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5272 
    args = getAllUsersByCounter_args()
5273 
    args.read(iprot)
5274 
    iprot.readMessageEnd()
5275 
    result = getAllUsersByCounter_result()
5276 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5277 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5278 
    result.write(oprot)
5279 
    oprot.writeMessageEnd()
5280 
    oprot.trans.flush()
5281 
 
15251 manish.sha 5282 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5283 
    args = getActiveAccessTokenForUser_args()
5284 
    args.read(iprot)
5285 
    iprot.readMessageEnd()
5286 
    result = getActiveAccessTokenForUser_result()
5287 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5288 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5289 
    result.write(oprot)
5290 
    oprot.writeMessageEnd()
5291 
    oprot.trans.flush()
12722 amit.gupta 5292 
 
15251 manish.sha 5293 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5294 
    args = validateAccessToken_args()
5295 
    args.read(iprot)
5296 
    iprot.readMessageEnd()
5297 
    result = validateAccessToken_result()
5298 
    result.success = self._handler.validateAccessToken(args.accessToken)
5299 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5300 
    result.write(oprot)
5301 
    oprot.writeMessageEnd()
5302 
    oprot.trans.flush()
5303 
 
17782 amit.gupta 5304 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5305 
    args = addItemsToCart_args()
5306 
    args.read(iprot)
5307 
    iprot.readMessageEnd()
5308 
    result = addItemsToCart_result()
5309 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5310 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5311 
    result.write(oprot)
5312 
    oprot.writeMessageEnd()
5313 
    oprot.trans.flush()
15251 manish.sha 5314 
 
17782 amit.gupta 5315 
  def process_validateCartNew(self, seqid, iprot, oprot):
5316 
    args = validateCartNew_args()
5317 
    args.read(iprot)
5318 
    iprot.readMessageEnd()
5319 
    result = validateCartNew_result()
5320 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5321 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5322 
    result.write(oprot)
5323 
    oprot.writeMessageEnd()
5324 
    oprot.trans.flush()
5325 
 
18644 manish.sha 5326 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5327 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5328 
    args.read(iprot)
5329 
    iprot.readMessageEnd()
18644 manish.sha 5330 
    result = isAddressEditableForCounter_result()
5331 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5332 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5333 
    result.write(oprot)
5334 
    oprot.writeMessageEnd()
5335 
    oprot.trans.flush()
17782 amit.gupta 5336 
 
18530 manish.sha 5337 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5338 
    args = getBillingAddressForUser_args()
5339 
    args.read(iprot)
5340 
    iprot.readMessageEnd()
5341 
    result = getBillingAddressForUser_result()
5342 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5343 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5344 
    result.write(oprot)
5345 
    oprot.writeMessageEnd()
5346 
    oprot.trans.flush()
5347 
 
18590 manish.sha 5348 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5349 
    args = isCreditorAssigned_args()
5350 
    args.read(iprot)
5351 
    iprot.readMessageEnd()
5352 
    result = isCreditorAssigned_result()
5353 
    result.success = self._handler.isCreditorAssigned(args.userId)
5354 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
18530 manish.sha 5358 
 
18735 manish.sha 5359 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5360 
    args = isTaxInvoiceEnabledUser_args()
5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
5363 
    result = isTaxInvoiceEnabledUser_result()
5364 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5365 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5366 
    result.write(oprot)
5367 
    oprot.writeMessageEnd()
5368 
    oprot.trans.flush()
18590 manish.sha 5369 
 
19182 amit.gupta 5370 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5371 
    args = taxInvoiceAvailable_args()
5372 
    args.read(iprot)
5373 
    iprot.readMessageEnd()
5374 
    result = taxInvoiceAvailable_result()
5375 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5376 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5377 
    result.write(oprot)
5378 
    oprot.writeMessageEnd()
5379 
    oprot.trans.flush()
5380 
 
18764 kshitij.so 5381 
  def process_getCartByValue(self, seqid, iprot, oprot):
5382 
    args = getCartByValue_args()
5383 
    args.read(iprot)
5384 
    iprot.readMessageEnd()
5385 
    result = getCartByValue_result()
5386 
    result.success = self._handler.getCartByValue(args.cartIds)
5387 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5388 
    result.write(oprot)
5389 
    oprot.writeMessageEnd()
5390 
    oprot.trans.flush()
18735 manish.sha 5391 
 
19889 manas 5392 
  def process_getCounterName(self, seqid, iprot, oprot):
5393 
    args = getCounterName_args()
5394 
    args.read(iprot)
5395 
    iprot.readMessageEnd()
5396 
    result = getCounterName_result()
5397 
    result.success = self._handler.getCounterName(args.userIds)
5398 
    oprot.writeMessageBegin("getCounterName", TMessageType.REPLY, seqid)
5399 
    result.write(oprot)
5400 
    oprot.writeMessageEnd()
5401 
    oprot.trans.flush()
18764 kshitij.so 5402 
 
20873 kshitij.so 5403 
  def process_setWalletAmountInCart(self, seqid, iprot, oprot):
5404 
    args = setWalletAmountInCart_args()
5405 
    args.read(iprot)
5406 
    iprot.readMessageEnd()
5407 
    result = setWalletAmountInCart_result()
5408 
    result.success = self._handler.setWalletAmountInCart(args.cartId, args.wallet_amount)
5409 
    oprot.writeMessageBegin("setWalletAmountInCart", TMessageType.REPLY, seqid)
5410 
    result.write(oprot)
5411 
    oprot.writeMessageEnd()
5412 
    oprot.trans.flush()
19889 manas 5413 
 
22452 amit.gupta 5414 
  def process_addItemPricingToCart(self, seqid, iprot, oprot):
5415 
    args = addItemPricingToCart_args()
5416 
    args.read(iprot)
5417 
    iprot.readMessageEnd()
5418 
    result = addItemPricingToCart_result()
5419 
    result.success = self._handler.addItemPricingToCart(args.cartId, args.itemPriceQuantityList)
5420 
    oprot.writeMessageBegin("addItemPricingToCart", TMessageType.REPLY, seqid)
5421 
    result.write(oprot)
5422 
    oprot.writeMessageEnd()
5423 
    oprot.trans.flush()
20873 kshitij.so 5424 
 
22452 amit.gupta 5425 
 
94 ashish 5426 
# HELPER FUNCTIONS AND STRUCTURES
5427 
 
559 chandransh 5428 
class createAnonymousUser_args:
94 ashish 5429 
  """
5430 
  Attributes:
559 chandransh 5431 
   - jsessionId
94 ashish 5432 
  """
5433 
 
5434 
  thrift_spec = (
5435 
    None, # 0
559 chandransh 5436 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5437 
  )
5438 
 
559 chandransh 5439 
  def __init__(self, jsessionId=None,):
5440 
    self.jsessionId = jsessionId
94 ashish 5441 
 
5442 
  def read(self, iprot):
5443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5445 
      return
5446 
    iprot.readStructBegin()
5447 
    while True:
5448 
      (fname, ftype, fid) = iprot.readFieldBegin()
5449 
      if ftype == TType.STOP:
5450 
        break
5451 
      if fid == 1:
559 chandransh 5452 
        if ftype == TType.STRING:
5453 
          self.jsessionId = iprot.readString();
94 ashish 5454 
        else:
5455 
          iprot.skip(ftype)
5456 
      else:
5457 
        iprot.skip(ftype)
5458 
      iprot.readFieldEnd()
5459 
    iprot.readStructEnd()
5460 
 
5461 
  def write(self, oprot):
5462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5464 
      return
559 chandransh 5465 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5466 
    if self.jsessionId is not None:
559 chandransh 5467 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5468 
      oprot.writeString(self.jsessionId)
94 ashish 5469 
      oprot.writeFieldEnd()
5470 
    oprot.writeFieldStop()
5471 
    oprot.writeStructEnd()
5472 
 
3431 rajveer 5473 
  def validate(self):
5474 
    return
5475 
 
5476 
 
94 ashish 5477 
  def __repr__(self):
5478 
    L = ['%s=%r' % (key, value)
5479 
      for key, value in self.__dict__.iteritems()]
5480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5481 
 
5482 
  def __eq__(self, other):
5483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5484 
 
5485 
  def __ne__(self, other):
5486 
    return not (self == other)
5487 
 
559 chandransh 5488 
class createAnonymousUser_result:
94 ashish 5489 
  """
5490 
  Attributes:
5491 
   - success
559 chandransh 5492 
   - ucex
94 ashish 5493 
  """
5494 
 
5495 
  thrift_spec = (
559 chandransh 5496 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5497 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5498 
  )
5499 
 
559 chandransh 5500 
  def __init__(self, success=None, ucex=None,):
94 ashish 5501 
    self.success = success
559 chandransh 5502 
    self.ucex = ucex
94 ashish 5503 
 
5504 
  def read(self, iprot):
5505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5507 
      return
5508 
    iprot.readStructBegin()
5509 
    while True:
5510 
      (fname, ftype, fid) = iprot.readFieldBegin()
5511 
      if ftype == TType.STOP:
5512 
        break
5513 
      if fid == 0:
5514 
        if ftype == TType.STRUCT:
559 chandransh 5515 
          self.success = User()
94 ashish 5516 
          self.success.read(iprot)
5517 
        else:
5518 
          iprot.skip(ftype)
5519 
      elif fid == 1:
5520 
        if ftype == TType.STRUCT:
559 chandransh 5521 
          self.ucex = UserContextException()
5522 
          self.ucex.read(iprot)
94 ashish 5523 
        else:
5524 
          iprot.skip(ftype)
5525 
      else:
5526 
        iprot.skip(ftype)
5527 
      iprot.readFieldEnd()
5528 
    iprot.readStructEnd()
5529 
 
5530 
  def write(self, oprot):
5531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5533 
      return
559 chandransh 5534 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5535 
    if self.success is not None:
94 ashish 5536 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5537 
      self.success.write(oprot)
5538 
      oprot.writeFieldEnd()
3431 rajveer 5539 
    if self.ucex is not None:
559 chandransh 5540 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5541 
      self.ucex.write(oprot)
94 ashish 5542 
      oprot.writeFieldEnd()
5543 
    oprot.writeFieldStop()
5544 
    oprot.writeStructEnd()
5545 
 
3431 rajveer 5546 
  def validate(self):
5547 
    return
5548 
 
5549 
 
94 ashish 5550 
  def __repr__(self):
5551 
    L = ['%s=%r' % (key, value)
5552 
      for key, value in self.__dict__.iteritems()]
5553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5554 
 
5555 
  def __eq__(self, other):
5556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5557 
 
5558 
  def __ne__(self, other):
5559 
    return not (self == other)
5560 
 
559 chandransh 5561 
class getUserById_args:
94 ashish 5562 
  """
5563 
  Attributes:
5564 
   - userId
5565 
  """
5566 
 
5567 
  thrift_spec = (
5568 
    None, # 0
5569 
    (1, TType.I64, 'userId', None, None, ), # 1
5570 
  )
5571 
 
559 chandransh 5572 
  def __init__(self, userId=None,):
94 ashish 5573 
    self.userId = userId
5574 
 
5575 
  def read(self, iprot):
5576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5578 
      return
5579 
    iprot.readStructBegin()
5580 
    while True:
5581 
      (fname, ftype, fid) = iprot.readFieldBegin()
5582 
      if ftype == TType.STOP:
5583 
        break
5584 
      if fid == 1:
5585 
        if ftype == TType.I64:
5586 
          self.userId = iprot.readI64();
5587 
        else:
5588 
          iprot.skip(ftype)
5589 
      else:
5590 
        iprot.skip(ftype)
5591 
      iprot.readFieldEnd()
5592 
    iprot.readStructEnd()
5593 
 
5594 
  def write(self, oprot):
5595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5597 
      return
559 chandransh 5598 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5599 
    if self.userId is not None:
94 ashish 5600 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5601 
      oprot.writeI64(self.userId)
5602 
      oprot.writeFieldEnd()
5603 
    oprot.writeFieldStop()
5604 
    oprot.writeStructEnd()
5605 
 
3431 rajveer 5606 
  def validate(self):
5607 
    return
5608 
 
5609 
 
94 ashish 5610 
  def __repr__(self):
5611 
    L = ['%s=%r' % (key, value)
5612 
      for key, value in self.__dict__.iteritems()]
5613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5614 
 
5615 
  def __eq__(self, other):
5616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5617 
 
5618 
  def __ne__(self, other):
5619 
    return not (self == other)
5620 
 
559 chandransh 5621 
class getUserById_result:
94 ashish 5622 
  """
5623 
  Attributes:
5624 
   - success
559 chandransh 5625 
   - ucex
94 ashish 5626 
  """
5627 
 
5628 
  thrift_spec = (
559 chandransh 5629 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5630 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5631 
  )
5632 
 
559 chandransh 5633 
  def __init__(self, success=None, ucex=None,):
94 ashish 5634 
    self.success = success
559 chandransh 5635 
    self.ucex = ucex
94 ashish 5636 
 
5637 
  def read(self, iprot):
5638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5640 
      return
5641 
    iprot.readStructBegin()
5642 
    while True:
5643 
      (fname, ftype, fid) = iprot.readFieldBegin()
5644 
      if ftype == TType.STOP:
5645 
        break
5646 
      if fid == 0:
5647 
        if ftype == TType.STRUCT:
559 chandransh 5648 
          self.success = User()
94 ashish 5649 
          self.success.read(iprot)
5650 
        else:
5651 
          iprot.skip(ftype)
5652 
      elif fid == 1:
5653 
        if ftype == TType.STRUCT:
559 chandransh 5654 
          self.ucex = UserContextException()
5655 
          self.ucex.read(iprot)
94 ashish 5656 
        else:
5657 
          iprot.skip(ftype)
5658 
      else:
5659 
        iprot.skip(ftype)
5660 
      iprot.readFieldEnd()
5661 
    iprot.readStructEnd()
5662 
 
5663 
  def write(self, oprot):
5664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5666 
      return
559 chandransh 5667 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5668 
    if self.success is not None:
94 ashish 5669 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5670 
      self.success.write(oprot)
5671 
      oprot.writeFieldEnd()
3431 rajveer 5672 
    if self.ucex is not None:
559 chandransh 5673 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5674 
      self.ucex.write(oprot)
94 ashish 5675 
      oprot.writeFieldEnd()
5676 
    oprot.writeFieldStop()
5677 
    oprot.writeStructEnd()
5678 
 
3431 rajveer 5679 
  def validate(self):
5680 
    return
5681 
 
5682 
 
94 ashish 5683 
  def __repr__(self):
5684 
    L = ['%s=%r' % (key, value)
5685 
      for key, value in self.__dict__.iteritems()]
5686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5687 
 
5688 
  def __eq__(self, other):
5689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5690 
 
5691 
  def __ne__(self, other):
5692 
    return not (self == other)
5693 
 
5326 rajveer 5694 
class getUserByCartId_args:
1491 vikas 5695 
  """
5696 
  Attributes:
5326 rajveer 5697 
   - cartId
1491 vikas 5698 
  """
5699 
 
5700 
  thrift_spec = (
5701 
    None, # 0
5326 rajveer 5702 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5703 
  )
5704 
 
5326 rajveer 5705 
  def __init__(self, cartId=None,):
5706 
    self.cartId = cartId
1491 vikas 5707 
 
5708 
  def read(self, iprot):
5709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5711 
      return
5712 
    iprot.readStructBegin()
5713 
    while True:
5714 
      (fname, ftype, fid) = iprot.readFieldBegin()
5715 
      if ftype == TType.STOP:
5716 
        break
5717 
      if fid == 1:
5326 rajveer 5718 
        if ftype == TType.I64:
5719 
          self.cartId = iprot.readI64();
1491 vikas 5720 
        else:
5721 
          iprot.skip(ftype)
5722 
      else:
5723 
        iprot.skip(ftype)
5724 
      iprot.readFieldEnd()
5725 
    iprot.readStructEnd()
5726 
 
5727 
  def write(self, oprot):
5728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5730 
      return
5326 rajveer 5731 
    oprot.writeStructBegin('getUserByCartId_args')
5732 
    if self.cartId is not None:
5733 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5734 
      oprot.writeI64(self.cartId)
1491 vikas 5735 
      oprot.writeFieldEnd()
5736 
    oprot.writeFieldStop()
5737 
    oprot.writeStructEnd()
5738 
 
3431 rajveer 5739 
  def validate(self):
5740 
    return
5741 
 
5742 
 
1491 vikas 5743 
  def __repr__(self):
5744 
    L = ['%s=%r' % (key, value)
5745 
      for key, value in self.__dict__.iteritems()]
5746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5747 
 
5748 
  def __eq__(self, other):
5749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5750 
 
5751 
  def __ne__(self, other):
5752 
    return not (self == other)
5753 
 
5326 rajveer 5754 
class getUserByCartId_result:
1491 vikas 5755 
  """
5756 
  Attributes:
5757 
   - success
5758 
   - ucex
5759 
  """
5760 
 
5761 
  thrift_spec = (
5762 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5763 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5764 
  )
5765 
 
5766 
  def __init__(self, success=None, ucex=None,):
5767 
    self.success = success
5768 
    self.ucex = ucex
5769 
 
5770 
  def read(self, iprot):
5771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5773 
      return
5774 
    iprot.readStructBegin()
5775 
    while True:
5776 
      (fname, ftype, fid) = iprot.readFieldBegin()
5777 
      if ftype == TType.STOP:
5778 
        break
5779 
      if fid == 0:
5780 
        if ftype == TType.STRUCT:
5781 
          self.success = User()
5782 
          self.success.read(iprot)
5783 
        else:
5784 
          iprot.skip(ftype)
5785 
      elif fid == 1:
5786 
        if ftype == TType.STRUCT:
5787 
          self.ucex = UserContextException()
5788 
          self.ucex.read(iprot)
5789 
        else:
5790 
          iprot.skip(ftype)
5791 
      else:
5792 
        iprot.skip(ftype)
5793 
      iprot.readFieldEnd()
5794 
    iprot.readStructEnd()
5795 
 
5796 
  def write(self, oprot):
5797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5799 
      return
5326 rajveer 5800 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5801 
    if self.success is not None:
1491 vikas 5802 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5803 
      self.success.write(oprot)
5804 
      oprot.writeFieldEnd()
3431 rajveer 5805 
    if self.ucex is not None:
1491 vikas 5806 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5807 
      self.ucex.write(oprot)
5808 
      oprot.writeFieldEnd()
5809 
    oprot.writeFieldStop()
5810 
    oprot.writeStructEnd()
5811 
 
3431 rajveer 5812 
  def validate(self):
5813 
    return
5814 
 
5815 
 
1491 vikas 5816 
  def __repr__(self):
5817 
    L = ['%s=%r' % (key, value)
5818 
      for key, value in self.__dict__.iteritems()]
5819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5820 
 
5821 
  def __eq__(self, other):
5822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5823 
 
5824 
  def __ne__(self, other):
5825 
    return not (self == other)
5826 
 
5326 rajveer 5827 
class getUserByEmail_args:
3032 mandeep.dh 5828 
  """
5829 
  Attributes:
5326 rajveer 5830 
   - email
3032 mandeep.dh 5831 
  """
5832 
 
5833 
  thrift_spec = (
5834 
    None, # 0
5326 rajveer 5835 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5836 
  )
5837 
 
5326 rajveer 5838 
  def __init__(self, email=None,):
5839 
    self.email = email
3032 mandeep.dh 5840 
 
5841 
  def read(self, iprot):
5842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5844 
      return
5845 
    iprot.readStructBegin()
5846 
    while True:
5847 
      (fname, ftype, fid) = iprot.readFieldBegin()
5848 
      if ftype == TType.STOP:
5849 
        break
5850 
      if fid == 1:
5326 rajveer 5851 
        if ftype == TType.STRING:
5852 
          self.email = iprot.readString();
3032 mandeep.dh 5853 
        else:
5854 
          iprot.skip(ftype)
5855 
      else:
5856 
        iprot.skip(ftype)
5857 
      iprot.readFieldEnd()
5858 
    iprot.readStructEnd()
5859 
 
5860 
  def write(self, oprot):
5861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5863 
      return
5326 rajveer 5864 
    oprot.writeStructBegin('getUserByEmail_args')
5865 
    if self.email is not None:
5866 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5867 
      oprot.writeString(self.email)
3032 mandeep.dh 5868 
      oprot.writeFieldEnd()
5869 
    oprot.writeFieldStop()
5870 
    oprot.writeStructEnd()
5871 
 
3431 rajveer 5872 
  def validate(self):
5873 
    return
5874 
 
5875 
 
3032 mandeep.dh 5876 
  def __repr__(self):
5877 
    L = ['%s=%r' % (key, value)
5878 
      for key, value in self.__dict__.iteritems()]
5879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5880 
 
5881 
  def __eq__(self, other):
5882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5883 
 
5884 
  def __ne__(self, other):
5885 
    return not (self == other)
5886 
 
5326 rajveer 5887 
class getUserByEmail_result:
3032 mandeep.dh 5888 
  """
5889 
  Attributes:
5890 
   - success
5891 
   - ucex
5892 
  """
5893 
 
5894 
  thrift_spec = (
5895 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5896 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5897 
  )
5898 
 
5899 
  def __init__(self, success=None, ucex=None,):
5900 
    self.success = success
5901 
    self.ucex = ucex
5902 
 
5903 
  def read(self, iprot):
5904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5906 
      return
5907 
    iprot.readStructBegin()
5908 
    while True:
5909 
      (fname, ftype, fid) = iprot.readFieldBegin()
5910 
      if ftype == TType.STOP:
5911 
        break
5912 
      if fid == 0:
5913 
        if ftype == TType.STRUCT:
5914 
          self.success = User()
5915 
          self.success.read(iprot)
5916 
        else:
5917 
          iprot.skip(ftype)
5918 
      elif fid == 1:
5919 
        if ftype == TType.STRUCT:
5920 
          self.ucex = UserContextException()
5921 
          self.ucex.read(iprot)
5922 
        else:
5923 
          iprot.skip(ftype)
5924 
      else:
5925 
        iprot.skip(ftype)
5926 
      iprot.readFieldEnd()
5927 
    iprot.readStructEnd()
5928 
 
5929 
  def write(self, oprot):
5930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5932 
      return
5326 rajveer 5933 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5934 
    if self.success is not None:
3032 mandeep.dh 5935 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5936 
      self.success.write(oprot)
5937 
      oprot.writeFieldEnd()
3431 rajveer 5938 
    if self.ucex is not None:
3032 mandeep.dh 5939 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5940 
      self.ucex.write(oprot)
5941 
      oprot.writeFieldEnd()
5942 
    oprot.writeFieldStop()
5943 
    oprot.writeStructEnd()
5944 
 
3431 rajveer 5945 
  def validate(self):
5946 
    return
5947 
 
5948 
 
3032 mandeep.dh 5949 
  def __repr__(self):
5950 
    L = ['%s=%r' % (key, value)
5951 
      for key, value in self.__dict__.iteritems()]
5952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5953 
 
5954 
  def __eq__(self, other):
5955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5956 
 
5957 
  def __ne__(self, other):
5958 
    return not (self == other)
5959 
 
5326 rajveer 5960 
class getUserByMobileNumber_args:
94 ashish 5961 
  """
5962 
  Attributes:
5326 rajveer 5963 
   - mobileNumber
94 ashish 5964 
  """
5965 
 
5966 
  thrift_spec = (
5967 
    None, # 0
5326 rajveer 5968 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5969 
  )
5970 
 
5326 rajveer 5971 
  def __init__(self, mobileNumber=None,):
5972 
    self.mobileNumber = mobileNumber
94 ashish 5973 
 
5974 
  def read(self, iprot):
5975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5977 
      return
5978 
    iprot.readStructBegin()
5979 
    while True:
5980 
      (fname, ftype, fid) = iprot.readFieldBegin()
5981 
      if ftype == TType.STOP:
5982 
        break
5983 
      if fid == 1:
5326 rajveer 5984 
        if ftype == TType.I64:
5985 
          self.mobileNumber = iprot.readI64();
94 ashish 5986 
        else:
5987 
          iprot.skip(ftype)
5988 
      else:
5989 
        iprot.skip(ftype)
5990 
      iprot.readFieldEnd()
5991 
    iprot.readStructEnd()
5992 
 
5993 
  def write(self, oprot):
5994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5996 
      return
5326 rajveer 5997 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5998 
    if self.mobileNumber is not None:
5999 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
6000 
      oprot.writeI64(self.mobileNumber)
94 ashish 6001 
      oprot.writeFieldEnd()
6002 
    oprot.writeFieldStop()
6003 
    oprot.writeStructEnd()
6004 
 
3431 rajveer 6005 
  def validate(self):
6006 
    return
6007 
 
6008 
 
94 ashish 6009 
  def __repr__(self):
6010 
    L = ['%s=%r' % (key, value)
6011 
      for key, value in self.__dict__.iteritems()]
6012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6013 
 
6014 
  def __eq__(self, other):
6015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6016 
 
6017 
  def __ne__(self, other):
6018 
    return not (self == other)
6019 
 
5326 rajveer 6020 
class getUserByMobileNumber_result:
94 ashish 6021 
  """
6022 
  Attributes:
6023 
   - success
559 chandransh 6024 
   - ucex
94 ashish 6025 
  """
6026 
 
6027 
  thrift_spec = (
559 chandransh 6028 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6029 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6030 
  )
6031 
 
559 chandransh 6032 
  def __init__(self, success=None, ucex=None,):
94 ashish 6033 
    self.success = success
559 chandransh 6034 
    self.ucex = ucex
94 ashish 6035 
 
6036 
  def read(self, iprot):
6037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6039 
      return
6040 
    iprot.readStructBegin()
6041 
    while True:
6042 
      (fname, ftype, fid) = iprot.readFieldBegin()
6043 
      if ftype == TType.STOP:
6044 
        break
6045 
      if fid == 0:
6046 
        if ftype == TType.STRUCT:
559 chandransh 6047 
          self.success = User()
94 ashish 6048 
          self.success.read(iprot)
6049 
        else:
6050 
          iprot.skip(ftype)
6051 
      elif fid == 1:
6052 
        if ftype == TType.STRUCT:
559 chandransh 6053 
          self.ucex = UserContextException()
6054 
          self.ucex.read(iprot)
94 ashish 6055 
        else:
6056 
          iprot.skip(ftype)
6057 
      else:
6058 
        iprot.skip(ftype)
6059 
      iprot.readFieldEnd()
6060 
    iprot.readStructEnd()
6061 
 
6062 
  def write(self, oprot):
6063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6065 
      return
5326 rajveer 6066 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 6067 
    if self.success is not None:
94 ashish 6068 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6069 
      self.success.write(oprot)
6070 
      oprot.writeFieldEnd()
3431 rajveer 6071 
    if self.ucex is not None:
559 chandransh 6072 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6073 
      self.ucex.write(oprot)
94 ashish 6074 
      oprot.writeFieldEnd()
6075 
    oprot.writeFieldStop()
6076 
    oprot.writeStructEnd()
6077 
 
3431 rajveer 6078 
  def validate(self):
6079 
    return
6080 
 
6081 
 
94 ashish 6082 
  def __repr__(self):
6083 
    L = ['%s=%r' % (key, value)
6084 
      for key, value in self.__dict__.iteritems()]
6085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6086 
 
6087 
  def __eq__(self, other):
6088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6089 
 
6090 
  def __ne__(self, other):
6091 
    return not (self == other)
6092 
 
5326 rajveer 6093 
class createUser_args:
94 ashish 6094 
  """
6095 
  Attributes:
559 chandransh 6096 
   - user
94 ashish 6097 
  """
6098 
 
6099 
  thrift_spec = (
6100 
    None, # 0
559 chandransh 6101 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6102 
  )
6103 
 
559 chandransh 6104 
  def __init__(self, user=None,):
6105 
    self.user = user
94 ashish 6106 
 
6107 
  def read(self, iprot):
6108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6110 
      return
6111 
    iprot.readStructBegin()
6112 
    while True:
6113 
      (fname, ftype, fid) = iprot.readFieldBegin()
6114 
      if ftype == TType.STOP:
6115 
        break
6116 
      if fid == 1:
559 chandransh 6117 
        if ftype == TType.STRUCT:
6118 
          self.user = User()
6119 
          self.user.read(iprot)
94 ashish 6120 
        else:
6121 
          iprot.skip(ftype)
6122 
      else:
6123 
        iprot.skip(ftype)
6124 
      iprot.readFieldEnd()
6125 
    iprot.readStructEnd()
6126 
 
6127 
  def write(self, oprot):
6128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6130 
      return
5326 rajveer 6131 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 6132 
    if self.user is not None:
559 chandransh 6133 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6134 
      self.user.write(oprot)
94 ashish 6135 
      oprot.writeFieldEnd()
6136 
    oprot.writeFieldStop()
6137 
    oprot.writeStructEnd()
6138 
 
3431 rajveer 6139 
  def validate(self):
6140 
    return
6141 
 
6142 
 
94 ashish 6143 
  def __repr__(self):
6144 
    L = ['%s=%r' % (key, value)
6145 
      for key, value in self.__dict__.iteritems()]
6146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6147 
 
6148 
  def __eq__(self, other):
6149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6150 
 
6151 
  def __ne__(self, other):
6152 
    return not (self == other)
6153 
 
5326 rajveer 6154 
class createUser_result:
94 ashish 6155 
  """
6156 
  Attributes:
6157 
   - success
559 chandransh 6158 
   - ucex
94 ashish 6159 
  """
6160 
 
6161 
  thrift_spec = (
559 chandransh 6162 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6163 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6164 
  )
6165 
 
559 chandransh 6166 
  def __init__(self, success=None, ucex=None,):
94 ashish 6167 
    self.success = success
559 chandransh 6168 
    self.ucex = ucex
94 ashish 6169 
 
6170 
  def read(self, iprot):
6171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6173 
      return
6174 
    iprot.readStructBegin()
6175 
    while True:
6176 
      (fname, ftype, fid) = iprot.readFieldBegin()
6177 
      if ftype == TType.STOP:
6178 
        break
6179 
      if fid == 0:
6180 
        if ftype == TType.STRUCT:
559 chandransh 6181 
          self.success = User()
94 ashish 6182 
          self.success.read(iprot)
6183 
        else:
6184 
          iprot.skip(ftype)
6185 
      elif fid == 1:
6186 
        if ftype == TType.STRUCT:
559 chandransh 6187 
          self.ucex = UserContextException()
6188 
          self.ucex.read(iprot)
94 ashish 6189 
        else:
6190 
          iprot.skip(ftype)
6191 
      else:
6192 
        iprot.skip(ftype)
6193 
      iprot.readFieldEnd()
6194 
    iprot.readStructEnd()
6195 
 
6196 
  def write(self, oprot):
6197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6199 
      return
5326 rajveer 6200 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 6201 
    if self.success is not None:
94 ashish 6202 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6203 
      self.success.write(oprot)
6204 
      oprot.writeFieldEnd()
3431 rajveer 6205 
    if self.ucex is not None:
559 chandransh 6206 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6207 
      self.ucex.write(oprot)
94 ashish 6208 
      oprot.writeFieldEnd()
6209 
    oprot.writeFieldStop()
6210 
    oprot.writeStructEnd()
6211 
 
3431 rajveer 6212 
  def validate(self):
6213 
    return
6214 
 
6215 
 
94 ashish 6216 
  def __repr__(self):
6217 
    L = ['%s=%r' % (key, value)
6218 
      for key, value in self.__dict__.iteritems()]
6219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6220 
 
6221 
  def __eq__(self, other):
6222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6223 
 
6224 
  def __ne__(self, other):
6225 
    return not (self == other)
6226 
 
5326 rajveer 6227 
class updateUser_args:
94 ashish 6228 
  """
6229 
  Attributes:
5326 rajveer 6230 
   - user
94 ashish 6231 
  """
6232 
 
6233 
  thrift_spec = (
6234 
    None, # 0
5326 rajveer 6235 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6236 
  )
6237 
 
5326 rajveer 6238 
  def __init__(self, user=None,):
6239 
    self.user = user
94 ashish 6240 
 
6241 
  def read(self, iprot):
6242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6244 
      return
6245 
    iprot.readStructBegin()
6246 
    while True:
6247 
      (fname, ftype, fid) = iprot.readFieldBegin()
6248 
      if ftype == TType.STOP:
6249 
        break
6250 
      if fid == 1:
5326 rajveer 6251 
        if ftype == TType.STRUCT:
6252 
          self.user = User()
6253 
          self.user.read(iprot)
94 ashish 6254 
        else:
6255 
          iprot.skip(ftype)
6256 
      else:
6257 
        iprot.skip(ftype)
6258 
      iprot.readFieldEnd()
6259 
    iprot.readStructEnd()
6260 
 
6261 
  def write(self, oprot):
6262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6264 
      return
5326 rajveer 6265 
    oprot.writeStructBegin('updateUser_args')
6266 
    if self.user is not None:
6267 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6268 
      self.user.write(oprot)
94 ashish 6269 
      oprot.writeFieldEnd()
6270 
    oprot.writeFieldStop()
6271 
    oprot.writeStructEnd()
6272 
 
3431 rajveer 6273 
  def validate(self):
6274 
    return
6275 
 
6276 
 
94 ashish 6277 
  def __repr__(self):
6278 
    L = ['%s=%r' % (key, value)
6279 
      for key, value in self.__dict__.iteritems()]
6280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6281 
 
6282 
  def __eq__(self, other):
6283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6284 
 
6285 
  def __ne__(self, other):
6286 
    return not (self == other)
6287 
 
5326 rajveer 6288 
class updateUser_result:
94 ashish 6289 
  """
6290 
  Attributes:
6291 
   - success
559 chandransh 6292 
   - ucex
94 ashish 6293 
  """
6294 
 
6295 
  thrift_spec = (
5326 rajveer 6296 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6297 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6298 
  )
6299 
 
559 chandransh 6300 
  def __init__(self, success=None, ucex=None,):
94 ashish 6301 
    self.success = success
559 chandransh 6302 
    self.ucex = ucex
94 ashish 6303 
 
6304 
  def read(self, iprot):
6305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6307 
      return
6308 
    iprot.readStructBegin()
6309 
    while True:
6310 
      (fname, ftype, fid) = iprot.readFieldBegin()
6311 
      if ftype == TType.STOP:
6312 
        break
6313 
      if fid == 0:
5326 rajveer 6314 
        if ftype == TType.STRUCT:
6315 
          self.success = User()
6316 
          self.success.read(iprot)
94 ashish 6317 
        else:
6318 
          iprot.skip(ftype)
6319 
      elif fid == 1:
6320 
        if ftype == TType.STRUCT:
559 chandransh 6321 
          self.ucex = UserContextException()
6322 
          self.ucex.read(iprot)
94 ashish 6323 
        else:
6324 
          iprot.skip(ftype)
6325 
      else:
6326 
        iprot.skip(ftype)
6327 
      iprot.readFieldEnd()
6328 
    iprot.readStructEnd()
6329 
 
6330 
  def write(self, oprot):
6331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6333 
      return
5326 rajveer 6334 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6335 
    if self.success is not None:
5326 rajveer 6336 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6337 
      self.success.write(oprot)
94 ashish 6338 
      oprot.writeFieldEnd()
3431 rajveer 6339 
    if self.ucex is not None:
559 chandransh 6340 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6341 
      self.ucex.write(oprot)
94 ashish 6342 
      oprot.writeFieldEnd()
6343 
    oprot.writeFieldStop()
6344 
    oprot.writeStructEnd()
6345 
 
3431 rajveer 6346 
  def validate(self):
6347 
    return
6348 
 
6349 
 
94 ashish 6350 
  def __repr__(self):
6351 
    L = ['%s=%r' % (key, value)
6352 
      for key, value in self.__dict__.iteritems()]
6353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6354 
 
6355 
  def __eq__(self, other):
6356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6357 
 
6358 
  def __ne__(self, other):
6359 
    return not (self == other)
6360 
 
559 chandransh 6361 
class authenticateUser_args:
94 ashish 6362 
  """
6363 
  Attributes:
6364 
   - email
6365 
   - password
6366 
  """
6367 
 
6368 
  thrift_spec = (
6369 
    None, # 0
6370 
    (1, TType.STRING, 'email', None, None, ), # 1
6371 
    (2, TType.STRING, 'password', None, None, ), # 2
6372 
  )
6373 
 
6374 
  def __init__(self, email=None, password=None,):
6375 
    self.email = email
6376 
    self.password = password
6377 
 
6378 
  def read(self, iprot):
6379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6381 
      return
6382 
    iprot.readStructBegin()
6383 
    while True:
6384 
      (fname, ftype, fid) = iprot.readFieldBegin()
6385 
      if ftype == TType.STOP:
6386 
        break
6387 
      if fid == 1:
6388 
        if ftype == TType.STRING:
6389 
          self.email = iprot.readString();
6390 
        else:
6391 
          iprot.skip(ftype)
6392 
      elif fid == 2:
6393 
        if ftype == TType.STRING:
6394 
          self.password = iprot.readString();
6395 
        else:
6396 
          iprot.skip(ftype)
6397 
      else:
6398 
        iprot.skip(ftype)
6399 
      iprot.readFieldEnd()
6400 
    iprot.readStructEnd()
6401 
 
6402 
  def write(self, oprot):
6403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6405 
      return
559 chandransh 6406 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6407 
    if self.email is not None:
94 ashish 6408 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6409 
      oprot.writeString(self.email)
6410 
      oprot.writeFieldEnd()
3431 rajveer 6411 
    if self.password is not None:
94 ashish 6412 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6413 
      oprot.writeString(self.password)
6414 
      oprot.writeFieldEnd()
6415 
    oprot.writeFieldStop()
6416 
    oprot.writeStructEnd()
6417 
 
3431 rajveer 6418 
  def validate(self):
6419 
    return
6420 
 
6421 
 
94 ashish 6422 
  def __repr__(self):
6423 
    L = ['%s=%r' % (key, value)
6424 
      for key, value in self.__dict__.iteritems()]
6425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6426 
 
6427 
  def __eq__(self, other):
6428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6429 
 
6430 
  def __ne__(self, other):
6431 
    return not (self == other)
6432 
 
559 chandransh 6433 
class authenticateUser_result:
94 ashish 6434 
  """
6435 
  Attributes:
6436 
   - success
559 chandransh 6437 
   - auex
94 ashish 6438 
  """
6439 
 
6440 
  thrift_spec = (
559 chandransh 6441 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6442 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6443 
  )
6444 
 
559 chandransh 6445 
  def __init__(self, success=None, auex=None,):
94 ashish 6446 
    self.success = success
559 chandransh 6447 
    self.auex = auex
94 ashish 6448 
 
6449 
  def read(self, iprot):
6450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6452 
      return
6453 
    iprot.readStructBegin()
6454 
    while True:
6455 
      (fname, ftype, fid) = iprot.readFieldBegin()
6456 
      if ftype == TType.STOP:
6457 
        break
6458 
      if fid == 0:
6459 
        if ftype == TType.STRUCT:
559 chandransh 6460 
          self.success = User()
94 ashish 6461 
          self.success.read(iprot)
6462 
        else:
6463 
          iprot.skip(ftype)
6464 
      elif fid == 1:
6465 
        if ftype == TType.STRUCT:
559 chandransh 6466 
          self.auex = AuthenticationException()
6467 
          self.auex.read(iprot)
94 ashish 6468 
        else:
6469 
          iprot.skip(ftype)
6470 
      else:
6471 
        iprot.skip(ftype)
6472 
      iprot.readFieldEnd()
6473 
    iprot.readStructEnd()
6474 
 
6475 
  def write(self, oprot):
6476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6478 
      return
559 chandransh 6479 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6480 
    if self.success is not None:
94 ashish 6481 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6482 
      self.success.write(oprot)
6483 
      oprot.writeFieldEnd()
3431 rajveer 6484 
    if self.auex is not None:
559 chandransh 6485 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6486 
      self.auex.write(oprot)
94 ashish 6487 
      oprot.writeFieldEnd()
6488 
    oprot.writeFieldStop()
6489 
    oprot.writeStructEnd()
6490 
 
3431 rajveer 6491 
  def validate(self):
6492 
    return
6493 
 
6494 
 
94 ashish 6495 
  def __repr__(self):
6496 
    L = ['%s=%r' % (key, value)
6497 
      for key, value in self.__dict__.iteritems()]
6498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6499 
 
6500 
  def __eq__(self, other):
6501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6502 
 
6503 
  def __ne__(self, other):
6504 
    return not (self == other)
6505 
 
559 chandransh 6506 
class userExists_args:
122 ashish 6507 
  """
6508 
  Attributes:
559 chandransh 6509 
   - email
122 ashish 6510 
  """
6511 
 
6512 
  thrift_spec = (
6513 
    None, # 0
559 chandransh 6514 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6515 
  )
6516 
 
559 chandransh 6517 
  def __init__(self, email=None,):
6518 
    self.email = email
122 ashish 6519 
 
6520 
  def read(self, iprot):
6521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6523 
      return
6524 
    iprot.readStructBegin()
6525 
    while True:
6526 
      (fname, ftype, fid) = iprot.readFieldBegin()
6527 
      if ftype == TType.STOP:
6528 
        break
6529 
      if fid == 1:
6530 
        if ftype == TType.STRING:
559 chandransh 6531 
          self.email = iprot.readString();
122 ashish 6532 
        else:
6533 
          iprot.skip(ftype)
559 chandransh 6534 
      else:
6535 
        iprot.skip(ftype)
6536 
      iprot.readFieldEnd()
6537 
    iprot.readStructEnd()
6538 
 
6539 
  def write(self, oprot):
6540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6542 
      return
6543 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6544 
    if self.email is not None:
559 chandransh 6545 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6546 
      oprot.writeString(self.email)
6547 
      oprot.writeFieldEnd()
6548 
    oprot.writeFieldStop()
6549 
    oprot.writeStructEnd()
6550 
 
3431 rajveer 6551 
  def validate(self):
6552 
    return
6553 
 
6554 
 
559 chandransh 6555 
  def __repr__(self):
6556 
    L = ['%s=%r' % (key, value)
6557 
      for key, value in self.__dict__.iteritems()]
6558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6559 
 
6560 
  def __eq__(self, other):
6561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6562 
 
6563 
  def __ne__(self, other):
6564 
    return not (self == other)
6565 
 
6566 
class userExists_result:
6567 
  """
6568 
  Attributes:
6569 
   - success
6570 
   - ucx
6571 
  """
6572 
 
6573 
  thrift_spec = (
6574 
    (0, TType.BOOL, 'success', None, None, ), # 0
6575 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6576 
  )
6577 
 
6578 
  def __init__(self, success=None, ucx=None,):
6579 
    self.success = success
6580 
    self.ucx = ucx
6581 
 
6582 
  def read(self, iprot):
6583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6585 
      return
6586 
    iprot.readStructBegin()
6587 
    while True:
6588 
      (fname, ftype, fid) = iprot.readFieldBegin()
6589 
      if ftype == TType.STOP:
6590 
        break
6591 
      if fid == 0:
6592 
        if ftype == TType.BOOL:
6593 
          self.success = iprot.readBool();
6594 
        else:
6595 
          iprot.skip(ftype)
6596 
      elif fid == 1:
6597 
        if ftype == TType.STRUCT:
6598 
          self.ucx = UserContextException()
6599 
          self.ucx.read(iprot)
6600 
        else:
6601 
          iprot.skip(ftype)
6602 
      else:
6603 
        iprot.skip(ftype)
6604 
      iprot.readFieldEnd()
6605 
    iprot.readStructEnd()
6606 
 
6607 
  def write(self, oprot):
6608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6610 
      return
6611 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6612 
    if self.success is not None:
559 chandransh 6613 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6614 
      oprot.writeBool(self.success)
6615 
      oprot.writeFieldEnd()
3431 rajveer 6616 
    if self.ucx is not None:
559 chandransh 6617 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6618 
      self.ucx.write(oprot)
6619 
      oprot.writeFieldEnd()
6620 
    oprot.writeFieldStop()
6621 
    oprot.writeStructEnd()
6622 
 
3431 rajveer 6623 
  def validate(self):
6624 
    return
6625 
 
6626 
 
559 chandransh 6627 
  def __repr__(self):
6628 
    L = ['%s=%r' % (key, value)
6629 
      for key, value in self.__dict__.iteritems()]
6630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6631 
 
6632 
  def __eq__(self, other):
6633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6634 
 
6635 
  def __ne__(self, other):
6636 
    return not (self == other)
6637 
 
6638 
class addAddressForUser_args:
6639 
  """
6640 
  Attributes:
6641 
   - userId
6642 
   - address
6643 
   - setDefault
6644 
  """
6645 
 
6646 
  thrift_spec = (
6647 
    None, # 0
6648 
    (1, TType.I64, 'userId', None, None, ), # 1
6649 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6650 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6651 
  )
6652 
 
567 rajveer 6653 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6654 
    self.userId = userId
6655 
    self.address = address
6656 
    self.setDefault = setDefault
6657 
 
6658 
  def read(self, iprot):
6659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6661 
      return
6662 
    iprot.readStructBegin()
6663 
    while True:
6664 
      (fname, ftype, fid) = iprot.readFieldBegin()
6665 
      if ftype == TType.STOP:
6666 
        break
6667 
      if fid == 1:
6668 
        if ftype == TType.I64:
6669 
          self.userId = iprot.readI64();
6670 
        else:
6671 
          iprot.skip(ftype)
122 ashish 6672 
      elif fid == 2:
559 chandransh 6673 
        if ftype == TType.STRUCT:
6674 
          self.address = Address()
6675 
          self.address.read(iprot)
122 ashish 6676 
        else:
6677 
          iprot.skip(ftype)
6678 
      elif fid == 3:
6679 
        if ftype == TType.BOOL:
559 chandransh 6680 
          self.setDefault = iprot.readBool();
122 ashish 6681 
        else:
6682 
          iprot.skip(ftype)
6683 
      else:
6684 
        iprot.skip(ftype)
6685 
      iprot.readFieldEnd()
6686 
    iprot.readStructEnd()
6687 
 
6688 
  def write(self, oprot):
6689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6691 
      return
559 chandransh 6692 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6693 
    if self.userId is not None:
559 chandransh 6694 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6695 
      oprot.writeI64(self.userId)
122 ashish 6696 
      oprot.writeFieldEnd()
3431 rajveer 6697 
    if self.address is not None:
559 chandransh 6698 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6699 
      self.address.write(oprot)
122 ashish 6700 
      oprot.writeFieldEnd()
3431 rajveer 6701 
    if self.setDefault is not None:
567 rajveer 6702 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6703 
      oprot.writeBool(self.setDefault)
6704 
      oprot.writeFieldEnd()
122 ashish 6705 
    oprot.writeFieldStop()
6706 
    oprot.writeStructEnd()
6707 
 
3431 rajveer 6708 
  def validate(self):
6709 
    return
6710 
 
6711 
 
122 ashish 6712 
  def __repr__(self):
6713 
    L = ['%s=%r' % (key, value)
6714 
      for key, value in self.__dict__.iteritems()]
6715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6716 
 
6717 
  def __eq__(self, other):
6718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6719 
 
6720 
  def __ne__(self, other):
6721 
    return not (self == other)
6722 
 
559 chandransh 6723 
class addAddressForUser_result:
122 ashish 6724 
  """
6725 
  Attributes:
6726 
   - success
559 chandransh 6727 
   - ucx
122 ashish 6728 
  """
6729 
 
6730 
  thrift_spec = (
567 rajveer 6731 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6732 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6733 
  )
6734 
 
559 chandransh 6735 
  def __init__(self, success=None, ucx=None,):
122 ashish 6736 
    self.success = success
559 chandransh 6737 
    self.ucx = ucx
122 ashish 6738 
 
6739 
  def read(self, iprot):
6740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6742 
      return
6743 
    iprot.readStructBegin()
6744 
    while True:
6745 
      (fname, ftype, fid) = iprot.readFieldBegin()
6746 
      if ftype == TType.STOP:
6747 
        break
6748 
      if fid == 0:
567 rajveer 6749 
        if ftype == TType.I64:
6750 
          self.success = iprot.readI64();
122 ashish 6751 
        else:
6752 
          iprot.skip(ftype)
6753 
      elif fid == 1:
6754 
        if ftype == TType.STRUCT:
559 chandransh 6755 
          self.ucx = UserContextException()
6756 
          self.ucx.read(iprot)
122 ashish 6757 
        else:
6758 
          iprot.skip(ftype)
6759 
      else:
6760 
        iprot.skip(ftype)
6761 
      iprot.readFieldEnd()
6762 
    iprot.readStructEnd()
6763 
 
6764 
  def write(self, oprot):
6765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6767 
      return
559 chandransh 6768 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6769 
    if self.success is not None:
567 rajveer 6770 
      oprot.writeFieldBegin('success', TType.I64, 0)
6771 
      oprot.writeI64(self.success)
122 ashish 6772 
      oprot.writeFieldEnd()
3431 rajveer 6773 
    if self.ucx is not None:
559 chandransh 6774 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6775 
      self.ucx.write(oprot)
122 ashish 6776 
      oprot.writeFieldEnd()
6777 
    oprot.writeFieldStop()
6778 
    oprot.writeStructEnd()
6779 
 
3431 rajveer 6780 
  def validate(self):
6781 
    return
6782 
 
6783 
 
122 ashish 6784 
  def __repr__(self):
6785 
    L = ['%s=%r' % (key, value)
6786 
      for key, value in self.__dict__.iteritems()]
6787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6788 
 
6789 
  def __eq__(self, other):
6790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6791 
 
6792 
  def __ne__(self, other):
6793 
    return not (self == other)
6794 
 
559 chandransh 6795 
class removeAddressForUser_args:
94 ashish 6796 
  """
6797 
  Attributes:
559 chandransh 6798 
   - userid
6799 
   - addressId
94 ashish 6800 
  """
6801 
 
6802 
  thrift_spec = (
6803 
    None, # 0
559 chandransh 6804 
    (1, TType.I64, 'userid', None, None, ), # 1
6805 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6806 
  )
6807 
 
559 chandransh 6808 
  def __init__(self, userid=None, addressId=None,):
6809 
    self.userid = userid
6810 
    self.addressId = addressId
94 ashish 6811 
 
6812 
  def read(self, iprot):
6813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6815 
      return
6816 
    iprot.readStructBegin()
6817 
    while True:
6818 
      (fname, ftype, fid) = iprot.readFieldBegin()
6819 
      if ftype == TType.STOP:
6820 
        break
6821 
      if fid == 1:
559 chandransh 6822 
        if ftype == TType.I64:
6823 
          self.userid = iprot.readI64();
94 ashish 6824 
        else:
6825 
          iprot.skip(ftype)
559 chandransh 6826 
      elif fid == 2:
6827 
        if ftype == TType.I64:
6828 
          self.addressId = iprot.readI64();
6829 
        else:
6830 
          iprot.skip(ftype)
94 ashish 6831 
      else:
6832 
        iprot.skip(ftype)
6833 
      iprot.readFieldEnd()
6834 
    iprot.readStructEnd()
6835 
 
6836 
  def write(self, oprot):
6837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6839 
      return
559 chandransh 6840 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6841 
    if self.userid is not None:
559 chandransh 6842 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6843 
      oprot.writeI64(self.userid)
94 ashish 6844 
      oprot.writeFieldEnd()
3431 rajveer 6845 
    if self.addressId is not None:
559 chandransh 6846 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6847 
      oprot.writeI64(self.addressId)
6848 
      oprot.writeFieldEnd()
94 ashish 6849 
    oprot.writeFieldStop()
6850 
    oprot.writeStructEnd()
6851 
 
3431 rajveer 6852 
  def validate(self):
6853 
    return
6854 
 
6855 
 
94 ashish 6856 
  def __repr__(self):
6857 
    L = ['%s=%r' % (key, value)
6858 
      for key, value in self.__dict__.iteritems()]
6859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6860 
 
6861 
  def __eq__(self, other):
6862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6863 
 
6864 
  def __ne__(self, other):
6865 
    return not (self == other)
6866 
 
559 chandransh 6867 
class removeAddressForUser_result:
94 ashish 6868 
  """
6869 
  Attributes:
6870 
   - success
6871 
   - ucx
6872 
  """
6873 
 
6874 
  thrift_spec = (
6875 
    (0, TType.BOOL, 'success', None, None, ), # 0
6876 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6877 
  )
6878 
 
6879 
  def __init__(self, success=None, ucx=None,):
6880 
    self.success = success
6881 
    self.ucx = ucx
6882 
 
6883 
  def read(self, iprot):
6884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6886 
      return
6887 
    iprot.readStructBegin()
6888 
    while True:
6889 
      (fname, ftype, fid) = iprot.readFieldBegin()
6890 
      if ftype == TType.STOP:
6891 
        break
6892 
      if fid == 0:
6893 
        if ftype == TType.BOOL:
6894 
          self.success = iprot.readBool();
6895 
        else:
6896 
          iprot.skip(ftype)
6897 
      elif fid == 1:
6898 
        if ftype == TType.STRUCT:
6899 
          self.ucx = UserContextException()
6900 
          self.ucx.read(iprot)
6901 
        else:
6902 
          iprot.skip(ftype)
6903 
      else:
6904 
        iprot.skip(ftype)
6905 
      iprot.readFieldEnd()
6906 
    iprot.readStructEnd()
6907 
 
6908 
  def write(self, oprot):
6909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6911 
      return
559 chandransh 6912 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6913 
    if self.success is not None:
94 ashish 6914 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6915 
      oprot.writeBool(self.success)
6916 
      oprot.writeFieldEnd()
3431 rajveer 6917 
    if self.ucx is not None:
94 ashish 6918 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6919 
      self.ucx.write(oprot)
6920 
      oprot.writeFieldEnd()
6921 
    oprot.writeFieldStop()
6922 
    oprot.writeStructEnd()
6923 
 
3431 rajveer 6924 
  def validate(self):
6925 
    return
6926 
 
6927 
 
94 ashish 6928 
  def __repr__(self):
6929 
    L = ['%s=%r' % (key, value)
6930 
      for key, value in self.__dict__.iteritems()]
6931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6932 
 
6933 
  def __eq__(self, other):
6934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6935 
 
6936 
  def __ne__(self, other):
6937 
    return not (self == other)
6938 
 
22358 ashik.ali 6939 
class updateAddress_args:
6940 
  """
6941 
  Attributes:
6942 
   - address
6943 
  """
6944 
 
6945 
  thrift_spec = (
6946 
    None, # 0
6947 
    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
6948 
  )
6949 
 
6950 
  def __init__(self, address=None,):
6951 
    self.address = address
6952 
 
6953 
  def read(self, iprot):
6954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6956 
      return
6957 
    iprot.readStructBegin()
6958 
    while True:
6959 
      (fname, ftype, fid) = iprot.readFieldBegin()
6960 
      if ftype == TType.STOP:
6961 
        break
6962 
      if fid == 1:
6963 
        if ftype == TType.STRUCT:
6964 
          self.address = Address()
6965 
          self.address.read(iprot)
6966 
        else:
6967 
          iprot.skip(ftype)
6968 
      else:
6969 
        iprot.skip(ftype)
6970 
      iprot.readFieldEnd()
6971 
    iprot.readStructEnd()
6972 
 
6973 
  def write(self, oprot):
6974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6976 
      return
6977 
    oprot.writeStructBegin('updateAddress_args')
6978 
    if self.address is not None:
6979 
      oprot.writeFieldBegin('address', TType.STRUCT, 1)
6980 
      self.address.write(oprot)
6981 
      oprot.writeFieldEnd()
6982 
    oprot.writeFieldStop()
6983 
    oprot.writeStructEnd()
6984 
 
6985 
  def validate(self):
6986 
    return
6987 
 
6988 
 
6989 
  def __repr__(self):
6990 
    L = ['%s=%r' % (key, value)
6991 
      for key, value in self.__dict__.iteritems()]
6992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6993 
 
6994 
  def __eq__(self, other):
6995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6996 
 
6997 
  def __ne__(self, other):
6998 
    return not (self == other)
6999 
 
7000 
class updateAddress_result:
7001 
  """
7002 
  Attributes:
7003 
   - success
7004 
   - ucx
7005 
  """
7006 
 
7007 
  thrift_spec = (
7008 
    (0, TType.BOOL, 'success', None, None, ), # 0
7009 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7010 
  )
7011 
 
7012 
  def __init__(self, success=None, ucx=None,):
7013 
    self.success = success
7014 
    self.ucx = ucx
7015 
 
7016 
  def read(self, iprot):
7017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7019 
      return
7020 
    iprot.readStructBegin()
7021 
    while True:
7022 
      (fname, ftype, fid) = iprot.readFieldBegin()
7023 
      if ftype == TType.STOP:
7024 
        break
7025 
      if fid == 0:
7026 
        if ftype == TType.BOOL:
7027 
          self.success = iprot.readBool();
7028 
        else:
7029 
          iprot.skip(ftype)
7030 
      elif fid == 1:
7031 
        if ftype == TType.STRUCT:
7032 
          self.ucx = UserContextException()
7033 
          self.ucx.read(iprot)
7034 
        else:
7035 
          iprot.skip(ftype)
7036 
      else:
7037 
        iprot.skip(ftype)
7038 
      iprot.readFieldEnd()
7039 
    iprot.readStructEnd()
7040 
 
7041 
  def write(self, oprot):
7042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7044 
      return
7045 
    oprot.writeStructBegin('updateAddress_result')
7046 
    if self.success is not None:
7047 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7048 
      oprot.writeBool(self.success)
7049 
      oprot.writeFieldEnd()
7050 
    if self.ucx is not None:
7051 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7052 
      self.ucx.write(oprot)
7053 
      oprot.writeFieldEnd()
7054 
    oprot.writeFieldStop()
7055 
    oprot.writeStructEnd()
7056 
 
7057 
  def validate(self):
7058 
    return
7059 
 
7060 
 
7061 
  def __repr__(self):
7062 
    L = ['%s=%r' % (key, value)
7063 
      for key, value in self.__dict__.iteritems()]
7064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7065 
 
7066 
  def __eq__(self, other):
7067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7068 
 
7069 
  def __ne__(self, other):
7070 
    return not (self == other)
7071 
 
22364 ashik.ali 7072 
class updateCounter_args:
7073 
  """
7074 
  Attributes:
7075 
   - counter
7076 
  """
7077 
 
7078 
  thrift_spec = (
7079 
    None, # 0
7080 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
7081 
  )
7082 
 
7083 
  def __init__(self, counter=None,):
7084 
    self.counter = counter
7085 
 
7086 
  def read(self, iprot):
7087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7089 
      return
7090 
    iprot.readStructBegin()
7091 
    while True:
7092 
      (fname, ftype, fid) = iprot.readFieldBegin()
7093 
      if ftype == TType.STOP:
7094 
        break
7095 
      if fid == 1:
7096 
        if ftype == TType.STRUCT:
7097 
          self.counter = Counter()
7098 
          self.counter.read(iprot)
7099 
        else:
7100 
          iprot.skip(ftype)
7101 
      else:
7102 
        iprot.skip(ftype)
7103 
      iprot.readFieldEnd()
7104 
    iprot.readStructEnd()
7105 
 
7106 
  def write(self, oprot):
7107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7109 
      return
7110 
    oprot.writeStructBegin('updateCounter_args')
7111 
    if self.counter is not None:
7112 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
7113 
      self.counter.write(oprot)
7114 
      oprot.writeFieldEnd()
7115 
    oprot.writeFieldStop()
7116 
    oprot.writeStructEnd()
7117 
 
7118 
  def validate(self):
7119 
    return
7120 
 
7121 
 
7122 
  def __repr__(self):
7123 
    L = ['%s=%r' % (key, value)
7124 
      for key, value in self.__dict__.iteritems()]
7125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7126 
 
7127 
  def __eq__(self, other):
7128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7129 
 
7130 
  def __ne__(self, other):
7131 
    return not (self == other)
7132 
 
7133 
class updateCounter_result:
7134 
  """
7135 
  Attributes:
7136 
   - success
7137 
   - ucx
7138 
  """
7139 
 
7140 
  thrift_spec = (
7141 
    (0, TType.BOOL, 'success', None, None, ), # 0
7142 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7143 
  )
7144 
 
7145 
  def __init__(self, success=None, ucx=None,):
7146 
    self.success = success
7147 
    self.ucx = ucx
7148 
 
7149 
  def read(self, iprot):
7150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7152 
      return
7153 
    iprot.readStructBegin()
7154 
    while True:
7155 
      (fname, ftype, fid) = iprot.readFieldBegin()
7156 
      if ftype == TType.STOP:
7157 
        break
7158 
      if fid == 0:
7159 
        if ftype == TType.BOOL:
7160 
          self.success = iprot.readBool();
7161 
        else:
7162 
          iprot.skip(ftype)
7163 
      elif fid == 1:
7164 
        if ftype == TType.STRUCT:
7165 
          self.ucx = UserContextException()
7166 
          self.ucx.read(iprot)
7167 
        else:
7168 
          iprot.skip(ftype)
7169 
      else:
7170 
        iprot.skip(ftype)
7171 
      iprot.readFieldEnd()
7172 
    iprot.readStructEnd()
7173 
 
7174 
  def write(self, oprot):
7175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7177 
      return
7178 
    oprot.writeStructBegin('updateCounter_result')
7179 
    if self.success is not None:
7180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7181 
      oprot.writeBool(self.success)
7182 
      oprot.writeFieldEnd()
7183 
    if self.ucx is not None:
7184 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7185 
      self.ucx.write(oprot)
7186 
      oprot.writeFieldEnd()
7187 
    oprot.writeFieldStop()
7188 
    oprot.writeStructEnd()
7189 
 
7190 
  def validate(self):
7191 
    return
7192 
 
7193 
 
7194 
  def __repr__(self):
7195 
    L = ['%s=%r' % (key, value)
7196 
      for key, value in self.__dict__.iteritems()]
7197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7198 
 
7199 
  def __eq__(self, other):
7200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7201 
 
7202 
  def __ne__(self, other):
7203 
    return not (self == other)
7204 
 
559 chandransh 7205 
class setUserAsLoggedIn_args:
94 ashish 7206 
  """
7207 
  Attributes:
559 chandransh 7208 
   - userId
94 ashish 7209 
   - timestamp
7210 
  """
7211 
 
7212 
  thrift_spec = (
7213 
    None, # 0
559 chandransh 7214 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 7215 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7216 
  )
7217 
 
559 chandransh 7218 
  def __init__(self, userId=None, timestamp=None,):
7219 
    self.userId = userId
94 ashish 7220 
    self.timestamp = timestamp
7221 
 
7222 
  def read(self, iprot):
7223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7225 
      return
7226 
    iprot.readStructBegin()
7227 
    while True:
7228 
      (fname, ftype, fid) = iprot.readFieldBegin()
7229 
      if ftype == TType.STOP:
7230 
        break
7231 
      if fid == 1:
559 chandransh 7232 
        if ftype == TType.I64:
7233 
          self.userId = iprot.readI64();
94 ashish 7234 
        else:
7235 
          iprot.skip(ftype)
7236 
      elif fid == 2:
7237 
        if ftype == TType.I64:
7238 
          self.timestamp = iprot.readI64();
7239 
        else:
7240 
          iprot.skip(ftype)
7241 
      else:
7242 
        iprot.skip(ftype)
7243 
      iprot.readFieldEnd()
7244 
    iprot.readStructEnd()
7245 
 
7246 
  def write(self, oprot):
7247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7249 
      return
559 chandransh 7250 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 7251 
    if self.userId is not None:
559 chandransh 7252 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7253 
      oprot.writeI64(self.userId)
94 ashish 7254 
      oprot.writeFieldEnd()
3431 rajveer 7255 
    if self.timestamp is not None:
94 ashish 7256 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7257 
      oprot.writeI64(self.timestamp)
7258 
      oprot.writeFieldEnd()
7259 
    oprot.writeFieldStop()
7260 
    oprot.writeStructEnd()
7261 
 
3431 rajveer 7262 
  def validate(self):
7263 
    return
7264 
 
7265 
 
94 ashish 7266 
  def __repr__(self):
7267 
    L = ['%s=%r' % (key, value)
7268 
      for key, value in self.__dict__.iteritems()]
7269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7270 
 
7271 
  def __eq__(self, other):
7272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7273 
 
7274 
  def __ne__(self, other):
7275 
    return not (self == other)
7276 
 
559 chandransh 7277 
class setUserAsLoggedIn_result:
94 ashish 7278 
  """
7279 
  Attributes:
7280 
   - success
7281 
   - ucx
7282 
  """
7283 
 
7284 
  thrift_spec = (
7285 
    (0, TType.BOOL, 'success', None, None, ), # 0
7286 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7287 
  )
7288 
 
7289 
  def __init__(self, success=None, ucx=None,):
7290 
    self.success = success
7291 
    self.ucx = ucx
7292 
 
7293 
  def read(self, iprot):
7294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7296 
      return
7297 
    iprot.readStructBegin()
7298 
    while True:
7299 
      (fname, ftype, fid) = iprot.readFieldBegin()
7300 
      if ftype == TType.STOP:
7301 
        break
7302 
      if fid == 0:
7303 
        if ftype == TType.BOOL:
7304 
          self.success = iprot.readBool();
7305 
        else:
7306 
          iprot.skip(ftype)
7307 
      elif fid == 1:
7308 
        if ftype == TType.STRUCT:
7309 
          self.ucx = UserContextException()
7310 
          self.ucx.read(iprot)
7311 
        else:
7312 
          iprot.skip(ftype)
7313 
      else:
7314 
        iprot.skip(ftype)
7315 
      iprot.readFieldEnd()
7316 
    iprot.readStructEnd()
7317 
 
7318 
  def write(self, oprot):
7319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7321 
      return
559 chandransh 7322 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 7323 
    if self.success is not None:
94 ashish 7324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7325 
      oprot.writeBool(self.success)
7326 
      oprot.writeFieldEnd()
3431 rajveer 7327 
    if self.ucx is not None:
94 ashish 7328 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7329 
      self.ucx.write(oprot)
7330 
      oprot.writeFieldEnd()
7331 
    oprot.writeFieldStop()
7332 
    oprot.writeStructEnd()
7333 
 
3431 rajveer 7334 
  def validate(self):
7335 
    return
7336 
 
7337 
 
94 ashish 7338 
  def __repr__(self):
7339 
    L = ['%s=%r' % (key, value)
7340 
      for key, value in self.__dict__.iteritems()]
7341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7342 
 
7343 
  def __eq__(self, other):
7344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7345 
 
7346 
  def __ne__(self, other):
7347 
    return not (self == other)
7348 
 
559 chandransh 7349 
class setUserAsLoggedOut_args:
94 ashish 7350 
  """
7351 
  Attributes:
7352 
   - userid
7353 
   - timestamp
7354 
  """
7355 
 
7356 
  thrift_spec = (
7357 
    None, # 0
559 chandransh 7358 
    (1, TType.I64, 'userid', None, None, ), # 1
7359 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 7360 
  )
7361 
 
559 chandransh 7362 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 7363 
    self.userid = userid
7364 
    self.timestamp = timestamp
7365 
 
7366 
  def read(self, iprot):
7367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7369 
      return
7370 
    iprot.readStructBegin()
7371 
    while True:
7372 
      (fname, ftype, fid) = iprot.readFieldBegin()
7373 
      if ftype == TType.STOP:
7374 
        break
7375 
      if fid == 1:
7376 
        if ftype == TType.I64:
7377 
          self.userid = iprot.readI64();
7378 
        else:
7379 
          iprot.skip(ftype)
559 chandransh 7380 
      elif fid == 2:
94 ashish 7381 
        if ftype == TType.I64:
7382 
          self.timestamp = iprot.readI64();
7383 
        else:
7384 
          iprot.skip(ftype)
7385 
      else:
7386 
        iprot.skip(ftype)
7387 
      iprot.readFieldEnd()
7388 
    iprot.readStructEnd()
7389 
 
7390 
  def write(self, oprot):
7391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7393 
      return
559 chandransh 7394 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 7395 
    if self.userid is not None:
559 chandransh 7396 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 7397 
      oprot.writeI64(self.userid)
7398 
      oprot.writeFieldEnd()
3431 rajveer 7399 
    if self.timestamp is not None:
559 chandransh 7400 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 7401 
      oprot.writeI64(self.timestamp)
7402 
      oprot.writeFieldEnd()
7403 
    oprot.writeFieldStop()
7404 
    oprot.writeStructEnd()
7405 
 
3431 rajveer 7406 
  def validate(self):
7407 
    return
7408 
 
7409 
 
94 ashish 7410 
  def __repr__(self):
7411 
    L = ['%s=%r' % (key, value)
7412 
      for key, value in self.__dict__.iteritems()]
7413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7414 
 
7415 
  def __eq__(self, other):
7416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7417 
 
7418 
  def __ne__(self, other):
7419 
    return not (self == other)
7420 
 
559 chandransh 7421 
class setUserAsLoggedOut_result:
94 ashish 7422 
  """
7423 
  Attributes:
7424 
   - success
7425 
   - ucx
7426 
  """
7427 
 
7428 
  thrift_spec = (
7429 
    (0, TType.BOOL, 'success', None, None, ), # 0
7430 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7431 
  )
7432 
 
7433 
  def __init__(self, success=None, ucx=None,):
7434 
    self.success = success
7435 
    self.ucx = ucx
7436 
 
7437 
  def read(self, iprot):
7438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7440 
      return
7441 
    iprot.readStructBegin()
7442 
    while True:
7443 
      (fname, ftype, fid) = iprot.readFieldBegin()
7444 
      if ftype == TType.STOP:
7445 
        break
7446 
      if fid == 0:
7447 
        if ftype == TType.BOOL:
7448 
          self.success = iprot.readBool();
7449 
        else:
7450 
          iprot.skip(ftype)
7451 
      elif fid == 1:
7452 
        if ftype == TType.STRUCT:
7453 
          self.ucx = UserContextException()
7454 
          self.ucx.read(iprot)
7455 
        else:
7456 
          iprot.skip(ftype)
7457 
      else:
7458 
        iprot.skip(ftype)
7459 
      iprot.readFieldEnd()
7460 
    iprot.readStructEnd()
7461 
 
7462 
  def write(self, oprot):
7463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7465 
      return
559 chandransh 7466 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 7467 
    if self.success is not None:
94 ashish 7468 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7469 
      oprot.writeBool(self.success)
7470 
      oprot.writeFieldEnd()
3431 rajveer 7471 
    if self.ucx is not None:
94 ashish 7472 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7473 
      self.ucx.write(oprot)
7474 
      oprot.writeFieldEnd()
7475 
    oprot.writeFieldStop()
7476 
    oprot.writeStructEnd()
7477 
 
3431 rajveer 7478 
  def validate(self):
7479 
    return
7480 
 
7481 
 
94 ashish 7482 
  def __repr__(self):
7483 
    L = ['%s=%r' % (key, value)
7484 
      for key, value in self.__dict__.iteritems()]
7485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7486 
 
7487 
  def __eq__(self, other):
7488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7489 
 
7490 
  def __ne__(self, other):
7491 
    return not (self == other)
7492 
 
559 chandransh 7493 
class setDefaultAddress_args:
94 ashish 7494 
  """
7495 
  Attributes:
7496 
   - userid
7497 
   - addressId
7498 
  """
7499 
 
7500 
  thrift_spec = (
7501 
    None, # 0
7502 
    (1, TType.I64, 'userid', None, None, ), # 1
7503 
    (2, TType.I64, 'addressId', None, None, ), # 2
7504 
  )
7505 
 
7506 
  def __init__(self, userid=None, addressId=None,):
7507 
    self.userid = userid
7508 
    self.addressId = addressId
7509 
 
7510 
  def read(self, iprot):
7511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7513 
      return
7514 
    iprot.readStructBegin()
7515 
    while True:
7516 
      (fname, ftype, fid) = iprot.readFieldBegin()
7517 
      if ftype == TType.STOP:
7518 
        break
7519 
      if fid == 1:
7520 
        if ftype == TType.I64:
7521 
          self.userid = iprot.readI64();
7522 
        else:
7523 
          iprot.skip(ftype)
7524 
      elif fid == 2:
7525 
        if ftype == TType.I64:
7526 
          self.addressId = iprot.readI64();
7527 
        else:
7528 
          iprot.skip(ftype)
7529 
      else:
7530 
        iprot.skip(ftype)
7531 
      iprot.readFieldEnd()
7532 
    iprot.readStructEnd()
7533 
 
7534 
  def write(self, oprot):
7535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7537 
      return
559 chandransh 7538 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7539 
    if self.userid is not None:
94 ashish 7540 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7541 
      oprot.writeI64(self.userid)
7542 
      oprot.writeFieldEnd()
3431 rajveer 7543 
    if self.addressId is not None:
94 ashish 7544 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7545 
      oprot.writeI64(self.addressId)
7546 
      oprot.writeFieldEnd()
7547 
    oprot.writeFieldStop()
7548 
    oprot.writeStructEnd()
7549 
 
3431 rajveer 7550 
  def validate(self):
7551 
    return
7552 
 
7553 
 
94 ashish 7554 
  def __repr__(self):
7555 
    L = ['%s=%r' % (key, value)
7556 
      for key, value in self.__dict__.iteritems()]
7557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7558 
 
7559 
  def __eq__(self, other):
7560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7561 
 
7562 
  def __ne__(self, other):
7563 
    return not (self == other)
7564 
 
559 chandransh 7565 
class setDefaultAddress_result:
94 ashish 7566 
  """
7567 
  Attributes:
7568 
   - success
7569 
   - ucx
7570 
  """
7571 
 
7572 
  thrift_spec = (
7573 
    (0, TType.BOOL, 'success', None, None, ), # 0
7574 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7575 
  )
7576 
 
7577 
  def __init__(self, success=None, ucx=None,):
7578 
    self.success = success
7579 
    self.ucx = ucx
7580 
 
7581 
  def read(self, iprot):
7582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7584 
      return
7585 
    iprot.readStructBegin()
7586 
    while True:
7587 
      (fname, ftype, fid) = iprot.readFieldBegin()
7588 
      if ftype == TType.STOP:
7589 
        break
7590 
      if fid == 0:
7591 
        if ftype == TType.BOOL:
7592 
          self.success = iprot.readBool();
7593 
        else:
7594 
          iprot.skip(ftype)
7595 
      elif fid == 1:
7596 
        if ftype == TType.STRUCT:
7597 
          self.ucx = UserContextException()
7598 
          self.ucx.read(iprot)
7599 
        else:
7600 
          iprot.skip(ftype)
7601 
      else:
7602 
        iprot.skip(ftype)
7603 
      iprot.readFieldEnd()
7604 
    iprot.readStructEnd()
7605 
 
7606 
  def write(self, oprot):
7607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7609 
      return
559 chandransh 7610 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7611 
    if self.success is not None:
94 ashish 7612 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7613 
      oprot.writeBool(self.success)
7614 
      oprot.writeFieldEnd()
3431 rajveer 7615 
    if self.ucx is not None:
94 ashish 7616 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7617 
      self.ucx.write(oprot)
7618 
      oprot.writeFieldEnd()
7619 
    oprot.writeFieldStop()
7620 
    oprot.writeStructEnd()
7621 
 
3431 rajveer 7622 
  def validate(self):
7623 
    return
7624 
 
7625 
 
94 ashish 7626 
  def __repr__(self):
7627 
    L = ['%s=%r' % (key, value)
7628 
      for key, value in self.__dict__.iteritems()]
7629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7630 
 
7631 
  def __eq__(self, other):
7632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7633 
 
7634 
  def __ne__(self, other):
7635 
    return not (self == other)
7636 
 
559 chandransh 7637 
class updatePassword_args:
94 ashish 7638 
  """
7639 
  Attributes:
559 chandransh 7640 
   - userid
594 rajveer 7641 
   - oldPassword
7642 
   - newPassword
94 ashish 7643 
  """
7644 
 
7645 
  thrift_spec = (
7646 
    None, # 0
559 chandransh 7647 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7648 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7649 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7650 
  )
7651 
 
594 rajveer 7652 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7653 
    self.userid = userid
594 rajveer 7654 
    self.oldPassword = oldPassword
7655 
    self.newPassword = newPassword
94 ashish 7656 
 
7657 
  def read(self, iprot):
7658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7660 
      return
7661 
    iprot.readStructBegin()
7662 
    while True:
7663 
      (fname, ftype, fid) = iprot.readFieldBegin()
7664 
      if ftype == TType.STOP:
7665 
        break
7666 
      if fid == 1:
7667 
        if ftype == TType.I64:
559 chandransh 7668 
          self.userid = iprot.readI64();
94 ashish 7669 
        else:
7670 
          iprot.skip(ftype)
7671 
      elif fid == 2:
559 chandransh 7672 
        if ftype == TType.STRING:
594 rajveer 7673 
          self.oldPassword = iprot.readString();
94 ashish 7674 
        else:
7675 
          iprot.skip(ftype)
594 rajveer 7676 
      elif fid == 3:
7677 
        if ftype == TType.STRING:
7678 
          self.newPassword = iprot.readString();
7679 
        else:
7680 
          iprot.skip(ftype)
94 ashish 7681 
      else:
7682 
        iprot.skip(ftype)
7683 
      iprot.readFieldEnd()
7684 
    iprot.readStructEnd()
7685 
 
7686 
  def write(self, oprot):
7687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7689 
      return
559 chandransh 7690 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7691 
    if self.userid is not None:
559 chandransh 7692 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7693 
      oprot.writeI64(self.userid)
94 ashish 7694 
      oprot.writeFieldEnd()
3431 rajveer 7695 
    if self.oldPassword is not None:
594 rajveer 7696 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7697 
      oprot.writeString(self.oldPassword)
94 ashish 7698 
      oprot.writeFieldEnd()
3431 rajveer 7699 
    if self.newPassword is not None:
594 rajveer 7700 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7701 
      oprot.writeString(self.newPassword)
7702 
      oprot.writeFieldEnd()
94 ashish 7703 
    oprot.writeFieldStop()
7704 
    oprot.writeStructEnd()
7705 
 
3431 rajveer 7706 
  def validate(self):
7707 
    return
7708 
 
7709 
 
94 ashish 7710 
  def __repr__(self):
7711 
    L = ['%s=%r' % (key, value)
7712 
      for key, value in self.__dict__.iteritems()]
7713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7714 
 
7715 
  def __eq__(self, other):
7716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7717 
 
7718 
  def __ne__(self, other):
7719 
    return not (self == other)
7720 
 
559 chandransh 7721 
class updatePassword_result:
94 ashish 7722 
  """
7723 
  Attributes:
7724 
   - success
7725 
   - ucx
7726 
  """
7727 
 
7728 
  thrift_spec = (
7729 
    (0, TType.BOOL, 'success', None, None, ), # 0
7730 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7731 
  )
7732 
 
7733 
  def __init__(self, success=None, ucx=None,):
7734 
    self.success = success
7735 
    self.ucx = ucx
7736 
 
7737 
  def read(self, iprot):
7738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7740 
      return
7741 
    iprot.readStructBegin()
7742 
    while True:
7743 
      (fname, ftype, fid) = iprot.readFieldBegin()
7744 
      if ftype == TType.STOP:
7745 
        break
7746 
      if fid == 0:
7747 
        if ftype == TType.BOOL:
7748 
          self.success = iprot.readBool();
7749 
        else:
7750 
          iprot.skip(ftype)
7751 
      elif fid == 1:
7752 
        if ftype == TType.STRUCT:
7753 
          self.ucx = UserContextException()
7754 
          self.ucx.read(iprot)
7755 
        else:
7756 
          iprot.skip(ftype)
7757 
      else:
7758 
        iprot.skip(ftype)
7759 
      iprot.readFieldEnd()
7760 
    iprot.readStructEnd()
7761 
 
7762 
  def write(self, oprot):
7763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7765 
      return
559 chandransh 7766 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7767 
    if self.success is not None:
94 ashish 7768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7769 
      oprot.writeBool(self.success)
7770 
      oprot.writeFieldEnd()
3431 rajveer 7771 
    if self.ucx is not None:
94 ashish 7772 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7773 
      self.ucx.write(oprot)
7774 
      oprot.writeFieldEnd()
7775 
    oprot.writeFieldStop()
7776 
    oprot.writeStructEnd()
7777 
 
3431 rajveer 7778 
  def validate(self):
7779 
    return
7780 
 
7781 
 
94 ashish 7782 
  def __repr__(self):
7783 
    L = ['%s=%r' % (key, value)
7784 
      for key, value in self.__dict__.iteritems()]
7785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7786 
 
7787 
  def __eq__(self, other):
7788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7789 
 
7790 
  def __ne__(self, other):
7791 
    return not (self == other)
7792 
 
581 rajveer 7793 
class forgotPassword_args:
7794 
  """
7795 
  Attributes:
7796 
   - email
884 rajveer 7797 
   - newPassword
581 rajveer 7798 
  """
7799 
 
7800 
  thrift_spec = (
7801 
    None, # 0
7802 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7803 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7804 
  )
7805 
 
884 rajveer 7806 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7807 
    self.email = email
884 rajveer 7808 
    self.newPassword = newPassword
581 rajveer 7809 
 
7810 
  def read(self, iprot):
7811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7813 
      return
7814 
    iprot.readStructBegin()
7815 
    while True:
7816 
      (fname, ftype, fid) = iprot.readFieldBegin()
7817 
      if ftype == TType.STOP:
7818 
        break
7819 
      if fid == 1:
7820 
        if ftype == TType.STRING:
7821 
          self.email = iprot.readString();
7822 
        else:
7823 
          iprot.skip(ftype)
884 rajveer 7824 
      elif fid == 2:
7825 
        if ftype == TType.STRING:
7826 
          self.newPassword = iprot.readString();
7827 
        else:
7828 
          iprot.skip(ftype)
581 rajveer 7829 
      else:
7830 
        iprot.skip(ftype)
7831 
      iprot.readFieldEnd()
7832 
    iprot.readStructEnd()
7833 
 
7834 
  def write(self, oprot):
7835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7837 
      return
7838 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7839 
    if self.email is not None:
581 rajveer 7840 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7841 
      oprot.writeString(self.email)
7842 
      oprot.writeFieldEnd()
3431 rajveer 7843 
    if self.newPassword is not None:
884 rajveer 7844 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7845 
      oprot.writeString(self.newPassword)
7846 
      oprot.writeFieldEnd()
581 rajveer 7847 
    oprot.writeFieldStop()
7848 
    oprot.writeStructEnd()
7849 
 
3431 rajveer 7850 
  def validate(self):
7851 
    return
7852 
 
7853 
 
581 rajveer 7854 
  def __repr__(self):
7855 
    L = ['%s=%r' % (key, value)
7856 
      for key, value in self.__dict__.iteritems()]
7857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7858 
 
7859 
  def __eq__(self, other):
7860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7861 
 
7862 
  def __ne__(self, other):
7863 
    return not (self == other)
7864 
 
7865 
class forgotPassword_result:
7866 
  """
7867 
  Attributes:
7868 
   - success
7869 
   - ucx
7870 
  """
7871 
 
7872 
  thrift_spec = (
7873 
    (0, TType.BOOL, 'success', None, None, ), # 0
7874 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7875 
  )
7876 
 
7877 
  def __init__(self, success=None, ucx=None,):
7878 
    self.success = success
7879 
    self.ucx = ucx
7880 
 
7881 
  def read(self, iprot):
7882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7884 
      return
7885 
    iprot.readStructBegin()
7886 
    while True:
7887 
      (fname, ftype, fid) = iprot.readFieldBegin()
7888 
      if ftype == TType.STOP:
7889 
        break
7890 
      if fid == 0:
7891 
        if ftype == TType.BOOL:
7892 
          self.success = iprot.readBool();
7893 
        else:
7894 
          iprot.skip(ftype)
7895 
      elif fid == 1:
7896 
        if ftype == TType.STRUCT:
7897 
          self.ucx = UserContextException()
7898 
          self.ucx.read(iprot)
7899 
        else:
7900 
          iprot.skip(ftype)
7901 
      else:
7902 
        iprot.skip(ftype)
7903 
      iprot.readFieldEnd()
7904 
    iprot.readStructEnd()
7905 
 
7906 
  def write(self, oprot):
7907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7909 
      return
7910 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7911 
    if self.success is not None:
581 rajveer 7912 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7913 
      oprot.writeBool(self.success)
7914 
      oprot.writeFieldEnd()
3431 rajveer 7915 
    if self.ucx is not None:
581 rajveer 7916 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7917 
      self.ucx.write(oprot)
7918 
      oprot.writeFieldEnd()
7919 
    oprot.writeFieldStop()
7920 
    oprot.writeStructEnd()
7921 
 
3431 rajveer 7922 
  def validate(self):
7923 
    return
7924 
 
7925 
 
581 rajveer 7926 
  def __repr__(self):
7927 
    L = ['%s=%r' % (key, value)
7928 
      for key, value in self.__dict__.iteritems()]
7929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7930 
 
7931 
  def __eq__(self, other):
7932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7933 
 
7934 
  def __ne__(self, other):
7935 
    return not (self == other)
7936 
 
594 rajveer 7937 
class getAllAddressesForUser_args:
7938 
  """
7939 
  Attributes:
7940 
   - userId
7941 
  """
7942 
 
7943 
  thrift_spec = (
7944 
    None, # 0
7945 
    (1, TType.I64, 'userId', None, None, ), # 1
7946 
  )
7947 
 
7948 
  def __init__(self, userId=None,):
7949 
    self.userId = userId
7950 
 
7951 
  def read(self, iprot):
7952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7954 
      return
7955 
    iprot.readStructBegin()
7956 
    while True:
7957 
      (fname, ftype, fid) = iprot.readFieldBegin()
7958 
      if ftype == TType.STOP:
7959 
        break
7960 
      if fid == 1:
7961 
        if ftype == TType.I64:
7962 
          self.userId = iprot.readI64();
7963 
        else:
7964 
          iprot.skip(ftype)
7965 
      else:
7966 
        iprot.skip(ftype)
7967 
      iprot.readFieldEnd()
7968 
    iprot.readStructEnd()
7969 
 
7970 
  def write(self, oprot):
7971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7973 
      return
7974 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7975 
    if self.userId is not None:
594 rajveer 7976 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7977 
      oprot.writeI64(self.userId)
7978 
      oprot.writeFieldEnd()
7979 
    oprot.writeFieldStop()
7980 
    oprot.writeStructEnd()
7981 
 
3431 rajveer 7982 
  def validate(self):
7983 
    return
7984 
 
7985 
 
594 rajveer 7986 
  def __repr__(self):
7987 
    L = ['%s=%r' % (key, value)
7988 
      for key, value in self.__dict__.iteritems()]
7989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7990 
 
7991 
  def __eq__(self, other):
7992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7993 
 
7994 
  def __ne__(self, other):
7995 
    return not (self == other)
7996 
 
7997 
class getAllAddressesForUser_result:
7998 
  """
7999 
  Attributes:
8000 
   - success
8001 
   - ucx
8002 
  """
8003 
 
8004 
  thrift_spec = (
8005 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
8006 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8007 
  )
8008 
 
8009 
  def __init__(self, success=None, ucx=None,):
8010 
    self.success = success
8011 
    self.ucx = ucx
8012 
 
8013 
  def read(self, iprot):
8014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8016 
      return
8017 
    iprot.readStructBegin()
8018 
    while True:
8019 
      (fname, ftype, fid) = iprot.readFieldBegin()
8020 
      if ftype == TType.STOP:
8021 
        break
8022 
      if fid == 0:
8023 
        if ftype == TType.LIST:
8024 
          self.success = []
11592 amit.gupta 8025 
          (_etype100, _size97) = iprot.readListBegin()
8026 
          for _i101 in xrange(_size97):
8027 
            _elem102 = Address()
8028 
            _elem102.read(iprot)
8029 
            self.success.append(_elem102)
594 rajveer 8030 
          iprot.readListEnd()
8031 
        else:
8032 
          iprot.skip(ftype)
8033 
      elif fid == 1:
8034 
        if ftype == TType.STRUCT:
8035 
          self.ucx = UserContextException()
8036 
          self.ucx.read(iprot)
8037 
        else:
8038 
          iprot.skip(ftype)
8039 
      else:
8040 
        iprot.skip(ftype)
8041 
      iprot.readFieldEnd()
8042 
    iprot.readStructEnd()
8043 
 
8044 
  def write(self, oprot):
8045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8047 
      return
8048 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 8049 
    if self.success is not None:
594 rajveer 8050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8052 
      for iter103 in self.success:
8053 
        iter103.write(oprot)
594 rajveer 8054 
      oprot.writeListEnd()
8055 
      oprot.writeFieldEnd()
3431 rajveer 8056 
    if self.ucx is not None:
594 rajveer 8057 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8058 
      self.ucx.write(oprot)
8059 
      oprot.writeFieldEnd()
8060 
    oprot.writeFieldStop()
8061 
    oprot.writeStructEnd()
8062 
 
3431 rajveer 8063 
  def validate(self):
8064 
    return
8065 
 
8066 
 
594 rajveer 8067 
  def __repr__(self):
8068 
    L = ['%s=%r' % (key, value)
8069 
      for key, value in self.__dict__.iteritems()]
8070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8071 
 
8072 
  def __eq__(self, other):
8073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8074 
 
8075 
  def __ne__(self, other):
8076 
    return not (self == other)
8077 
 
1894 vikas 8078 
class getAddressById_args:
8079 
  """
8080 
  Attributes:
8081 
   - addressId
8082 
  """
8083 
 
8084 
  thrift_spec = (
8085 
    None, # 0
8086 
    (1, TType.I64, 'addressId', None, None, ), # 1
8087 
  )
8088 
 
8089 
  def __init__(self, addressId=None,):
8090 
    self.addressId = addressId
8091 
 
8092 
  def read(self, iprot):
8093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8095 
      return
8096 
    iprot.readStructBegin()
8097 
    while True:
8098 
      (fname, ftype, fid) = iprot.readFieldBegin()
8099 
      if ftype == TType.STOP:
8100 
        break
8101 
      if fid == 1:
8102 
        if ftype == TType.I64:
8103 
          self.addressId = iprot.readI64();
8104 
        else:
8105 
          iprot.skip(ftype)
8106 
      else:
8107 
        iprot.skip(ftype)
8108 
      iprot.readFieldEnd()
8109 
    iprot.readStructEnd()
8110 
 
8111 
  def write(self, oprot):
8112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8114 
      return
8115 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 8116 
    if self.addressId is not None:
1894 vikas 8117 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
8118 
      oprot.writeI64(self.addressId)
8119 
      oprot.writeFieldEnd()
8120 
    oprot.writeFieldStop()
8121 
    oprot.writeStructEnd()
8122 
 
3431 rajveer 8123 
  def validate(self):
8124 
    return
8125 
 
8126 
 
1894 vikas 8127 
  def __repr__(self):
8128 
    L = ['%s=%r' % (key, value)
8129 
      for key, value in self.__dict__.iteritems()]
8130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8131 
 
8132 
  def __eq__(self, other):
8133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8134 
 
8135 
  def __ne__(self, other):
8136 
    return not (self == other)
8137 
 
8138 
class getAddressById_result:
8139 
  """
8140 
  Attributes:
8141 
   - success
8142 
   - ucx
8143 
  """
8144 
 
8145 
  thrift_spec = (
8146 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
8147 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8148 
  )
8149 
 
8150 
  def __init__(self, success=None, ucx=None,):
8151 
    self.success = success
8152 
    self.ucx = ucx
8153 
 
8154 
  def read(self, iprot):
8155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8157 
      return
8158 
    iprot.readStructBegin()
8159 
    while True:
8160 
      (fname, ftype, fid) = iprot.readFieldBegin()
8161 
      if ftype == TType.STOP:
8162 
        break
8163 
      if fid == 0:
8164 
        if ftype == TType.STRUCT:
8165 
          self.success = Address()
8166 
          self.success.read(iprot)
8167 
        else:
8168 
          iprot.skip(ftype)
8169 
      elif fid == 1:
8170 
        if ftype == TType.STRUCT:
8171 
          self.ucx = UserContextException()
8172 
          self.ucx.read(iprot)
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      else:
8176 
        iprot.skip(ftype)
8177 
      iprot.readFieldEnd()
8178 
    iprot.readStructEnd()
8179 
 
8180 
  def write(self, oprot):
8181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8183 
      return
8184 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 8185 
    if self.success is not None:
1894 vikas 8186 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8187 
      self.success.write(oprot)
8188 
      oprot.writeFieldEnd()
3431 rajveer 8189 
    if self.ucx is not None:
1894 vikas 8190 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8191 
      self.ucx.write(oprot)
8192 
      oprot.writeFieldEnd()
8193 
    oprot.writeFieldStop()
8194 
    oprot.writeStructEnd()
8195 
 
3431 rajveer 8196 
  def validate(self):
8197 
    return
8198 
 
8199 
 
1894 vikas 8200 
  def __repr__(self):
8201 
    L = ['%s=%r' % (key, value)
8202 
      for key, value in self.__dict__.iteritems()]
8203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8204 
 
8205 
  def __eq__(self, other):
8206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8207 
 
8208 
  def __ne__(self, other):
8209 
    return not (self == other)
8210 
 
594 rajveer 8211 
class getDefaultAddressId_args:
8212 
  """
8213 
  Attributes:
8214 
   - userId
8215 
  """
8216 
 
8217 
  thrift_spec = (
8218 
    None, # 0
8219 
    (1, TType.I64, 'userId', None, None, ), # 1
8220 
  )
8221 
 
8222 
  def __init__(self, userId=None,):
8223 
    self.userId = userId
8224 
 
8225 
  def read(self, iprot):
8226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8228 
      return
8229 
    iprot.readStructBegin()
8230 
    while True:
8231 
      (fname, ftype, fid) = iprot.readFieldBegin()
8232 
      if ftype == TType.STOP:
8233 
        break
8234 
      if fid == 1:
8235 
        if ftype == TType.I64:
8236 
          self.userId = iprot.readI64();
8237 
        else:
8238 
          iprot.skip(ftype)
8239 
      else:
8240 
        iprot.skip(ftype)
8241 
      iprot.readFieldEnd()
8242 
    iprot.readStructEnd()
8243 
 
8244 
  def write(self, oprot):
8245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8247 
      return
8248 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 8249 
    if self.userId is not None:
594 rajveer 8250 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8251 
      oprot.writeI64(self.userId)
8252 
      oprot.writeFieldEnd()
8253 
    oprot.writeFieldStop()
8254 
    oprot.writeStructEnd()
8255 
 
3431 rajveer 8256 
  def validate(self):
8257 
    return
8258 
 
8259 
 
594 rajveer 8260 
  def __repr__(self):
8261 
    L = ['%s=%r' % (key, value)
8262 
      for key, value in self.__dict__.iteritems()]
8263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8264 
 
8265 
  def __eq__(self, other):
8266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8267 
 
8268 
  def __ne__(self, other):
8269 
    return not (self == other)
8270 
 
8271 
class getDefaultAddressId_result:
8272 
  """
8273 
  Attributes:
8274 
   - success
8275 
   - ucx
8276 
  """
8277 
 
8278 
  thrift_spec = (
8279 
    (0, TType.I64, 'success', None, None, ), # 0
8280 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8281 
  )
8282 
 
8283 
  def __init__(self, success=None, ucx=None,):
8284 
    self.success = success
8285 
    self.ucx = ucx
8286 
 
8287 
  def read(self, iprot):
8288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8290 
      return
8291 
    iprot.readStructBegin()
8292 
    while True:
8293 
      (fname, ftype, fid) = iprot.readFieldBegin()
8294 
      if ftype == TType.STOP:
8295 
        break
8296 
      if fid == 0:
8297 
        if ftype == TType.I64:
8298 
          self.success = iprot.readI64();
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      elif fid == 1:
8302 
        if ftype == TType.STRUCT:
8303 
          self.ucx = UserContextException()
8304 
          self.ucx.read(iprot)
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      else:
8308 
        iprot.skip(ftype)
8309 
      iprot.readFieldEnd()
8310 
    iprot.readStructEnd()
8311 
 
8312 
  def write(self, oprot):
8313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8315 
      return
8316 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 8317 
    if self.success is not None:
594 rajveer 8318 
      oprot.writeFieldBegin('success', TType.I64, 0)
8319 
      oprot.writeI64(self.success)
8320 
      oprot.writeFieldEnd()
3431 rajveer 8321 
    if self.ucx is not None:
594 rajveer 8322 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8323 
      self.ucx.write(oprot)
8324 
      oprot.writeFieldEnd()
8325 
    oprot.writeFieldStop()
8326 
    oprot.writeStructEnd()
8327 
 
3431 rajveer 8328 
  def validate(self):
8329 
    return
8330 
 
8331 
 
594 rajveer 8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
785 rajveer 8343 
class getDefaultPincode_args:
8344 
  """
8345 
  Attributes:
8346 
   - userId
8347 
  """
8348 
 
8349 
  thrift_spec = (
8350 
    None, # 0
8351 
    (1, TType.I64, 'userId', None, None, ), # 1
8352 
  )
8353 
 
8354 
  def __init__(self, userId=None,):
8355 
    self.userId = userId
8356 
 
8357 
  def read(self, iprot):
8358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8360 
      return
8361 
    iprot.readStructBegin()
8362 
    while True:
8363 
      (fname, ftype, fid) = iprot.readFieldBegin()
8364 
      if ftype == TType.STOP:
8365 
        break
8366 
      if fid == 1:
8367 
        if ftype == TType.I64:
8368 
          self.userId = iprot.readI64();
8369 
        else:
8370 
          iprot.skip(ftype)
8371 
      else:
8372 
        iprot.skip(ftype)
8373 
      iprot.readFieldEnd()
8374 
    iprot.readStructEnd()
8375 
 
8376 
  def write(self, oprot):
8377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8379 
      return
8380 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 8381 
    if self.userId is not None:
785 rajveer 8382 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8383 
      oprot.writeI64(self.userId)
8384 
      oprot.writeFieldEnd()
8385 
    oprot.writeFieldStop()
8386 
    oprot.writeStructEnd()
8387 
 
3431 rajveer 8388 
  def validate(self):
8389 
    return
8390 
 
8391 
 
785 rajveer 8392 
  def __repr__(self):
8393 
    L = ['%s=%r' % (key, value)
8394 
      for key, value in self.__dict__.iteritems()]
8395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8396 
 
8397 
  def __eq__(self, other):
8398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8399 
 
8400 
  def __ne__(self, other):
8401 
    return not (self == other)
8402 
 
8403 
class getDefaultPincode_result:
8404 
  """
8405 
  Attributes:
8406 
   - success
8407 
   - ucx
8408 
  """
8409 
 
8410 
  thrift_spec = (
8411 
    (0, TType.STRING, 'success', None, None, ), # 0
8412 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
8413 
  )
8414 
 
8415 
  def __init__(self, success=None, ucx=None,):
8416 
    self.success = success
8417 
    self.ucx = ucx
8418 
 
8419 
  def read(self, iprot):
8420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8422 
      return
8423 
    iprot.readStructBegin()
8424 
    while True:
8425 
      (fname, ftype, fid) = iprot.readFieldBegin()
8426 
      if ftype == TType.STOP:
8427 
        break
8428 
      if fid == 0:
8429 
        if ftype == TType.STRING:
8430 
          self.success = iprot.readString();
8431 
        else:
8432 
          iprot.skip(ftype)
8433 
      elif fid == 1:
8434 
        if ftype == TType.STRUCT:
8435 
          self.ucx = UserContextException()
8436 
          self.ucx.read(iprot)
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      else:
8440 
        iprot.skip(ftype)
8441 
      iprot.readFieldEnd()
8442 
    iprot.readStructEnd()
8443 
 
8444 
  def write(self, oprot):
8445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8447 
      return
8448 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 8449 
    if self.success is not None:
785 rajveer 8450 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8451 
      oprot.writeString(self.success)
8452 
      oprot.writeFieldEnd()
3431 rajveer 8453 
    if self.ucx is not None:
785 rajveer 8454 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8455 
      self.ucx.write(oprot)
8456 
      oprot.writeFieldEnd()
8457 
    oprot.writeFieldStop()
8458 
    oprot.writeStructEnd()
8459 
 
3431 rajveer 8460 
  def validate(self):
8461 
    return
8462 
 
8463 
 
785 rajveer 8464 
  def __repr__(self):
8465 
    L = ['%s=%r' % (key, value)
8466 
      for key, value in self.__dict__.iteritems()]
8467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8468 
 
8469 
  def __eq__(self, other):
8470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8471 
 
8472 
  def __ne__(self, other):
8473 
    return not (self == other)
8474 
 
1274 varun.gupt 8475 
class saveUserCommunication_args:
8476 
  """
8477 
  Attributes:
8478 
   - userId
8479 
   - replyTo
8480 
   - communicationType
8481 
   - orderId
8482 
   - airwaybillNo
8483 
   - productName
8484 
   - subject
8485 
   - message
8486 
  """
8487 
 
8488 
  thrift_spec = (
8489 
    None, # 0
8490 
    (1, TType.I64, 'userId', None, None, ), # 1
8491 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
8492 
    (3, TType.I64, 'communicationType', None, None, ), # 3
8493 
    (4, TType.I64, 'orderId', None, None, ), # 4
8494 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
8495 
    (6, TType.STRING, 'productName', None, None, ), # 6
8496 
    (7, TType.STRING, 'subject', None, None, ), # 7
8497 
    (8, TType.STRING, 'message', None, None, ), # 8
8498 
  )
8499 
 
8500 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
8501 
    self.userId = userId
8502 
    self.replyTo = replyTo
8503 
    self.communicationType = communicationType
8504 
    self.orderId = orderId
8505 
    self.airwaybillNo = airwaybillNo
8506 
    self.productName = productName
8507 
    self.subject = subject
8508 
    self.message = message
8509 
 
8510 
  def read(self, iprot):
8511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8513 
      return
8514 
    iprot.readStructBegin()
8515 
    while True:
8516 
      (fname, ftype, fid) = iprot.readFieldBegin()
8517 
      if ftype == TType.STOP:
8518 
        break
8519 
      if fid == 1:
8520 
        if ftype == TType.I64:
8521 
          self.userId = iprot.readI64();
8522 
        else:
8523 
          iprot.skip(ftype)
8524 
      elif fid == 2:
8525 
        if ftype == TType.STRING:
8526 
          self.replyTo = iprot.readString();
8527 
        else:
8528 
          iprot.skip(ftype)
8529 
      elif fid == 3:
8530 
        if ftype == TType.I64:
8531 
          self.communicationType = iprot.readI64();
8532 
        else:
8533 
          iprot.skip(ftype)
8534 
      elif fid == 4:
8535 
        if ftype == TType.I64:
8536 
          self.orderId = iprot.readI64();
8537 
        else:
8538 
          iprot.skip(ftype)
8539 
      elif fid == 5:
8540 
        if ftype == TType.STRING:
8541 
          self.airwaybillNo = iprot.readString();
8542 
        else:
8543 
          iprot.skip(ftype)
8544 
      elif fid == 6:
8545 
        if ftype == TType.STRING:
8546 
          self.productName = iprot.readString();
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      elif fid == 7:
8550 
        if ftype == TType.STRING:
8551 
          self.subject = iprot.readString();
8552 
        else:
8553 
          iprot.skip(ftype)
8554 
      elif fid == 8:
8555 
        if ftype == TType.STRING:
8556 
          self.message = iprot.readString();
8557 
        else:
8558 
          iprot.skip(ftype)
8559 
      else:
8560 
        iprot.skip(ftype)
8561 
      iprot.readFieldEnd()
8562 
    iprot.readStructEnd()
8563 
 
8564 
  def write(self, oprot):
8565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8567 
      return
8568 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 8569 
    if self.userId is not None:
1274 varun.gupt 8570 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8571 
      oprot.writeI64(self.userId)
8572 
      oprot.writeFieldEnd()
3431 rajveer 8573 
    if self.replyTo is not None:
1274 varun.gupt 8574 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8575 
      oprot.writeString(self.replyTo)
8576 
      oprot.writeFieldEnd()
3431 rajveer 8577 
    if self.communicationType is not None:
1274 varun.gupt 8578 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8579 
      oprot.writeI64(self.communicationType)
8580 
      oprot.writeFieldEnd()
3431 rajveer 8581 
    if self.orderId is not None:
1274 varun.gupt 8582 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8583 
      oprot.writeI64(self.orderId)
8584 
      oprot.writeFieldEnd()
3431 rajveer 8585 
    if self.airwaybillNo is not None:
1274 varun.gupt 8586 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8587 
      oprot.writeString(self.airwaybillNo)
8588 
      oprot.writeFieldEnd()
3431 rajveer 8589 
    if self.productName is not None:
1274 varun.gupt 8590 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8591 
      oprot.writeString(self.productName)
8592 
      oprot.writeFieldEnd()
3431 rajveer 8593 
    if self.subject is not None:
1274 varun.gupt 8594 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8595 
      oprot.writeString(self.subject)
8596 
      oprot.writeFieldEnd()
3431 rajveer 8597 
    if self.message is not None:
1274 varun.gupt 8598 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8599 
      oprot.writeString(self.message)
8600 
      oprot.writeFieldEnd()
8601 
    oprot.writeFieldStop()
8602 
    oprot.writeStructEnd()
8603 
 
3431 rajveer 8604 
  def validate(self):
8605 
    return
8606 
 
8607 
 
1274 varun.gupt 8608 
  def __repr__(self):
8609 
    L = ['%s=%r' % (key, value)
8610 
      for key, value in self.__dict__.iteritems()]
8611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8612 
 
8613 
  def __eq__(self, other):
8614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8615 
 
8616 
  def __ne__(self, other):
8617 
    return not (self == other)
8618 
 
8619 
class saveUserCommunication_result:
8620 
  """
8621 
  Attributes:
8622 
   - success
8623 
   - ucx
8624 
  """
8625 
 
8626 
  thrift_spec = (
8627 
    (0, TType.BOOL, 'success', None, None, ), # 0
8628 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8629 
  )
8630 
 
8631 
  def __init__(self, success=None, ucx=None,):
8632 
    self.success = success
8633 
    self.ucx = ucx
8634 
 
8635 
  def read(self, iprot):
8636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8638 
      return
8639 
    iprot.readStructBegin()
8640 
    while True:
8641 
      (fname, ftype, fid) = iprot.readFieldBegin()
8642 
      if ftype == TType.STOP:
8643 
        break
8644 
      if fid == 0:
8645 
        if ftype == TType.BOOL:
8646 
          self.success = iprot.readBool();
8647 
        else:
8648 
          iprot.skip(ftype)
8649 
      elif fid == 1:
8650 
        if ftype == TType.STRUCT:
8651 
          self.ucx = UserCommunicationException()
8652 
          self.ucx.read(iprot)
8653 
        else:
8654 
          iprot.skip(ftype)
8655 
      else:
8656 
        iprot.skip(ftype)
8657 
      iprot.readFieldEnd()
8658 
    iprot.readStructEnd()
8659 
 
8660 
  def write(self, oprot):
8661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8663 
      return
8664 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8665 
    if self.success is not None:
1274 varun.gupt 8666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8667 
      oprot.writeBool(self.success)
8668 
      oprot.writeFieldEnd()
3431 rajveer 8669 
    if self.ucx is not None:
1274 varun.gupt 8670 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8671 
      self.ucx.write(oprot)
8672 
      oprot.writeFieldEnd()
8673 
    oprot.writeFieldStop()
8674 
    oprot.writeStructEnd()
8675 
 
3431 rajveer 8676 
  def validate(self):
8677 
    return
8678 
 
8679 
 
1274 varun.gupt 8680 
  def __repr__(self):
8681 
    L = ['%s=%r' % (key, value)
8682 
      for key, value in self.__dict__.iteritems()]
8683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8684 
 
8685 
  def __eq__(self, other):
8686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8687 
 
8688 
  def __ne__(self, other):
8689 
    return not (self == other)
8690 
 
1590 varun.gupt 8691 
class getUserCommunicationById_args:
8692 
  """
8693 
  Attributes:
8694 
   - id
8695 
  """
8696 
 
8697 
  thrift_spec = (
8698 
    None, # 0
8699 
    (1, TType.I64, 'id', None, None, ), # 1
8700 
  )
8701 
 
8702 
  def __init__(self, id=None,):
8703 
    self.id = id
8704 
 
8705 
  def read(self, iprot):
8706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8708 
      return
8709 
    iprot.readStructBegin()
8710 
    while True:
8711 
      (fname, ftype, fid) = iprot.readFieldBegin()
8712 
      if ftype == TType.STOP:
8713 
        break
8714 
      if fid == 1:
8715 
        if ftype == TType.I64:
8716 
          self.id = iprot.readI64();
8717 
        else:
8718 
          iprot.skip(ftype)
8719 
      else:
8720 
        iprot.skip(ftype)
8721 
      iprot.readFieldEnd()
8722 
    iprot.readStructEnd()
8723 
 
8724 
  def write(self, oprot):
8725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8727 
      return
8728 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8729 
    if self.id is not None:
1590 varun.gupt 8730 
      oprot.writeFieldBegin('id', TType.I64, 1)
8731 
      oprot.writeI64(self.id)
8732 
      oprot.writeFieldEnd()
8733 
    oprot.writeFieldStop()
8734 
    oprot.writeStructEnd()
8735 
 
3431 rajveer 8736 
  def validate(self):
8737 
    return
8738 
 
8739 
 
1590 varun.gupt 8740 
  def __repr__(self):
8741 
    L = ['%s=%r' % (key, value)
8742 
      for key, value in self.__dict__.iteritems()]
8743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8744 
 
8745 
  def __eq__(self, other):
8746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8747 
 
8748 
  def __ne__(self, other):
8749 
    return not (self == other)
8750 
 
8751 
class getUserCommunicationById_result:
8752 
  """
8753 
  Attributes:
8754 
   - success
8755 
   - ucx
8756 
  """
8757 
 
8758 
  thrift_spec = (
8759 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8760 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8761 
  )
8762 
 
8763 
  def __init__(self, success=None, ucx=None,):
8764 
    self.success = success
8765 
    self.ucx = ucx
8766 
 
8767 
  def read(self, iprot):
8768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8770 
      return
8771 
    iprot.readStructBegin()
8772 
    while True:
8773 
      (fname, ftype, fid) = iprot.readFieldBegin()
8774 
      if ftype == TType.STOP:
8775 
        break
8776 
      if fid == 0:
8777 
        if ftype == TType.STRUCT:
8778 
          self.success = UserCommunication()
8779 
          self.success.read(iprot)
8780 
        else:
8781 
          iprot.skip(ftype)
8782 
      elif fid == 1:
8783 
        if ftype == TType.STRUCT:
8784 
          self.ucx = UserCommunicationException()
8785 
          self.ucx.read(iprot)
8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
8797 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8798 
    if self.success is not None:
1590 varun.gupt 8799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8800 
      self.success.write(oprot)
8801 
      oprot.writeFieldEnd()
3431 rajveer 8802 
    if self.ucx is not None:
1590 varun.gupt 8803 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8804 
      self.ucx.write(oprot)
8805 
      oprot.writeFieldEnd()
8806 
    oprot.writeFieldStop()
8807 
    oprot.writeStructEnd()
8808 
 
3431 rajveer 8809 
  def validate(self):
8810 
    return
8811 
 
8812 
 
1590 varun.gupt 8813 
  def __repr__(self):
8814 
    L = ['%s=%r' % (key, value)
8815 
      for key, value in self.__dict__.iteritems()]
8816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8817 
 
8818 
  def __eq__(self, other):
8819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8820 
 
8821 
  def __ne__(self, other):
8822 
    return not (self == other)
8823 
 
8824 
class getUserCommunicationByUser_args:
8825 
  """
8826 
  Attributes:
8827 
   - userId
8828 
  """
8829 
 
8830 
  thrift_spec = (
8831 
    None, # 0
8832 
    (1, TType.I64, 'userId', None, None, ), # 1
8833 
  )
8834 
 
8835 
  def __init__(self, userId=None,):
8836 
    self.userId = userId
8837 
 
8838 
  def read(self, iprot):
8839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8841 
      return
8842 
    iprot.readStructBegin()
8843 
    while True:
8844 
      (fname, ftype, fid) = iprot.readFieldBegin()
8845 
      if ftype == TType.STOP:
8846 
        break
8847 
      if fid == 1:
8848 
        if ftype == TType.I64:
8849 
          self.userId = iprot.readI64();
8850 
        else:
8851 
          iprot.skip(ftype)
8852 
      else:
8853 
        iprot.skip(ftype)
8854 
      iprot.readFieldEnd()
8855 
    iprot.readStructEnd()
8856 
 
8857 
  def write(self, oprot):
8858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8860 
      return
8861 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8862 
    if self.userId is not None:
1590 varun.gupt 8863 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8864 
      oprot.writeI64(self.userId)
8865 
      oprot.writeFieldEnd()
8866 
    oprot.writeFieldStop()
8867 
    oprot.writeStructEnd()
8868 
 
3431 rajveer 8869 
  def validate(self):
8870 
    return
8871 
 
8872 
 
1590 varun.gupt 8873 
  def __repr__(self):
8874 
    L = ['%s=%r' % (key, value)
8875 
      for key, value in self.__dict__.iteritems()]
8876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8877 
 
8878 
  def __eq__(self, other):
8879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8880 
 
8881 
  def __ne__(self, other):
8882 
    return not (self == other)
8883 
 
8884 
class getUserCommunicationByUser_result:
8885 
  """
8886 
  Attributes:
8887 
   - success
8888 
   - ucx
8889 
  """
8890 
 
8891 
  thrift_spec = (
8892 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8893 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8894 
  )
8895 
 
8896 
  def __init__(self, success=None, ucx=None,):
8897 
    self.success = success
8898 
    self.ucx = ucx
8899 
 
8900 
  def read(self, iprot):
8901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8903 
      return
8904 
    iprot.readStructBegin()
8905 
    while True:
8906 
      (fname, ftype, fid) = iprot.readFieldBegin()
8907 
      if ftype == TType.STOP:
8908 
        break
8909 
      if fid == 0:
8910 
        if ftype == TType.LIST:
8911 
          self.success = []
11592 amit.gupta 8912 
          (_etype107, _size104) = iprot.readListBegin()
8913 
          for _i108 in xrange(_size104):
8914 
            _elem109 = UserCommunication()
8915 
            _elem109.read(iprot)
8916 
            self.success.append(_elem109)
1590 varun.gupt 8917 
          iprot.readListEnd()
8918 
        else:
8919 
          iprot.skip(ftype)
8920 
      elif fid == 1:
8921 
        if ftype == TType.STRUCT:
8922 
          self.ucx = UserCommunicationException()
8923 
          self.ucx.read(iprot)
8924 
        else:
8925 
          iprot.skip(ftype)
8926 
      else:
8927 
        iprot.skip(ftype)
8928 
      iprot.readFieldEnd()
8929 
    iprot.readStructEnd()
8930 
 
8931 
  def write(self, oprot):
8932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8934 
      return
8935 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8936 
    if self.success is not None:
1590 varun.gupt 8937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8939 
      for iter110 in self.success:
8940 
        iter110.write(oprot)
1590 varun.gupt 8941 
      oprot.writeListEnd()
8942 
      oprot.writeFieldEnd()
3431 rajveer 8943 
    if self.ucx is not None:
1590 varun.gupt 8944 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8945 
      self.ucx.write(oprot)
8946 
      oprot.writeFieldEnd()
8947 
    oprot.writeFieldStop()
8948 
    oprot.writeStructEnd()
8949 
 
3431 rajveer 8950 
  def validate(self):
8951 
    return
8952 
 
8953 
 
1590 varun.gupt 8954 
  def __repr__(self):
8955 
    L = ['%s=%r' % (key, value)
8956 
      for key, value in self.__dict__.iteritems()]
8957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8958 
 
8959 
  def __eq__(self, other):
8960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8961 
 
8962 
  def __ne__(self, other):
8963 
    return not (self == other)
8964 
 
8965 
class getAllUserCommunications_args:
8966 
 
8967 
  thrift_spec = (
8968 
  )
8969 
 
8970 
  def read(self, iprot):
8971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8973 
      return
8974 
    iprot.readStructBegin()
8975 
    while True:
8976 
      (fname, ftype, fid) = iprot.readFieldBegin()
8977 
      if ftype == TType.STOP:
8978 
        break
8979 
      else:
8980 
        iprot.skip(ftype)
8981 
      iprot.readFieldEnd()
8982 
    iprot.readStructEnd()
8983 
 
8984 
  def write(self, oprot):
8985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8987 
      return
8988 
    oprot.writeStructBegin('getAllUserCommunications_args')
8989 
    oprot.writeFieldStop()
8990 
    oprot.writeStructEnd()
8991 
 
3431 rajveer 8992 
  def validate(self):
8993 
    return
8994 
 
8995 
 
1590 varun.gupt 8996 
  def __repr__(self):
8997 
    L = ['%s=%r' % (key, value)
8998 
      for key, value in self.__dict__.iteritems()]
8999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9000 
 
9001 
  def __eq__(self, other):
9002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9003 
 
9004 
  def __ne__(self, other):
9005 
    return not (self == other)
9006 
 
9007 
class getAllUserCommunications_result:
9008 
  """
9009 
  Attributes:
9010 
   - success
9011 
   - ucx
9012 
  """
9013 
 
9014 
  thrift_spec = (
9015 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
9016 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
9017 
  )
9018 
 
9019 
  def __init__(self, success=None, ucx=None,):
9020 
    self.success = success
9021 
    self.ucx = ucx
9022 
 
9023 
  def read(self, iprot):
9024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9026 
      return
9027 
    iprot.readStructBegin()
9028 
    while True:
9029 
      (fname, ftype, fid) = iprot.readFieldBegin()
9030 
      if ftype == TType.STOP:
9031 
        break
9032 
      if fid == 0:
9033 
        if ftype == TType.LIST:
9034 
          self.success = []
11592 amit.gupta 9035 
          (_etype114, _size111) = iprot.readListBegin()
9036 
          for _i115 in xrange(_size111):
9037 
            _elem116 = UserCommunication()
9038 
            _elem116.read(iprot)
9039 
            self.success.append(_elem116)
1590 varun.gupt 9040 
          iprot.readListEnd()
9041 
        else:
9042 
          iprot.skip(ftype)
9043 
      elif fid == 1:
9044 
        if ftype == TType.STRUCT:
9045 
          self.ucx = UserCommunicationException()
9046 
          self.ucx.read(iprot)
9047 
        else:
9048 
          iprot.skip(ftype)
9049 
      else:
9050 
        iprot.skip(ftype)
9051 
      iprot.readFieldEnd()
9052 
    iprot.readStructEnd()
9053 
 
9054 
  def write(self, oprot):
9055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9057 
      return
9058 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 9059 
    if self.success is not None:
1590 varun.gupt 9060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9062 
      for iter117 in self.success:
9063 
        iter117.write(oprot)
1590 varun.gupt 9064 
      oprot.writeListEnd()
9065 
      oprot.writeFieldEnd()
3431 rajveer 9066 
    if self.ucx is not None:
1590 varun.gupt 9067 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
9068 
      self.ucx.write(oprot)
9069 
      oprot.writeFieldEnd()
9070 
    oprot.writeFieldStop()
9071 
    oprot.writeStructEnd()
9072 
 
3431 rajveer 9073 
  def validate(self):
9074 
    return
9075 
 
9076 
 
1590 varun.gupt 9077 
  def __repr__(self):
9078 
    L = ['%s=%r' % (key, value)
9079 
      for key, value in self.__dict__.iteritems()]
9080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9081 
 
9082 
  def __eq__(self, other):
9083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9084 
 
9085 
  def __ne__(self, other):
9086 
    return not (self == other)
9087 
 
5407 amar.kumar 9088 
class removeUserCommunication_args:
9089 
  """
9090 
  Attributes:
9091 
   - id
9092 
  """
9093 
 
9094 
  thrift_spec = (
9095 
    None, # 0
9096 
    (1, TType.I64, 'id', None, None, ), # 1
9097 
  )
9098 
 
9099 
  def __init__(self, id=None,):
9100 
    self.id = id
9101 
 
9102 
  def read(self, iprot):
9103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9105 
      return
9106 
    iprot.readStructBegin()
9107 
    while True:
9108 
      (fname, ftype, fid) = iprot.readFieldBegin()
9109 
      if ftype == TType.STOP:
9110 
        break
9111 
      if fid == 1:
9112 
        if ftype == TType.I64:
9113 
          self.id = iprot.readI64();
9114 
        else:
9115 
          iprot.skip(ftype)
9116 
      else:
9117 
        iprot.skip(ftype)
9118 
      iprot.readFieldEnd()
9119 
    iprot.readStructEnd()
9120 
 
9121 
  def write(self, oprot):
9122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9124 
      return
9125 
    oprot.writeStructBegin('removeUserCommunication_args')
9126 
    if self.id is not None:
9127 
      oprot.writeFieldBegin('id', TType.I64, 1)
9128 
      oprot.writeI64(self.id)
9129 
      oprot.writeFieldEnd()
9130 
    oprot.writeFieldStop()
9131 
    oprot.writeStructEnd()
9132 
 
9133 
  def validate(self):
9134 
    return
9135 
 
9136 
 
9137 
  def __repr__(self):
9138 
    L = ['%s=%r' % (key, value)
9139 
      for key, value in self.__dict__.iteritems()]
9140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9141 
 
9142 
  def __eq__(self, other):
9143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9144 
 
9145 
  def __ne__(self, other):
9146 
    return not (self == other)
9147 
 
9148 
class removeUserCommunication_result:
9149 
  """
9150 
  Attributes:
9151 
   - ucx
9152 
  """
9153 
 
9154 
  thrift_spec = (
9155 
    None, # 0
9156 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
9157 
  )
9158 
 
9159 
  def __init__(self, ucx=None,):
9160 
    self.ucx = ucx
9161 
 
9162 
  def read(self, iprot):
9163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9165 
      return
9166 
    iprot.readStructBegin()
9167 
    while True:
9168 
      (fname, ftype, fid) = iprot.readFieldBegin()
9169 
      if ftype == TType.STOP:
9170 
        break
9171 
      if fid == 1:
9172 
        if ftype == TType.STRUCT:
9173 
          self.ucx = UserCommunicationException()
9174 
          self.ucx.read(iprot)
9175 
        else:
9176 
          iprot.skip(ftype)
9177 
      else:
9178 
        iprot.skip(ftype)
9179 
      iprot.readFieldEnd()
9180 
    iprot.readStructEnd()
9181 
 
9182 
  def write(self, oprot):
9183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9185 
      return
9186 
    oprot.writeStructBegin('removeUserCommunication_result')
9187 
    if self.ucx is not None:
9188 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
9189 
      self.ucx.write(oprot)
9190 
      oprot.writeFieldEnd()
9191 
    oprot.writeFieldStop()
9192 
    oprot.writeStructEnd()
9193 
 
9194 
  def validate(self):
9195 
    return
9196 
 
9197 
 
9198 
  def __repr__(self):
9199 
    L = ['%s=%r' % (key, value)
9200 
      for key, value in self.__dict__.iteritems()]
9201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9202 
 
9203 
  def __eq__(self, other):
9204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9205 
 
9206 
  def __ne__(self, other):
9207 
    return not (self == other)
9208 
 
1845 vikas 9209 
class createMasterAffiliate_args:
9210 
  """
9211 
  Attributes:
9212 
   - name
1859 vikas 9213 
   - addedOn
1845 vikas 9214 
  """
9215 
 
9216 
  thrift_spec = (
9217 
    None, # 0
9218 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 9219 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 9220 
  )
9221 
 
1859 vikas 9222 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 9223 
    self.name = name
1859 vikas 9224 
    self.addedOn = addedOn
1845 vikas 9225 
 
9226 
  def read(self, iprot):
9227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9229 
      return
9230 
    iprot.readStructBegin()
9231 
    while True:
9232 
      (fname, ftype, fid) = iprot.readFieldBegin()
9233 
      if ftype == TType.STOP:
9234 
        break
9235 
      if fid == 1:
9236 
        if ftype == TType.STRING:
9237 
          self.name = iprot.readString();
9238 
        else:
9239 
          iprot.skip(ftype)
1859 vikas 9240 
      elif fid == 2:
9241 
        if ftype == TType.I64:
9242 
          self.addedOn = iprot.readI64();
9243 
        else:
9244 
          iprot.skip(ftype)
1845 vikas 9245 
      else:
9246 
        iprot.skip(ftype)
9247 
      iprot.readFieldEnd()
9248 
    iprot.readStructEnd()
9249 
 
9250 
  def write(self, oprot):
9251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9253 
      return
9254 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 9255 
    if self.name is not None:
1845 vikas 9256 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9257 
      oprot.writeString(self.name)
9258 
      oprot.writeFieldEnd()
3431 rajveer 9259 
    if self.addedOn is not None:
1859 vikas 9260 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
9261 
      oprot.writeI64(self.addedOn)
9262 
      oprot.writeFieldEnd()
1845 vikas 9263 
    oprot.writeFieldStop()
9264 
    oprot.writeStructEnd()
9265 
 
3431 rajveer 9266 
  def validate(self):
9267 
    return
9268 
 
9269 
 
1845 vikas 9270 
  def __repr__(self):
9271 
    L = ['%s=%r' % (key, value)
9272 
      for key, value in self.__dict__.iteritems()]
9273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9274 
 
9275 
  def __eq__(self, other):
9276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9277 
 
9278 
  def __ne__(self, other):
9279 
    return not (self == other)
9280 
 
9281 
class createMasterAffiliate_result:
9282 
  """
9283 
  Attributes:
9284 
   - success
9285 
   - utx
9286 
  """
9287 
 
9288 
  thrift_spec = (
9289 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9290 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9291 
  )
9292 
 
9293 
  def __init__(self, success=None, utx=None,):
9294 
    self.success = success
9295 
    self.utx = utx
9296 
 
9297 
  def read(self, iprot):
9298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9300 
      return
9301 
    iprot.readStructBegin()
9302 
    while True:
9303 
      (fname, ftype, fid) = iprot.readFieldBegin()
9304 
      if ftype == TType.STOP:
9305 
        break
9306 
      if fid == 0:
9307 
        if ftype == TType.STRUCT:
9308 
          self.success = MasterAffiliate()
9309 
          self.success.read(iprot)
9310 
        else:
9311 
          iprot.skip(ftype)
9312 
      elif fid == 1:
9313 
        if ftype == TType.STRUCT:
1996 vikas 9314 
          self.utx = UserAffiliateException()
1845 vikas 9315 
          self.utx.read(iprot)
9316 
        else:
9317 
          iprot.skip(ftype)
9318 
      else:
9319 
        iprot.skip(ftype)
9320 
      iprot.readFieldEnd()
9321 
    iprot.readStructEnd()
9322 
 
9323 
  def write(self, oprot):
9324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9326 
      return
9327 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 9328 
    if self.success is not None:
1845 vikas 9329 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9330 
      self.success.write(oprot)
9331 
      oprot.writeFieldEnd()
3431 rajveer 9332 
    if self.utx is not None:
1845 vikas 9333 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9334 
      self.utx.write(oprot)
9335 
      oprot.writeFieldEnd()
9336 
    oprot.writeFieldStop()
9337 
    oprot.writeStructEnd()
9338 
 
3431 rajveer 9339 
  def validate(self):
9340 
    return
9341 
 
9342 
 
1845 vikas 9343 
  def __repr__(self):
9344 
    L = ['%s=%r' % (key, value)
9345 
      for key, value in self.__dict__.iteritems()]
9346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9347 
 
9348 
  def __eq__(self, other):
9349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9350 
 
9351 
  def __ne__(self, other):
9352 
    return not (self == other)
9353 
 
1899 vikas 9354 
class getAllMasterAffiliates_args:
9355 
 
9356 
  thrift_spec = (
9357 
  )
9358 
 
9359 
  def read(self, iprot):
9360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9362 
      return
9363 
    iprot.readStructBegin()
9364 
    while True:
9365 
      (fname, ftype, fid) = iprot.readFieldBegin()
9366 
      if ftype == TType.STOP:
9367 
        break
9368 
      else:
9369 
        iprot.skip(ftype)
9370 
      iprot.readFieldEnd()
9371 
    iprot.readStructEnd()
9372 
 
9373 
  def write(self, oprot):
9374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9376 
      return
9377 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
9378 
    oprot.writeFieldStop()
9379 
    oprot.writeStructEnd()
9380 
 
3431 rajveer 9381 
  def validate(self):
9382 
    return
9383 
 
9384 
 
1899 vikas 9385 
  def __repr__(self):
9386 
    L = ['%s=%r' % (key, value)
9387 
      for key, value in self.__dict__.iteritems()]
9388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9389 
 
9390 
  def __eq__(self, other):
9391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9392 
 
9393 
  def __ne__(self, other):
9394 
    return not (self == other)
9395 
 
9396 
class getAllMasterAffiliates_result:
9397 
  """
9398 
  Attributes:
9399 
   - success
9400 
   - utx
9401 
  """
9402 
 
9403 
  thrift_spec = (
9404 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 9405 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 9406 
  )
9407 
 
9408 
  def __init__(self, success=None, utx=None,):
9409 
    self.success = success
9410 
    self.utx = utx
9411 
 
9412 
  def read(self, iprot):
9413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9415 
      return
9416 
    iprot.readStructBegin()
9417 
    while True:
9418 
      (fname, ftype, fid) = iprot.readFieldBegin()
9419 
      if ftype == TType.STOP:
9420 
        break
9421 
      if fid == 0:
9422 
        if ftype == TType.LIST:
9423 
          self.success = []
11592 amit.gupta 9424 
          (_etype121, _size118) = iprot.readListBegin()
9425 
          for _i122 in xrange(_size118):
9426 
            _elem123 = MasterAffiliate()
9427 
            _elem123.read(iprot)
9428 
            self.success.append(_elem123)
1899 vikas 9429 
          iprot.readListEnd()
9430 
        else:
9431 
          iprot.skip(ftype)
9432 
      elif fid == 1:
9433 
        if ftype == TType.STRUCT:
1996 vikas 9434 
          self.utx = UserAffiliateException()
1899 vikas 9435 
          self.utx.read(iprot)
9436 
        else:
9437 
          iprot.skip(ftype)
9438 
      else:
9439 
        iprot.skip(ftype)
9440 
      iprot.readFieldEnd()
9441 
    iprot.readStructEnd()
9442 
 
9443 
  def write(self, oprot):
9444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9446 
      return
9447 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 9448 
    if self.success is not None:
1899 vikas 9449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9451 
      for iter124 in self.success:
9452 
        iter124.write(oprot)
1899 vikas 9453 
      oprot.writeListEnd()
9454 
      oprot.writeFieldEnd()
3431 rajveer 9455 
    if self.utx is not None:
1899 vikas 9456 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9457 
      self.utx.write(oprot)
9458 
      oprot.writeFieldEnd()
9459 
    oprot.writeFieldStop()
9460 
    oprot.writeStructEnd()
9461 
 
3431 rajveer 9462 
  def validate(self):
9463 
    return
9464 
 
9465 
 
1899 vikas 9466 
  def __repr__(self):
9467 
    L = ['%s=%r' % (key, value)
9468 
      for key, value in self.__dict__.iteritems()]
9469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9470 
 
9471 
  def __eq__(self, other):
9472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9473 
 
9474 
  def __ne__(self, other):
9475 
    return not (self == other)
9476 
 
1845 vikas 9477 
class getMasterAffiliateById_args:
9478 
  """
9479 
  Attributes:
9480 
   - id
9481 
  """
9482 
 
9483 
  thrift_spec = (
9484 
    None, # 0
9485 
    (1, TType.I64, 'id', None, None, ), # 1
9486 
  )
9487 
 
9488 
  def __init__(self, id=None,):
9489 
    self.id = id
9490 
 
9491 
  def read(self, iprot):
9492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9494 
      return
9495 
    iprot.readStructBegin()
9496 
    while True:
9497 
      (fname, ftype, fid) = iprot.readFieldBegin()
9498 
      if ftype == TType.STOP:
9499 
        break
9500 
      if fid == 1:
9501 
        if ftype == TType.I64:
9502 
          self.id = iprot.readI64();
9503 
        else:
9504 
          iprot.skip(ftype)
9505 
      else:
9506 
        iprot.skip(ftype)
9507 
      iprot.readFieldEnd()
9508 
    iprot.readStructEnd()
9509 
 
9510 
  def write(self, oprot):
9511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9513 
      return
9514 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 9515 
    if self.id is not None:
1845 vikas 9516 
      oprot.writeFieldBegin('id', TType.I64, 1)
9517 
      oprot.writeI64(self.id)
9518 
      oprot.writeFieldEnd()
9519 
    oprot.writeFieldStop()
9520 
    oprot.writeStructEnd()
9521 
 
3431 rajveer 9522 
  def validate(self):
9523 
    return
9524 
 
9525 
 
1845 vikas 9526 
  def __repr__(self):
9527 
    L = ['%s=%r' % (key, value)
9528 
      for key, value in self.__dict__.iteritems()]
9529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9530 
 
9531 
  def __eq__(self, other):
9532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9533 
 
9534 
  def __ne__(self, other):
9535 
    return not (self == other)
9536 
 
9537 
class getMasterAffiliateById_result:
9538 
  """
9539 
  Attributes:
9540 
   - success
9541 
   - utx
9542 
  """
9543 
 
9544 
  thrift_spec = (
9545 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9546 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9547 
  )
9548 
 
9549 
  def __init__(self, success=None, utx=None,):
9550 
    self.success = success
9551 
    self.utx = utx
9552 
 
9553 
  def read(self, iprot):
9554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9556 
      return
9557 
    iprot.readStructBegin()
9558 
    while True:
9559 
      (fname, ftype, fid) = iprot.readFieldBegin()
9560 
      if ftype == TType.STOP:
9561 
        break
9562 
      if fid == 0:
9563 
        if ftype == TType.STRUCT:
9564 
          self.success = MasterAffiliate()
9565 
          self.success.read(iprot)
9566 
        else:
9567 
          iprot.skip(ftype)
9568 
      elif fid == 1:
9569 
        if ftype == TType.STRUCT:
1996 vikas 9570 
          self.utx = UserAffiliateException()
1845 vikas 9571 
          self.utx.read(iprot)
9572 
        else:
9573 
          iprot.skip(ftype)
9574 
      else:
9575 
        iprot.skip(ftype)
9576 
      iprot.readFieldEnd()
9577 
    iprot.readStructEnd()
9578 
 
9579 
  def write(self, oprot):
9580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9582 
      return
9583 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9584 
    if self.success is not None:
1845 vikas 9585 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9586 
      self.success.write(oprot)
9587 
      oprot.writeFieldEnd()
3431 rajveer 9588 
    if self.utx is not None:
1845 vikas 9589 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9590 
      self.utx.write(oprot)
9591 
      oprot.writeFieldEnd()
9592 
    oprot.writeFieldStop()
9593 
    oprot.writeStructEnd()
9594 
 
3431 rajveer 9595 
  def validate(self):
9596 
    return
9597 
 
9598 
 
1845 vikas 9599 
  def __repr__(self):
9600 
    L = ['%s=%r' % (key, value)
9601 
      for key, value in self.__dict__.iteritems()]
9602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9603 
 
9604 
  def __eq__(self, other):
9605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9606 
 
9607 
  def __ne__(self, other):
9608 
    return not (self == other)
9609 
 
9610 
class getMasterAffiliateByName_args:
9611 
  """
9612 
  Attributes:
9613 
   - name
9614 
  """
9615 
 
9616 
  thrift_spec = (
9617 
    None, # 0
9618 
    (1, TType.STRING, 'name', None, None, ), # 1
9619 
  )
9620 
 
9621 
  def __init__(self, name=None,):
9622 
    self.name = name
9623 
 
9624 
  def read(self, iprot):
9625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9627 
      return
9628 
    iprot.readStructBegin()
9629 
    while True:
9630 
      (fname, ftype, fid) = iprot.readFieldBegin()
9631 
      if ftype == TType.STOP:
9632 
        break
9633 
      if fid == 1:
9634 
        if ftype == TType.STRING:
9635 
          self.name = iprot.readString();
9636 
        else:
9637 
          iprot.skip(ftype)
9638 
      else:
9639 
        iprot.skip(ftype)
9640 
      iprot.readFieldEnd()
9641 
    iprot.readStructEnd()
9642 
 
9643 
  def write(self, oprot):
9644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9646 
      return
9647 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9648 
    if self.name is not None:
1845 vikas 9649 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9650 
      oprot.writeString(self.name)
9651 
      oprot.writeFieldEnd()
9652 
    oprot.writeFieldStop()
9653 
    oprot.writeStructEnd()
9654 
 
3431 rajveer 9655 
  def validate(self):
9656 
    return
9657 
 
9658 
 
1845 vikas 9659 
  def __repr__(self):
9660 
    L = ['%s=%r' % (key, value)
9661 
      for key, value in self.__dict__.iteritems()]
9662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9663 
 
9664 
  def __eq__(self, other):
9665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9666 
 
9667 
  def __ne__(self, other):
9668 
    return not (self == other)
9669 
 
9670 
class getMasterAffiliateByName_result:
9671 
  """
9672 
  Attributes:
9673 
   - success
9674 
   - utx
9675 
  """
9676 
 
9677 
  thrift_spec = (
9678 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9679 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9680 
  )
9681 
 
9682 
  def __init__(self, success=None, utx=None,):
9683 
    self.success = success
9684 
    self.utx = utx
9685 
 
9686 
  def read(self, iprot):
9687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9689 
      return
9690 
    iprot.readStructBegin()
9691 
    while True:
9692 
      (fname, ftype, fid) = iprot.readFieldBegin()
9693 
      if ftype == TType.STOP:
9694 
        break
9695 
      if fid == 0:
9696 
        if ftype == TType.STRUCT:
9697 
          self.success = MasterAffiliate()
9698 
          self.success.read(iprot)
9699 
        else:
9700 
          iprot.skip(ftype)
9701 
      elif fid == 1:
9702 
        if ftype == TType.STRUCT:
1996 vikas 9703 
          self.utx = UserAffiliateException()
1845 vikas 9704 
          self.utx.read(iprot)
9705 
        else:
9706 
          iprot.skip(ftype)
9707 
      else:
9708 
        iprot.skip(ftype)
9709 
      iprot.readFieldEnd()
9710 
    iprot.readStructEnd()
9711 
 
9712 
  def write(self, oprot):
9713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9715 
      return
9716 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9717 
    if self.success is not None:
1845 vikas 9718 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9719 
      self.success.write(oprot)
9720 
      oprot.writeFieldEnd()
3431 rajveer 9721 
    if self.utx is not None:
1845 vikas 9722 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9723 
      self.utx.write(oprot)
9724 
      oprot.writeFieldEnd()
9725 
    oprot.writeFieldStop()
9726 
    oprot.writeStructEnd()
9727 
 
3431 rajveer 9728 
  def validate(self):
9729 
    return
9730 
 
9731 
 
1845 vikas 9732 
  def __repr__(self):
9733 
    L = ['%s=%r' % (key, value)
9734 
      for key, value in self.__dict__.iteritems()]
9735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9736 
 
9737 
  def __eq__(self, other):
9738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9739 
 
9740 
  def __ne__(self, other):
9741 
    return not (self == other)
9742 
 
9743 
class createAffiliate_args:
9744 
  """
9745 
  Attributes:
9746 
   - name
9747 
   - url
9748 
   - masterAffiliateId
1859 vikas 9749 
   - addedOn
1845 vikas 9750 
  """
9751 
 
9752 
  thrift_spec = (
9753 
    None, # 0
9754 
    (1, TType.STRING, 'name', None, None, ), # 1
9755 
    (2, TType.STRING, 'url', None, None, ), # 2
9756 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9757 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9758 
  )
9759 
 
1859 vikas 9760 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9761 
    self.name = name
9762 
    self.url = url
9763 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9764 
    self.addedOn = addedOn
1845 vikas 9765 
 
9766 
  def read(self, iprot):
9767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9769 
      return
9770 
    iprot.readStructBegin()
9771 
    while True:
9772 
      (fname, ftype, fid) = iprot.readFieldBegin()
9773 
      if ftype == TType.STOP:
9774 
        break
9775 
      if fid == 1:
9776 
        if ftype == TType.STRING:
9777 
          self.name = iprot.readString();
9778 
        else:
9779 
          iprot.skip(ftype)
9780 
      elif fid == 2:
9781 
        if ftype == TType.STRING:
9782 
          self.url = iprot.readString();
9783 
        else:
9784 
          iprot.skip(ftype)
9785 
      elif fid == 3:
9786 
        if ftype == TType.I64:
9787 
          self.masterAffiliateId = iprot.readI64();
9788 
        else:
9789 
          iprot.skip(ftype)
1859 vikas 9790 
      elif fid == 4:
9791 
        if ftype == TType.I64:
9792 
          self.addedOn = iprot.readI64();
9793 
        else:
9794 
          iprot.skip(ftype)
1845 vikas 9795 
      else:
9796 
        iprot.skip(ftype)
9797 
      iprot.readFieldEnd()
9798 
    iprot.readStructEnd()
9799 
 
9800 
  def write(self, oprot):
9801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9803 
      return
9804 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9805 
    if self.name is not None:
1845 vikas 9806 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9807 
      oprot.writeString(self.name)
9808 
      oprot.writeFieldEnd()
3431 rajveer 9809 
    if self.url is not None:
1845 vikas 9810 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9811 
      oprot.writeString(self.url)
9812 
      oprot.writeFieldEnd()
3431 rajveer 9813 
    if self.masterAffiliateId is not None:
1845 vikas 9814 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9815 
      oprot.writeI64(self.masterAffiliateId)
9816 
      oprot.writeFieldEnd()
3431 rajveer 9817 
    if self.addedOn is not None:
1859 vikas 9818 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9819 
      oprot.writeI64(self.addedOn)
9820 
      oprot.writeFieldEnd()
1845 vikas 9821 
    oprot.writeFieldStop()
9822 
    oprot.writeStructEnd()
9823 
 
3431 rajveer 9824 
  def validate(self):
9825 
    return
9826 
 
9827 
 
1845 vikas 9828 
  def __repr__(self):
9829 
    L = ['%s=%r' % (key, value)
9830 
      for key, value in self.__dict__.iteritems()]
9831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9832 
 
9833 
  def __eq__(self, other):
9834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9835 
 
9836 
  def __ne__(self, other):
9837 
    return not (self == other)
9838 
 
9839 
class createAffiliate_result:
9840 
  """
9841 
  Attributes:
9842 
   - success
9843 
   - utx
9844 
  """
9845 
 
9846 
  thrift_spec = (
9847 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9848 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9849 
  )
9850 
 
9851 
  def __init__(self, success=None, utx=None,):
9852 
    self.success = success
9853 
    self.utx = utx
9854 
 
9855 
  def read(self, iprot):
9856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9858 
      return
9859 
    iprot.readStructBegin()
9860 
    while True:
9861 
      (fname, ftype, fid) = iprot.readFieldBegin()
9862 
      if ftype == TType.STOP:
9863 
        break
9864 
      if fid == 0:
9865 
        if ftype == TType.STRUCT:
9866 
          self.success = Affiliate()
9867 
          self.success.read(iprot)
9868 
        else:
9869 
          iprot.skip(ftype)
9870 
      elif fid == 1:
9871 
        if ftype == TType.STRUCT:
1996 vikas 9872 
          self.utx = UserAffiliateException()
1845 vikas 9873 
          self.utx.read(iprot)
9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      else:
9877 
        iprot.skip(ftype)
9878 
      iprot.readFieldEnd()
9879 
    iprot.readStructEnd()
9880 
 
9881 
  def write(self, oprot):
9882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9884 
      return
9885 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9886 
    if self.success is not None:
1845 vikas 9887 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9888 
      self.success.write(oprot)
9889 
      oprot.writeFieldEnd()
3431 rajveer 9890 
    if self.utx is not None:
1845 vikas 9891 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9892 
      self.utx.write(oprot)
9893 
      oprot.writeFieldEnd()
9894 
    oprot.writeFieldStop()
9895 
    oprot.writeStructEnd()
9896 
 
3431 rajveer 9897 
  def validate(self):
9898 
    return
9899 
 
9900 
 
1845 vikas 9901 
  def __repr__(self):
9902 
    L = ['%s=%r' % (key, value)
9903 
      for key, value in self.__dict__.iteritems()]
9904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9905 
 
9906 
  def __eq__(self, other):
9907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9908 
 
9909 
  def __ne__(self, other):
9910 
    return not (self == other)
9911 
 
9912 
class getAffiliateById_args:
9913 
  """
9914 
  Attributes:
9915 
   - id
9916 
  """
9917 
 
9918 
  thrift_spec = (
9919 
    None, # 0
9920 
    (1, TType.I64, 'id', None, None, ), # 1
9921 
  )
9922 
 
9923 
  def __init__(self, id=None,):
9924 
    self.id = id
9925 
 
9926 
  def read(self, iprot):
9927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9929 
      return
9930 
    iprot.readStructBegin()
9931 
    while True:
9932 
      (fname, ftype, fid) = iprot.readFieldBegin()
9933 
      if ftype == TType.STOP:
9934 
        break
9935 
      if fid == 1:
9936 
        if ftype == TType.I64:
9937 
          self.id = iprot.readI64();
9938 
        else:
9939 
          iprot.skip(ftype)
9940 
      else:
9941 
        iprot.skip(ftype)
9942 
      iprot.readFieldEnd()
9943 
    iprot.readStructEnd()
9944 
 
9945 
  def write(self, oprot):
9946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9948 
      return
9949 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9950 
    if self.id is not None:
1845 vikas 9951 
      oprot.writeFieldBegin('id', TType.I64, 1)
9952 
      oprot.writeI64(self.id)
9953 
      oprot.writeFieldEnd()
9954 
    oprot.writeFieldStop()
9955 
    oprot.writeStructEnd()
9956 
 
3431 rajveer 9957 
  def validate(self):
9958 
    return
9959 
 
9960 
 
1845 vikas 9961 
  def __repr__(self):
9962 
    L = ['%s=%r' % (key, value)
9963 
      for key, value in self.__dict__.iteritems()]
9964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9965 
 
9966 
  def __eq__(self, other):
9967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9968 
 
9969 
  def __ne__(self, other):
9970 
    return not (self == other)
9971 
 
9972 
class getAffiliateById_result:
9973 
  """
9974 
  Attributes:
9975 
   - success
9976 
   - utx
9977 
  """
9978 
 
9979 
  thrift_spec = (
9980 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9981 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9982 
  )
9983 
 
9984 
  def __init__(self, success=None, utx=None,):
9985 
    self.success = success
9986 
    self.utx = utx
9987 
 
9988 
  def read(self, iprot):
9989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9991 
      return
9992 
    iprot.readStructBegin()
9993 
    while True:
9994 
      (fname, ftype, fid) = iprot.readFieldBegin()
9995 
      if ftype == TType.STOP:
9996 
        break
9997 
      if fid == 0:
9998 
        if ftype == TType.STRUCT:
9999 
          self.success = Affiliate()
10000 
          self.success.read(iprot)
10001 
        else:
10002 
          iprot.skip(ftype)
10003 
      elif fid == 1:
10004 
        if ftype == TType.STRUCT:
1996 vikas 10005 
          self.utx = UserAffiliateException()
1845 vikas 10006 
          self.utx.read(iprot)
10007 
        else:
10008 
          iprot.skip(ftype)
10009 
      else:
10010 
        iprot.skip(ftype)
10011 
      iprot.readFieldEnd()
10012 
    iprot.readStructEnd()
10013 
 
10014 
  def write(self, oprot):
10015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10017 
      return
10018 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 10019 
    if self.success is not None:
1845 vikas 10020 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10021 
      self.success.write(oprot)
10022 
      oprot.writeFieldEnd()
3431 rajveer 10023 
    if self.utx is not None:
1845 vikas 10024 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10025 
      self.utx.write(oprot)
10026 
      oprot.writeFieldEnd()
10027 
    oprot.writeFieldStop()
10028 
    oprot.writeStructEnd()
10029 
 
3431 rajveer 10030 
  def validate(self):
10031 
    return
10032 
 
10033 
 
1845 vikas 10034 
  def __repr__(self):
10035 
    L = ['%s=%r' % (key, value)
10036 
      for key, value in self.__dict__.iteritems()]
10037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10038 
 
10039 
  def __eq__(self, other):
10040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10041 
 
10042 
  def __ne__(self, other):
10043 
    return not (self == other)
10044 
 
10045 
class getAffiliateByName_args:
10046 
  """
10047 
  Attributes:
10048 
   - name
10049 
  """
10050 
 
10051 
  thrift_spec = (
10052 
    None, # 0
10053 
    (1, TType.STRING, 'name', None, None, ), # 1
10054 
  )
10055 
 
10056 
  def __init__(self, name=None,):
10057 
    self.name = name
10058 
 
10059 
  def read(self, iprot):
10060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10062 
      return
10063 
    iprot.readStructBegin()
10064 
    while True:
10065 
      (fname, ftype, fid) = iprot.readFieldBegin()
10066 
      if ftype == TType.STOP:
10067 
        break
10068 
      if fid == 1:
10069 
        if ftype == TType.STRING:
10070 
          self.name = iprot.readString();
10071 
        else:
10072 
          iprot.skip(ftype)
10073 
      else:
10074 
        iprot.skip(ftype)
10075 
      iprot.readFieldEnd()
10076 
    iprot.readStructEnd()
10077 
 
10078 
  def write(self, oprot):
10079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10081 
      return
10082 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 10083 
    if self.name is not None:
1845 vikas 10084 
      oprot.writeFieldBegin('name', TType.STRING, 1)
10085 
      oprot.writeString(self.name)
10086 
      oprot.writeFieldEnd()
10087 
    oprot.writeFieldStop()
10088 
    oprot.writeStructEnd()
10089 
 
3431 rajveer 10090 
  def validate(self):
10091 
    return
10092 
 
10093 
 
1845 vikas 10094 
  def __repr__(self):
10095 
    L = ['%s=%r' % (key, value)
10096 
      for key, value in self.__dict__.iteritems()]
10097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10098 
 
10099 
  def __eq__(self, other):
10100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10101 
 
10102 
  def __ne__(self, other):
10103 
    return not (self == other)
10104 
 
10105 
class getAffiliateByName_result:
10106 
  """
10107 
  Attributes:
10108 
   - success
10109 
   - utx
10110 
  """
10111 
 
10112 
  thrift_spec = (
10113 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 10114 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10115 
  )
10116 
 
10117 
  def __init__(self, success=None, utx=None,):
10118 
    self.success = success
10119 
    self.utx = utx
10120 
 
10121 
  def read(self, iprot):
10122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10124 
      return
10125 
    iprot.readStructBegin()
10126 
    while True:
10127 
      (fname, ftype, fid) = iprot.readFieldBegin()
10128 
      if ftype == TType.STOP:
10129 
        break
10130 
      if fid == 0:
10131 
        if ftype == TType.STRUCT:
10132 
          self.success = Affiliate()
10133 
          self.success.read(iprot)
10134 
        else:
10135 
          iprot.skip(ftype)
10136 
      elif fid == 1:
10137 
        if ftype == TType.STRUCT:
1996 vikas 10138 
          self.utx = UserAffiliateException()
1845 vikas 10139 
          self.utx.read(iprot)
10140 
        else:
10141 
          iprot.skip(ftype)
10142 
      else:
10143 
        iprot.skip(ftype)
10144 
      iprot.readFieldEnd()
10145 
    iprot.readStructEnd()
10146 
 
10147 
  def write(self, oprot):
10148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10150 
      return
10151 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 10152 
    if self.success is not None:
1845 vikas 10153 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10154 
      self.success.write(oprot)
10155 
      oprot.writeFieldEnd()
3431 rajveer 10156 
    if self.utx is not None:
1845 vikas 10157 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10158 
      self.utx.write(oprot)
10159 
      oprot.writeFieldEnd()
10160 
    oprot.writeFieldStop()
10161 
    oprot.writeStructEnd()
10162 
 
3431 rajveer 10163 
  def validate(self):
10164 
    return
10165 
 
10166 
 
1845 vikas 10167 
  def __repr__(self):
10168 
    L = ['%s=%r' % (key, value)
10169 
      for key, value in self.__dict__.iteritems()]
10170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10171 
 
10172 
  def __eq__(self, other):
10173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10174 
 
10175 
  def __ne__(self, other):
10176 
    return not (self == other)
10177 
 
1996 vikas 10178 
class getTrackerById_args:
1845 vikas 10179 
  """
10180 
  Attributes:
10181 
   - id
10182 
  """
10183 
 
10184 
  thrift_spec = (
10185 
    None, # 0
10186 
    (1, TType.I64, 'id', None, None, ), # 1
10187 
  )
10188 
 
10189 
  def __init__(self, id=None,):
10190 
    self.id = id
10191 
 
10192 
  def read(self, iprot):
10193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10195 
      return
10196 
    iprot.readStructBegin()
10197 
    while True:
10198 
      (fname, ftype, fid) = iprot.readFieldBegin()
10199 
      if ftype == TType.STOP:
10200 
        break
10201 
      if fid == 1:
10202 
        if ftype == TType.I64:
10203 
          self.id = iprot.readI64();
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      else:
10207 
        iprot.skip(ftype)
10208 
      iprot.readFieldEnd()
10209 
    iprot.readStructEnd()
10210 
 
10211 
  def write(self, oprot):
10212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10214 
      return
1996 vikas 10215 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 10216 
    if self.id is not None:
1845 vikas 10217 
      oprot.writeFieldBegin('id', TType.I64, 1)
10218 
      oprot.writeI64(self.id)
10219 
      oprot.writeFieldEnd()
10220 
    oprot.writeFieldStop()
10221 
    oprot.writeStructEnd()
10222 
 
3431 rajveer 10223 
  def validate(self):
10224 
    return
10225 
 
10226 
 
1845 vikas 10227 
  def __repr__(self):
10228 
    L = ['%s=%r' % (key, value)
10229 
      for key, value in self.__dict__.iteritems()]
10230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10231 
 
10232 
  def __eq__(self, other):
10233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10234 
 
10235 
  def __ne__(self, other):
10236 
    return not (self == other)
10237 
 
10238 
class getTrackerById_result:
10239 
  """
10240 
  Attributes:
10241 
   - success
10242 
   - utx
10243 
  """
10244 
 
10245 
  thrift_spec = (
10246 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 10247 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10248 
  )
10249 
 
10250 
  def __init__(self, success=None, utx=None,):
10251 
    self.success = success
10252 
    self.utx = utx
10253 
 
10254 
  def read(self, iprot):
10255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10257 
      return
10258 
    iprot.readStructBegin()
10259 
    while True:
10260 
      (fname, ftype, fid) = iprot.readFieldBegin()
10261 
      if ftype == TType.STOP:
10262 
        break
10263 
      if fid == 0:
10264 
        if ftype == TType.STRUCT:
10265 
          self.success = Tracker()
10266 
          self.success.read(iprot)
10267 
        else:
10268 
          iprot.skip(ftype)
10269 
      elif fid == 1:
10270 
        if ftype == TType.STRUCT:
1996 vikas 10271 
          self.utx = UserAffiliateException()
1845 vikas 10272 
          self.utx.read(iprot)
10273 
        else:
10274 
          iprot.skip(ftype)
10275 
      else:
10276 
        iprot.skip(ftype)
10277 
      iprot.readFieldEnd()
10278 
    iprot.readStructEnd()
10279 
 
10280 
  def write(self, oprot):
10281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10283 
      return
10284 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 10285 
    if self.success is not None:
1845 vikas 10286 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10287 
      self.success.write(oprot)
10288 
      oprot.writeFieldEnd()
3431 rajveer 10289 
    if self.utx is not None:
1845 vikas 10290 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10291 
      self.utx.write(oprot)
10292 
      oprot.writeFieldEnd()
10293 
    oprot.writeFieldStop()
10294 
    oprot.writeStructEnd()
10295 
 
3431 rajveer 10296 
  def validate(self):
10297 
    return
10298 
 
10299 
 
1845 vikas 10300 
  def __repr__(self):
10301 
    L = ['%s=%r' % (key, value)
10302 
      for key, value in self.__dict__.iteritems()]
10303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10304 
 
10305 
  def __eq__(self, other):
10306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10307 
 
10308 
  def __ne__(self, other):
10309 
    return not (self == other)
10310 
 
1996 vikas 10311 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 10312 
  """
10313 
  Attributes:
1996 vikas 10314 
   - id
1845 vikas 10315 
  """
10316 
 
10317 
  thrift_spec = (
10318 
    None, # 0
1996 vikas 10319 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 10320 
  )
10321 
 
1996 vikas 10322 
  def __init__(self, id=None,):
10323 
    self.id = id
1845 vikas 10324 
 
10325 
  def read(self, iprot):
10326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10328 
      return
10329 
    iprot.readStructBegin()
10330 
    while True:
10331 
      (fname, ftype, fid) = iprot.readFieldBegin()
10332 
      if ftype == TType.STOP:
10333 
        break
10334 
      if fid == 1:
10335 
        if ftype == TType.I64:
1996 vikas 10336 
          self.id = iprot.readI64();
1845 vikas 10337 
        else:
10338 
          iprot.skip(ftype)
10339 
      else:
10340 
        iprot.skip(ftype)
10341 
      iprot.readFieldEnd()
10342 
    iprot.readStructEnd()
10343 
 
10344 
  def write(self, oprot):
10345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10347 
      return
1996 vikas 10348 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 10349 
    if self.id is not None:
1996 vikas 10350 
      oprot.writeFieldBegin('id', TType.I64, 1)
10351 
      oprot.writeI64(self.id)
1845 vikas 10352 
      oprot.writeFieldEnd()
10353 
    oprot.writeFieldStop()
10354 
    oprot.writeStructEnd()
10355 
 
3431 rajveer 10356 
  def validate(self):
10357 
    return
10358 
 
10359 
 
1845 vikas 10360 
  def __repr__(self):
10361 
    L = ['%s=%r' % (key, value)
10362 
      for key, value in self.__dict__.iteritems()]
10363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10364 
 
10365 
  def __eq__(self, other):
10366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10367 
 
10368 
  def __ne__(self, other):
10369 
    return not (self == other)
10370 
 
1996 vikas 10371 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 10372 
  """
10373 
  Attributes:
10374 
   - success
10375 
   - utx
10376 
  """
10377 
 
10378 
  thrift_spec = (
1996 vikas 10379 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
10380 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10381 
  )
10382 
 
10383 
  def __init__(self, success=None, utx=None,):
10384 
    self.success = success
10385 
    self.utx = utx
10386 
 
10387 
  def read(self, iprot):
10388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10390 
      return
10391 
    iprot.readStructBegin()
10392 
    while True:
10393 
      (fname, ftype, fid) = iprot.readFieldBegin()
10394 
      if ftype == TType.STOP:
10395 
        break
10396 
      if fid == 0:
10397 
        if ftype == TType.LIST:
10398 
          self.success = []
11592 amit.gupta 10399 
          (_etype128, _size125) = iprot.readListBegin()
10400 
          for _i129 in xrange(_size125):
10401 
            _elem130 = Affiliate()
10402 
            _elem130.read(iprot)
10403 
            self.success.append(_elem130)
1845 vikas 10404 
          iprot.readListEnd()
10405 
        else:
10406 
          iprot.skip(ftype)
10407 
      elif fid == 1:
10408 
        if ftype == TType.STRUCT:
1996 vikas 10409 
          self.utx = UserAffiliateException()
1845 vikas 10410 
          self.utx.read(iprot)
10411 
        else:
10412 
          iprot.skip(ftype)
10413 
      else:
10414 
        iprot.skip(ftype)
10415 
      iprot.readFieldEnd()
10416 
    iprot.readStructEnd()
10417 
 
10418 
  def write(self, oprot):
10419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10421 
      return
1996 vikas 10422 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 10423 
    if self.success is not None:
1845 vikas 10424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10426 
      for iter131 in self.success:
10427 
        iter131.write(oprot)
1845 vikas 10428 
      oprot.writeListEnd()
10429 
      oprot.writeFieldEnd()
3431 rajveer 10430 
    if self.utx is not None:
1845 vikas 10431 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10432 
      self.utx.write(oprot)
10433 
      oprot.writeFieldEnd()
10434 
    oprot.writeFieldStop()
10435 
    oprot.writeStructEnd()
10436 
 
3431 rajveer 10437 
  def validate(self):
10438 
    return
10439 
 
10440 
 
1845 vikas 10441 
  def __repr__(self):
10442 
    L = ['%s=%r' % (key, value)
10443 
      for key, value in self.__dict__.iteritems()]
10444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10445 
 
10446 
  def __eq__(self, other):
10447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10448 
 
10449 
  def __ne__(self, other):
10450 
    return not (self == other)
10451 
 
10452 
class addTrackLog_args:
10453 
  """
10454 
  Attributes:
1996 vikas 10455 
   - affiliateId
1845 vikas 10456 
   - userId
10457 
   - event
10458 
   - url
10459 
   - data
1859 vikas 10460 
   - addedOn
1845 vikas 10461 
  """
10462 
 
10463 
  thrift_spec = (
10464 
    None, # 0
1996 vikas 10465 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 10466 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 10467 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 10468 
    (4, TType.STRING, 'url', None, None, ), # 4
10469 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 10470 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 10471 
  )
10472 
 
1996 vikas 10473 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
10474 
    self.affiliateId = affiliateId
1845 vikas 10475 
    self.userId = userId
10476 
    self.event = event
10477 
    self.url = url
10478 
    self.data = data
1859 vikas 10479 
    self.addedOn = addedOn
1845 vikas 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 == 1:
10491 
        if ftype == TType.I64:
1996 vikas 10492 
          self.affiliateId = iprot.readI64();
1845 vikas 10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      elif fid == 2:
10496 
        if ftype == TType.I64:
10497 
          self.userId = iprot.readI64();
10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      elif fid == 3:
3378 vikas 10501 
        if ftype == TType.I32:
10502 
          self.event = iprot.readI32();
1845 vikas 10503 
        else:
10504 
          iprot.skip(ftype)
10505 
      elif fid == 4:
10506 
        if ftype == TType.STRING:
10507 
          self.url = iprot.readString();
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      elif fid == 5:
10511 
        if ftype == TType.STRING:
10512 
          self.data = iprot.readString();
10513 
        else:
10514 
          iprot.skip(ftype)
1859 vikas 10515 
      elif fid == 6:
10516 
        if ftype == TType.I64:
10517 
          self.addedOn = iprot.readI64();
10518 
        else:
10519 
          iprot.skip(ftype)
1845 vikas 10520 
      else:
10521 
        iprot.skip(ftype)
10522 
      iprot.readFieldEnd()
10523 
    iprot.readStructEnd()
10524 
 
10525 
  def write(self, oprot):
10526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10528 
      return
10529 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10530 
    if self.affiliateId is not None:
1996 vikas 10531 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10532 
      oprot.writeI64(self.affiliateId)
1845 vikas 10533 
      oprot.writeFieldEnd()
3431 rajveer 10534 
    if self.userId is not None:
1845 vikas 10535 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10536 
      oprot.writeI64(self.userId)
10537 
      oprot.writeFieldEnd()
3431 rajveer 10538 
    if self.event is not None:
3378 vikas 10539 
      oprot.writeFieldBegin('event', TType.I32, 3)
10540 
      oprot.writeI32(self.event)
1845 vikas 10541 
      oprot.writeFieldEnd()
3431 rajveer 10542 
    if self.url is not None:
1845 vikas 10543 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10544 
      oprot.writeString(self.url)
10545 
      oprot.writeFieldEnd()
3431 rajveer 10546 
    if self.data is not None:
1845 vikas 10547 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10548 
      oprot.writeString(self.data)
10549 
      oprot.writeFieldEnd()
3431 rajveer 10550 
    if self.addedOn is not None:
1859 vikas 10551 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10552 
      oprot.writeI64(self.addedOn)
10553 
      oprot.writeFieldEnd()
1845 vikas 10554 
    oprot.writeFieldStop()
10555 
    oprot.writeStructEnd()
10556 
 
3431 rajveer 10557 
  def validate(self):
10558 
    return
10559 
 
10560 
 
1845 vikas 10561 
  def __repr__(self):
10562 
    L = ['%s=%r' % (key, value)
10563 
      for key, value in self.__dict__.iteritems()]
10564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10565 
 
10566 
  def __eq__(self, other):
10567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10568 
 
10569 
  def __ne__(self, other):
10570 
    return not (self == other)
10571 
 
10572 
class addTrackLog_result:
10573 
  """
10574 
  Attributes:
10575 
   - success
10576 
   - utx
10577 
  """
10578 
 
10579 
  thrift_spec = (
10580 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10581 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10582 
  )
10583 
 
10584 
  def __init__(self, success=None, utx=None,):
10585 
    self.success = success
10586 
    self.utx = utx
10587 
 
10588 
  def read(self, iprot):
10589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10591 
      return
10592 
    iprot.readStructBegin()
10593 
    while True:
10594 
      (fname, ftype, fid) = iprot.readFieldBegin()
10595 
      if ftype == TType.STOP:
10596 
        break
10597 
      if fid == 0:
10598 
        if ftype == TType.I64:
10599 
          self.success = iprot.readI64();
10600 
        else:
10601 
          iprot.skip(ftype)
10602 
      elif fid == 1:
10603 
        if ftype == TType.STRUCT:
1996 vikas 10604 
          self.utx = UserAffiliateException()
1845 vikas 10605 
          self.utx.read(iprot)
10606 
        else:
10607 
          iprot.skip(ftype)
10608 
      else:
10609 
        iprot.skip(ftype)
10610 
      iprot.readFieldEnd()
10611 
    iprot.readStructEnd()
10612 
 
10613 
  def write(self, oprot):
10614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10616 
      return
10617 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10618 
    if self.success is not None:
1845 vikas 10619 
      oprot.writeFieldBegin('success', TType.I64, 0)
10620 
      oprot.writeI64(self.success)
10621 
      oprot.writeFieldEnd()
3431 rajveer 10622 
    if self.utx is not None:
1845 vikas 10623 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10624 
      self.utx.write(oprot)
10625 
      oprot.writeFieldEnd()
10626 
    oprot.writeFieldStop()
10627 
    oprot.writeStructEnd()
10628 
 
3431 rajveer 10629 
  def validate(self):
10630 
    return
10631 
 
10632 
 
1845 vikas 10633 
  def __repr__(self):
10634 
    L = ['%s=%r' % (key, value)
10635 
      for key, value in self.__dict__.iteritems()]
10636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10637 
 
10638 
  def __eq__(self, other):
10639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10640 
 
10641 
  def __ne__(self, other):
10642 
    return not (self == other)
10643 
 
10644 
class getTrackLogById_args:
10645 
  """
10646 
  Attributes:
10647 
   - id
10648 
  """
10649 
 
10650 
  thrift_spec = (
10651 
    None, # 0
10652 
    (1, TType.I64, 'id', None, None, ), # 1
10653 
  )
10654 
 
10655 
  def __init__(self, id=None,):
10656 
    self.id = id
10657 
 
10658 
  def read(self, iprot):
10659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10661 
      return
10662 
    iprot.readStructBegin()
10663 
    while True:
10664 
      (fname, ftype, fid) = iprot.readFieldBegin()
10665 
      if ftype == TType.STOP:
10666 
        break
10667 
      if fid == 1:
10668 
        if ftype == TType.I64:
10669 
          self.id = iprot.readI64();
10670 
        else:
10671 
          iprot.skip(ftype)
10672 
      else:
10673 
        iprot.skip(ftype)
10674 
      iprot.readFieldEnd()
10675 
    iprot.readStructEnd()
10676 
 
10677 
  def write(self, oprot):
10678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10680 
      return
10681 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10682 
    if self.id is not None:
1845 vikas 10683 
      oprot.writeFieldBegin('id', TType.I64, 1)
10684 
      oprot.writeI64(self.id)
10685 
      oprot.writeFieldEnd()
10686 
    oprot.writeFieldStop()
10687 
    oprot.writeStructEnd()
10688 
 
3431 rajveer 10689 
  def validate(self):
10690 
    return
10691 
 
10692 
 
1845 vikas 10693 
  def __repr__(self):
10694 
    L = ['%s=%r' % (key, value)
10695 
      for key, value in self.__dict__.iteritems()]
10696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10697 
 
10698 
  def __eq__(self, other):
10699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10700 
 
10701 
  def __ne__(self, other):
10702 
    return not (self == other)
10703 
 
10704 
class getTrackLogById_result:
10705 
  """
10706 
  Attributes:
10707 
   - success
10708 
   - utx
10709 
  """
10710 
 
10711 
  thrift_spec = (
10712 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10713 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10714 
  )
10715 
 
10716 
  def __init__(self, success=None, utx=None,):
10717 
    self.success = success
10718 
    self.utx = utx
10719 
 
10720 
  def read(self, iprot):
10721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10723 
      return
10724 
    iprot.readStructBegin()
10725 
    while True:
10726 
      (fname, ftype, fid) = iprot.readFieldBegin()
10727 
      if ftype == TType.STOP:
10728 
        break
10729 
      if fid == 0:
10730 
        if ftype == TType.STRUCT:
10731 
          self.success = TrackLog()
10732 
          self.success.read(iprot)
10733 
        else:
10734 
          iprot.skip(ftype)
10735 
      elif fid == 1:
10736 
        if ftype == TType.STRUCT:
1996 vikas 10737 
          self.utx = UserAffiliateException()
1845 vikas 10738 
          self.utx.read(iprot)
10739 
        else:
10740 
          iprot.skip(ftype)
10741 
      else:
10742 
        iprot.skip(ftype)
10743 
      iprot.readFieldEnd()
10744 
    iprot.readStructEnd()
10745 
 
10746 
  def write(self, oprot):
10747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10749 
      return
10750 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10751 
    if self.success is not None:
1845 vikas 10752 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10753 
      self.success.write(oprot)
10754 
      oprot.writeFieldEnd()
3431 rajveer 10755 
    if self.utx is not None:
1845 vikas 10756 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10757 
      self.utx.write(oprot)
10758 
      oprot.writeFieldEnd()
10759 
    oprot.writeFieldStop()
10760 
    oprot.writeStructEnd()
10761 
 
3431 rajveer 10762 
  def validate(self):
10763 
    return
10764 
 
10765 
 
1845 vikas 10766 
  def __repr__(self):
10767 
    L = ['%s=%r' % (key, value)
10768 
      for key, value in self.__dict__.iteritems()]
10769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10770 
 
10771 
  def __eq__(self, other):
10772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10773 
 
10774 
  def __ne__(self, other):
10775 
    return not (self == other)
10776 
 
1996 vikas 10777 
class getTrackLogsByAffiliate_args:
1845 vikas 10778 
  """
10779 
  Attributes:
1996 vikas 10780 
   - affiliateId
3293 vikas 10781 
   - startDate
10782 
   - endDate
1845 vikas 10783 
  """
10784 
 
10785 
  thrift_spec = (
10786 
    None, # 0
1996 vikas 10787 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10788 
    (2, TType.I64, 'startDate', None, None, ), # 2
10789 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10790 
  )
10791 
 
3293 vikas 10792 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10793 
    self.affiliateId = affiliateId
3293 vikas 10794 
    self.startDate = startDate
10795 
    self.endDate = endDate
1845 vikas 10796 
 
10797 
  def read(self, iprot):
10798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10800 
      return
10801 
    iprot.readStructBegin()
10802 
    while True:
10803 
      (fname, ftype, fid) = iprot.readFieldBegin()
10804 
      if ftype == TType.STOP:
10805 
        break
10806 
      if fid == 1:
10807 
        if ftype == TType.I64:
1996 vikas 10808 
          self.affiliateId = iprot.readI64();
1845 vikas 10809 
        else:
10810 
          iprot.skip(ftype)
3293 vikas 10811 
      elif fid == 2:
10812 
        if ftype == TType.I64:
10813 
          self.startDate = iprot.readI64();
10814 
        else:
10815 
          iprot.skip(ftype)
10816 
      elif fid == 3:
10817 
        if ftype == TType.I64:
10818 
          self.endDate = iprot.readI64();
10819 
        else:
10820 
          iprot.skip(ftype)
1845 vikas 10821 
      else:
10822 
        iprot.skip(ftype)
10823 
      iprot.readFieldEnd()
10824 
    iprot.readStructEnd()
10825 
 
10826 
  def write(self, oprot):
10827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10829 
      return
1996 vikas 10830 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10831 
    if self.affiliateId is not None:
1996 vikas 10832 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10833 
      oprot.writeI64(self.affiliateId)
1845 vikas 10834 
      oprot.writeFieldEnd()
3431 rajveer 10835 
    if self.startDate is not None:
3293 vikas 10836 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10837 
      oprot.writeI64(self.startDate)
10838 
      oprot.writeFieldEnd()
3431 rajveer 10839 
    if self.endDate is not None:
3293 vikas 10840 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10841 
      oprot.writeI64(self.endDate)
10842 
      oprot.writeFieldEnd()
1845 vikas 10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
3431 rajveer 10846 
  def validate(self):
10847 
    return
10848 
 
10849 
 
1845 vikas 10850 
  def __repr__(self):
10851 
    L = ['%s=%r' % (key, value)
10852 
      for key, value in self.__dict__.iteritems()]
10853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10854 
 
10855 
  def __eq__(self, other):
10856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10857 
 
10858 
  def __ne__(self, other):
10859 
    return not (self == other)
10860 
 
1996 vikas 10861 
class getTrackLogsByAffiliate_result:
1845 vikas 10862 
  """
10863 
  Attributes:
10864 
   - success
10865 
   - utx
10866 
  """
10867 
 
10868 
  thrift_spec = (
10869 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10870 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10871 
  )
10872 
 
10873 
  def __init__(self, success=None, utx=None,):
10874 
    self.success = success
10875 
    self.utx = utx
10876 
 
10877 
  def read(self, iprot):
10878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10880 
      return
10881 
    iprot.readStructBegin()
10882 
    while True:
10883 
      (fname, ftype, fid) = iprot.readFieldBegin()
10884 
      if ftype == TType.STOP:
10885 
        break
10886 
      if fid == 0:
10887 
        if ftype == TType.LIST:
10888 
          self.success = []
11592 amit.gupta 10889 
          (_etype135, _size132) = iprot.readListBegin()
10890 
          for _i136 in xrange(_size132):
10891 
            _elem137 = TrackLog()
10892 
            _elem137.read(iprot)
10893 
            self.success.append(_elem137)
1845 vikas 10894 
          iprot.readListEnd()
10895 
        else:
10896 
          iprot.skip(ftype)
10897 
      elif fid == 1:
10898 
        if ftype == TType.STRUCT:
1996 vikas 10899 
          self.utx = UserAffiliateException()
1845 vikas 10900 
          self.utx.read(iprot)
10901 
        else:
10902 
          iprot.skip(ftype)
10903 
      else:
10904 
        iprot.skip(ftype)
10905 
      iprot.readFieldEnd()
10906 
    iprot.readStructEnd()
10907 
 
10908 
  def write(self, oprot):
10909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10911 
      return
1996 vikas 10912 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10913 
    if self.success is not None:
1845 vikas 10914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10916 
      for iter138 in self.success:
10917 
        iter138.write(oprot)
1845 vikas 10918 
      oprot.writeListEnd()
10919 
      oprot.writeFieldEnd()
3431 rajveer 10920 
    if self.utx is not None:
1845 vikas 10921 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10922 
      self.utx.write(oprot)
10923 
      oprot.writeFieldEnd()
10924 
    oprot.writeFieldStop()
10925 
    oprot.writeStructEnd()
10926 
 
3431 rajveer 10927 
  def validate(self):
10928 
    return
10929 
 
10930 
 
1845 vikas 10931 
  def __repr__(self):
10932 
    L = ['%s=%r' % (key, value)
10933 
      for key, value in self.__dict__.iteritems()]
10934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10935 
 
10936 
  def __eq__(self, other):
10937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10938 
 
10939 
  def __ne__(self, other):
10940 
    return not (self == other)
10941 
 
10942 
class getTrackLogsByUser_args:
10943 
  """
10944 
  Attributes:
10945 
   - userId
10946 
  """
10947 
 
10948 
  thrift_spec = (
10949 
    None, # 0
10950 
    (1, TType.I64, 'userId', None, None, ), # 1
10951 
  )
10952 
 
10953 
  def __init__(self, userId=None,):
10954 
    self.userId = userId
10955 
 
10956 
  def read(self, iprot):
10957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10959 
      return
10960 
    iprot.readStructBegin()
10961 
    while True:
10962 
      (fname, ftype, fid) = iprot.readFieldBegin()
10963 
      if ftype == TType.STOP:
10964 
        break
10965 
      if fid == 1:
10966 
        if ftype == TType.I64:
10967 
          self.userId = iprot.readI64();
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('getTrackLogsByUser_args')
3431 rajveer 10980 
    if self.userId is not None:
1845 vikas 10981 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10982 
      oprot.writeI64(self.userId)
10983 
      oprot.writeFieldEnd()
10984 
    oprot.writeFieldStop()
10985 
    oprot.writeStructEnd()
10986 
 
3431 rajveer 10987 
  def validate(self):
10988 
    return
10989 
 
10990 
 
1845 vikas 10991 
  def __repr__(self):
10992 
    L = ['%s=%r' % (key, value)
10993 
      for key, value in self.__dict__.iteritems()]
10994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10995 
 
10996 
  def __eq__(self, other):
10997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10998 
 
10999 
  def __ne__(self, other):
11000 
    return not (self == other)
11001 
 
11002 
class getTrackLogsByUser_result:
11003 
  """
11004 
  Attributes:
11005 
   - success
11006 
   - utx
11007 
  """
11008 
 
11009 
  thrift_spec = (
11010 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 11011 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 11012 
  )
11013 
 
11014 
  def __init__(self, success=None, utx=None,):
11015 
    self.success = success
11016 
    self.utx = utx
11017 
 
11018 
  def read(self, iprot):
11019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11021 
      return
11022 
    iprot.readStructBegin()
11023 
    while True:
11024 
      (fname, ftype, fid) = iprot.readFieldBegin()
11025 
      if ftype == TType.STOP:
11026 
        break
11027 
      if fid == 0:
11028 
        if ftype == TType.LIST:
11029 
          self.success = []
11592 amit.gupta 11030 
          (_etype142, _size139) = iprot.readListBegin()
11031 
          for _i143 in xrange(_size139):
11032 
            _elem144 = TrackLog()
11033 
            _elem144.read(iprot)
11034 
            self.success.append(_elem144)
1845 vikas 11035 
          iprot.readListEnd()
11036 
        else:
11037 
          iprot.skip(ftype)
11038 
      elif fid == 1:
11039 
        if ftype == TType.STRUCT:
1996 vikas 11040 
          self.utx = UserAffiliateException()
1845 vikas 11041 
          self.utx.read(iprot)
11042 
        else:
11043 
          iprot.skip(ftype)
11044 
      else:
11045 
        iprot.skip(ftype)
11046 
      iprot.readFieldEnd()
11047 
    iprot.readStructEnd()
11048 
 
11049 
  def write(self, oprot):
11050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11052 
      return
11053 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 11054 
    if self.success is not None:
1845 vikas 11055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11056 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11057 
      for iter145 in self.success:
11058 
        iter145.write(oprot)
1845 vikas 11059 
      oprot.writeListEnd()
11060 
      oprot.writeFieldEnd()
3431 rajveer 11061 
    if self.utx is not None:
1845 vikas 11062 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
11063 
      self.utx.write(oprot)
11064 
      oprot.writeFieldEnd()
11065 
    oprot.writeFieldStop()
11066 
    oprot.writeStructEnd()
11067 
 
3431 rajveer 11068 
  def validate(self):
11069 
    return
11070 
 
11071 
 
1845 vikas 11072 
  def __repr__(self):
11073 
    L = ['%s=%r' % (key, value)
11074 
      for key, value in self.__dict__.iteritems()]
11075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11076 
 
11077 
  def __eq__(self, other):
11078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11079 
 
11080 
  def __ne__(self, other):
11081 
    return not (self == other)
11082 
 
11083 
class getTrackLogs_args:
11084 
  """
11085 
  Attributes:
11086 
   - userId
11087 
   - event
11088 
   - url
11089 
  """
11090 
 
11091 
  thrift_spec = (
11092 
    None, # 0
1996 vikas 11093 
    (1, TType.I64, 'userId', None, None, ), # 1
11094 
    (2, TType.STRING, 'event', None, None, ), # 2
11095 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 11096 
  )
11097 
 
1996 vikas 11098 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 11099 
    self.userId = userId
11100 
    self.event = event
11101 
    self.url = url
11102 
 
11103 
  def read(self, iprot):
11104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11106 
      return
11107 
    iprot.readStructBegin()
11108 
    while True:
11109 
      (fname, ftype, fid) = iprot.readFieldBegin()
11110 
      if ftype == TType.STOP:
11111 
        break
11112 
      if fid == 1:
11113 
        if ftype == TType.I64:
1996 vikas 11114 
          self.userId = iprot.readI64();
1845 vikas 11115 
        else:
11116 
          iprot.skip(ftype)
11117 
      elif fid == 2:
11118 
        if ftype == TType.STRING:
11119 
          self.event = iprot.readString();
11120 
        else:
11121 
          iprot.skip(ftype)
1996 vikas 11122 
      elif fid == 3:
1845 vikas 11123 
        if ftype == TType.STRING:
11124 
          self.url = iprot.readString();
11125 
        else:
11126 
          iprot.skip(ftype)
11127 
      else:
11128 
        iprot.skip(ftype)
11129 
      iprot.readFieldEnd()
11130 
    iprot.readStructEnd()
11131 
 
11132 
  def write(self, oprot):
11133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11135 
      return
11136 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 11137 
    if self.userId is not None:
1996 vikas 11138 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 11139 
      oprot.writeI64(self.userId)
11140 
      oprot.writeFieldEnd()
3431 rajveer 11141 
    if self.event is not None:
1996 vikas 11142 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 11143 
      oprot.writeString(self.event)
11144 
      oprot.writeFieldEnd()
3431 rajveer 11145 
    if self.url is not None:
1996 vikas 11146 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 11147 
      oprot.writeString(self.url)
11148 
      oprot.writeFieldEnd()
11149 
    oprot.writeFieldStop()
11150 
    oprot.writeStructEnd()
11151 
 
3431 rajveer 11152 
  def validate(self):
11153 
    return
11154 
 
11155 
 
1845 vikas 11156 
  def __repr__(self):
11157 
    L = ['%s=%r' % (key, value)
11158 
      for key, value in self.__dict__.iteritems()]
11159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11160 
 
11161 
  def __eq__(self, other):
11162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11163 
 
11164 
  def __ne__(self, other):
11165 
    return not (self == other)
11166 
 
11167 
class getTrackLogs_result:
11168 
  """
11169 
  Attributes:
11170 
   - success
11171 
   - utx
11172 
  """
11173 
 
11174 
  thrift_spec = (
11175 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 11176 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 11177 
  )
11178 
 
11179 
  def __init__(self, success=None, utx=None,):
11180 
    self.success = success
11181 
    self.utx = utx
11182 
 
11183 
  def read(self, iprot):
11184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11186 
      return
11187 
    iprot.readStructBegin()
11188 
    while True:
11189 
      (fname, ftype, fid) = iprot.readFieldBegin()
11190 
      if ftype == TType.STOP:
11191 
        break
11192 
      if fid == 0:
11193 
        if ftype == TType.LIST:
11194 
          self.success = []
11592 amit.gupta 11195 
          (_etype149, _size146) = iprot.readListBegin()
11196 
          for _i150 in xrange(_size146):
11197 
            _elem151 = TrackLog()
11198 
            _elem151.read(iprot)
11199 
            self.success.append(_elem151)
1845 vikas 11200 
          iprot.readListEnd()
11201 
        else:
11202 
          iprot.skip(ftype)
11203 
      elif fid == 1:
11204 
        if ftype == TType.STRUCT:
1996 vikas 11205 
          self.utx = UserAffiliateException()
1845 vikas 11206 
          self.utx.read(iprot)
11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      else:
11210 
        iprot.skip(ftype)
11211 
      iprot.readFieldEnd()
11212 
    iprot.readStructEnd()
11213 
 
11214 
  def write(self, oprot):
11215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11217 
      return
11218 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 11219 
    if self.success is not None:
1845 vikas 11220 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11221 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11222 
      for iter152 in self.success:
11223 
        iter152.write(oprot)
1845 vikas 11224 
      oprot.writeListEnd()
11225 
      oprot.writeFieldEnd()
3431 rajveer 11226 
    if self.utx is not None:
1845 vikas 11227 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
11228 
      self.utx.write(oprot)
11229 
      oprot.writeFieldEnd()
11230 
    oprot.writeFieldStop()
11231 
    oprot.writeStructEnd()
11232 
 
3431 rajveer 11233 
  def validate(self):
11234 
    return
11235 
 
11236 
 
1845 vikas 11237 
  def __repr__(self):
11238 
    L = ['%s=%r' % (key, value)
11239 
      for key, value in self.__dict__.iteritems()]
11240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11241 
 
11242 
  def __eq__(self, other):
11243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11244 
 
11245 
  def __ne__(self, other):
11246 
    return not (self == other)
11247 
 
559 chandransh 11248 
class getCurrentCart_args:
94 ashish 11249 
  """
11250 
  Attributes:
559 chandransh 11251 
   - userId
11252 
  """
11253 
 
11254 
  thrift_spec = (
11255 
    None, # 0
11256 
    (1, TType.I64, 'userId', None, None, ), # 1
11257 
  )
11258 
 
11259 
  def __init__(self, userId=None,):
11260 
    self.userId = userId
11261 
 
11262 
  def read(self, iprot):
11263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11265 
      return
11266 
    iprot.readStructBegin()
11267 
    while True:
11268 
      (fname, ftype, fid) = iprot.readFieldBegin()
11269 
      if ftype == TType.STOP:
11270 
        break
11271 
      if fid == 1:
11272 
        if ftype == TType.I64:
11273 
          self.userId = iprot.readI64();
11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      else:
11277 
        iprot.skip(ftype)
11278 
      iprot.readFieldEnd()
11279 
    iprot.readStructEnd()
11280 
 
11281 
  def write(self, oprot):
11282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11284 
      return
11285 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 11286 
    if self.userId is not None:
559 chandransh 11287 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11288 
      oprot.writeI64(self.userId)
11289 
      oprot.writeFieldEnd()
11290 
    oprot.writeFieldStop()
11291 
    oprot.writeStructEnd()
11292 
 
3431 rajveer 11293 
  def validate(self):
11294 
    return
11295 
 
11296 
 
559 chandransh 11297 
  def __repr__(self):
11298 
    L = ['%s=%r' % (key, value)
11299 
      for key, value in self.__dict__.iteritems()]
11300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11301 
 
11302 
  def __eq__(self, other):
11303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11304 
 
11305 
  def __ne__(self, other):
11306 
    return not (self == other)
11307 
 
11308 
class getCurrentCart_result:
11309 
  """
11310 
  Attributes:
94 ashish 11311 
   - success
559 chandransh 11312 
   - scx
94 ashish 11313 
  """
11314 
 
11315 
  thrift_spec = (
559 chandransh 11316 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11317 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11318 
  )
11319 
 
559 chandransh 11320 
  def __init__(self, success=None, scx=None,):
94 ashish 11321 
    self.success = success
559 chandransh 11322 
    self.scx = scx
94 ashish 11323 
 
11324 
  def read(self, iprot):
11325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11327 
      return
11328 
    iprot.readStructBegin()
11329 
    while True:
11330 
      (fname, ftype, fid) = iprot.readFieldBegin()
11331 
      if ftype == TType.STOP:
11332 
        break
11333 
      if fid == 0:
559 chandransh 11334 
        if ftype == TType.STRUCT:
11335 
          self.success = Cart()
11336 
          self.success.read(iprot)
94 ashish 11337 
        else:
11338 
          iprot.skip(ftype)
11339 
      elif fid == 1:
11340 
        if ftype == TType.STRUCT:
559 chandransh 11341 
          self.scx = ShoppingCartException()
11342 
          self.scx.read(iprot)
94 ashish 11343 
        else:
11344 
          iprot.skip(ftype)
11345 
      else:
11346 
        iprot.skip(ftype)
11347 
      iprot.readFieldEnd()
11348 
    iprot.readStructEnd()
11349 
 
11350 
  def write(self, oprot):
11351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11353 
      return
559 chandransh 11354 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 11355 
    if self.success is not None:
559 chandransh 11356 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11357 
      self.success.write(oprot)
94 ashish 11358 
      oprot.writeFieldEnd()
3431 rajveer 11359 
    if self.scx is not None:
559 chandransh 11360 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11361 
      self.scx.write(oprot)
94 ashish 11362 
      oprot.writeFieldEnd()
11363 
    oprot.writeFieldStop()
11364 
    oprot.writeStructEnd()
11365 
 
3431 rajveer 11366 
  def validate(self):
11367 
    return
11368 
 
11369 
 
94 ashish 11370 
  def __repr__(self):
11371 
    L = ['%s=%r' % (key, value)
11372 
      for key, value in self.__dict__.iteritems()]
11373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11374 
 
11375 
  def __eq__(self, other):
11376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11377 
 
11378 
  def __ne__(self, other):
11379 
    return not (self == other)
11380 
 
559 chandransh 11381 
class getCart_args:
504 rajveer 11382 
  """
11383 
  Attributes:
559 chandransh 11384 
   - cartId
504 rajveer 11385 
  """
11386 
 
11387 
  thrift_spec = (
11388 
    None, # 0
559 chandransh 11389 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 11390 
  )
11391 
 
559 chandransh 11392 
  def __init__(self, cartId=None,):
11393 
    self.cartId = cartId
504 rajveer 11394 
 
11395 
  def read(self, iprot):
11396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11398 
      return
11399 
    iprot.readStructBegin()
11400 
    while True:
11401 
      (fname, ftype, fid) = iprot.readFieldBegin()
11402 
      if ftype == TType.STOP:
11403 
        break
11404 
      if fid == 1:
11405 
        if ftype == TType.I64:
559 chandransh 11406 
          self.cartId = iprot.readI64();
504 rajveer 11407 
        else:
11408 
          iprot.skip(ftype)
11409 
      else:
11410 
        iprot.skip(ftype)
11411 
      iprot.readFieldEnd()
11412 
    iprot.readStructEnd()
11413 
 
11414 
  def write(self, oprot):
11415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11417 
      return
559 chandransh 11418 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 11419 
    if self.cartId is not None:
559 chandransh 11420 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11421 
      oprot.writeI64(self.cartId)
504 rajveer 11422 
      oprot.writeFieldEnd()
11423 
    oprot.writeFieldStop()
11424 
    oprot.writeStructEnd()
11425 
 
3431 rajveer 11426 
  def validate(self):
11427 
    return
11428 
 
11429 
 
504 rajveer 11430 
  def __repr__(self):
11431 
    L = ['%s=%r' % (key, value)
11432 
      for key, value in self.__dict__.iteritems()]
11433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11434 
 
11435 
  def __eq__(self, other):
11436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11437 
 
11438 
  def __ne__(self, other):
11439 
    return not (self == other)
11440 
 
559 chandransh 11441 
class getCart_result:
504 rajveer 11442 
  """
11443 
  Attributes:
11444 
   - success
559 chandransh 11445 
   - scx
504 rajveer 11446 
  """
11447 
 
11448 
  thrift_spec = (
559 chandransh 11449 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11450 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 11451 
  )
11452 
 
559 chandransh 11453 
  def __init__(self, success=None, scx=None,):
504 rajveer 11454 
    self.success = success
559 chandransh 11455 
    self.scx = scx
504 rajveer 11456 
 
11457 
  def read(self, iprot):
11458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11460 
      return
11461 
    iprot.readStructBegin()
11462 
    while True:
11463 
      (fname, ftype, fid) = iprot.readFieldBegin()
11464 
      if ftype == TType.STOP:
11465 
        break
11466 
      if fid == 0:
559 chandransh 11467 
        if ftype == TType.STRUCT:
11468 
          self.success = Cart()
11469 
          self.success.read(iprot)
504 rajveer 11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      elif fid == 1:
11473 
        if ftype == TType.STRUCT:
559 chandransh 11474 
          self.scx = ShoppingCartException()
11475 
          self.scx.read(iprot)
504 rajveer 11476 
        else:
11477 
          iprot.skip(ftype)
11478 
      else:
11479 
        iprot.skip(ftype)
11480 
      iprot.readFieldEnd()
11481 
    iprot.readStructEnd()
11482 
 
11483 
  def write(self, oprot):
11484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11486 
      return
559 chandransh 11487 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 11488 
    if self.success is not None:
559 chandransh 11489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11490 
      self.success.write(oprot)
504 rajveer 11491 
      oprot.writeFieldEnd()
3431 rajveer 11492 
    if self.scx is not None:
559 chandransh 11493 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11494 
      self.scx.write(oprot)
504 rajveer 11495 
      oprot.writeFieldEnd()
11496 
    oprot.writeFieldStop()
11497 
    oprot.writeStructEnd()
11498 
 
3431 rajveer 11499 
  def validate(self):
11500 
    return
11501 
 
11502 
 
504 rajveer 11503 
  def __repr__(self):
11504 
    L = ['%s=%r' % (key, value)
11505 
      for key, value in self.__dict__.iteritems()]
11506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11507 
 
11508 
  def __eq__(self, other):
11509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11510 
 
11511 
  def __ne__(self, other):
11512 
    return not (self == other)
11513 
 
559 chandransh 11514 
class getCartsByTime_args:
11515 
  """
11516 
  Attributes:
11517 
   - from_time
11518 
   - to_time
11519 
   - status
11520 
  """
11521 
 
11522 
  thrift_spec = (
11523 
    None, # 0
11524 
    (1, TType.I64, 'from_time', None, None, ), # 1
11525 
    (2, TType.I64, 'to_time', None, None, ), # 2
11526 
    (3, TType.I32, 'status', None, None, ), # 3
11527 
  )
11528 
 
11529 
  def __init__(self, from_time=None, to_time=None, status=None,):
11530 
    self.from_time = from_time
11531 
    self.to_time = to_time
11532 
    self.status = status
11533 
 
11534 
  def read(self, iprot):
11535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11537 
      return
11538 
    iprot.readStructBegin()
11539 
    while True:
11540 
      (fname, ftype, fid) = iprot.readFieldBegin()
11541 
      if ftype == TType.STOP:
11542 
        break
11543 
      if fid == 1:
94 ashish 11544 
        if ftype == TType.I64:
559 chandransh 11545 
          self.from_time = iprot.readI64();
94 ashish 11546 
        else:
11547 
          iprot.skip(ftype)
122 ashish 11548 
      elif fid == 2:
559 chandransh 11549 
        if ftype == TType.I64:
11550 
          self.to_time = iprot.readI64();
122 ashish 11551 
        else:
11552 
          iprot.skip(ftype)
559 chandransh 11553 
      elif fid == 3:
11554 
        if ftype == TType.I32:
11555 
          self.status = iprot.readI32();
11556 
        else:
11557 
          iprot.skip(ftype)
94 ashish 11558 
      else:
11559 
        iprot.skip(ftype)
11560 
      iprot.readFieldEnd()
11561 
    iprot.readStructEnd()
11562 
 
11563 
  def write(self, oprot):
11564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11566 
      return
559 chandransh 11567 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11568 
    if self.from_time is not None:
559 chandransh 11569 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11570 
      oprot.writeI64(self.from_time)
94 ashish 11571 
      oprot.writeFieldEnd()
3431 rajveer 11572 
    if self.to_time is not None:
559 chandransh 11573 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11574 
      oprot.writeI64(self.to_time)
122 ashish 11575 
      oprot.writeFieldEnd()
3431 rajveer 11576 
    if self.status is not None:
559 chandransh 11577 
      oprot.writeFieldBegin('status', TType.I32, 3)
11578 
      oprot.writeI32(self.status)
11579 
      oprot.writeFieldEnd()
94 ashish 11580 
    oprot.writeFieldStop()
11581 
    oprot.writeStructEnd()
11582 
 
3431 rajveer 11583 
  def validate(self):
11584 
    return
11585 
 
11586 
 
94 ashish 11587 
  def __repr__(self):
11588 
    L = ['%s=%r' % (key, value)
11589 
      for key, value in self.__dict__.iteritems()]
11590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11591 
 
11592 
  def __eq__(self, other):
11593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11594 
 
11595 
  def __ne__(self, other):
11596 
    return not (self == other)
11597 
 
559 chandransh 11598 
class getCartsByTime_result:
94 ashish 11599 
  """
11600 
  Attributes:
11601 
   - success
559 chandransh 11602 
   - scx
94 ashish 11603 
  """
11604 
 
11605 
  thrift_spec = (
559 chandransh 11606 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11607 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11608 
  )
11609 
 
559 chandransh 11610 
  def __init__(self, success=None, scx=None,):
94 ashish 11611 
    self.success = success
559 chandransh 11612 
    self.scx = scx
94 ashish 11613 
 
11614 
  def read(self, iprot):
11615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11617 
      return
11618 
    iprot.readStructBegin()
11619 
    while True:
11620 
      (fname, ftype, fid) = iprot.readFieldBegin()
11621 
      if ftype == TType.STOP:
11622 
        break
11623 
      if fid == 0:
559 chandransh 11624 
        if ftype == TType.LIST:
11625 
          self.success = []
11592 amit.gupta 11626 
          (_etype156, _size153) = iprot.readListBegin()
11627 
          for _i157 in xrange(_size153):
11628 
            _elem158 = Cart()
11629 
            _elem158.read(iprot)
11630 
            self.success.append(_elem158)
559 chandransh 11631 
          iprot.readListEnd()
94 ashish 11632 
        else:
11633 
          iprot.skip(ftype)
11634 
      elif fid == 1:
11635 
        if ftype == TType.STRUCT:
559 chandransh 11636 
          self.scx = ShoppingCartException()
11637 
          self.scx.read(iprot)
94 ashish 11638 
        else:
11639 
          iprot.skip(ftype)
11640 
      else:
11641 
        iprot.skip(ftype)
11642 
      iprot.readFieldEnd()
11643 
    iprot.readStructEnd()
11644 
 
11645 
  def write(self, oprot):
11646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11648 
      return
559 chandransh 11649 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11650 
    if self.success is not None:
559 chandransh 11651 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11652 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11653 
      for iter159 in self.success:
11654 
        iter159.write(oprot)
559 chandransh 11655 
      oprot.writeListEnd()
94 ashish 11656 
      oprot.writeFieldEnd()
3431 rajveer 11657 
    if self.scx is not None:
559 chandransh 11658 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11659 
      self.scx.write(oprot)
94 ashish 11660 
      oprot.writeFieldEnd()
11661 
    oprot.writeFieldStop()
11662 
    oprot.writeStructEnd()
11663 
 
3431 rajveer 11664 
  def validate(self):
11665 
    return
11666 
 
11667 
 
94 ashish 11668 
  def __repr__(self):
11669 
    L = ['%s=%r' % (key, value)
11670 
      for key, value in self.__dict__.iteritems()]
11671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11672 
 
11673 
  def __eq__(self, other):
11674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11675 
 
11676 
  def __ne__(self, other):
11677 
    return not (self == other)
11678 
 
559 chandransh 11679 
class addItemToCart_args:
11680 
  """
11681 
  Attributes:
11682 
   - cartId
11683 
   - itemId
11684 
   - quantity
3557 rajveer 11685 
   - sourceId
559 chandransh 11686 
  """
11687 
 
11688 
  thrift_spec = (
11689 
    None, # 0
11690 
    (1, TType.I64, 'cartId', None, None, ), # 1
11691 
    (2, TType.I64, 'itemId', None, None, ), # 2
11692 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11693 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11694 
  )
11695 
 
3557 rajveer 11696 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11697 
    self.cartId = cartId
11698 
    self.itemId = itemId
11699 
    self.quantity = quantity
3557 rajveer 11700 
    self.sourceId = sourceId
559 chandransh 11701 
 
11702 
  def read(self, iprot):
11703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11705 
      return
11706 
    iprot.readStructBegin()
11707 
    while True:
11708 
      (fname, ftype, fid) = iprot.readFieldBegin()
11709 
      if ftype == TType.STOP:
11710 
        break
11711 
      if fid == 1:
11712 
        if ftype == TType.I64:
11713 
          self.cartId = iprot.readI64();
11714 
        else:
11715 
          iprot.skip(ftype)
11716 
      elif fid == 2:
11717 
        if ftype == TType.I64:
11718 
          self.itemId = iprot.readI64();
11719 
        else:
11720 
          iprot.skip(ftype)
11721 
      elif fid == 3:
11722 
        if ftype == TType.I64:
11723 
          self.quantity = iprot.readI64();
11724 
        else:
11725 
          iprot.skip(ftype)
3557 rajveer 11726 
      elif fid == 4:
11727 
        if ftype == TType.I64:
11728 
          self.sourceId = iprot.readI64();
11729 
        else:
11730 
          iprot.skip(ftype)
559 chandransh 11731 
      else:
11732 
        iprot.skip(ftype)
11733 
      iprot.readFieldEnd()
11734 
    iprot.readStructEnd()
11735 
 
11736 
  def write(self, oprot):
11737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11739 
      return
11740 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11741 
    if self.cartId is not None:
559 chandransh 11742 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11743 
      oprot.writeI64(self.cartId)
11744 
      oprot.writeFieldEnd()
3431 rajveer 11745 
    if self.itemId is not None:
559 chandransh 11746 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11747 
      oprot.writeI64(self.itemId)
11748 
      oprot.writeFieldEnd()
3431 rajveer 11749 
    if self.quantity is not None:
559 chandransh 11750 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11751 
      oprot.writeI64(self.quantity)
11752 
      oprot.writeFieldEnd()
3557 rajveer 11753 
    if self.sourceId is not None:
11754 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11755 
      oprot.writeI64(self.sourceId)
11756 
      oprot.writeFieldEnd()
559 chandransh 11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
559 chandransh 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
11775 
class addItemToCart_result:
11776 
  """
11777 
  Attributes:
2035 rajveer 11778 
   - success
559 chandransh 11779 
   - scx
11780 
  """
11781 
 
11782 
  thrift_spec = (
2035 rajveer 11783 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11784 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11785 
  )
11786 
 
2035 rajveer 11787 
  def __init__(self, success=None, scx=None,):
11788 
    self.success = success
559 chandransh 11789 
    self.scx = scx
11790 
 
11791 
  def read(self, iprot):
11792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11794 
      return
11795 
    iprot.readStructBegin()
11796 
    while True:
11797 
      (fname, ftype, fid) = iprot.readFieldBegin()
11798 
      if ftype == TType.STOP:
11799 
        break
2035 rajveer 11800 
      if fid == 0:
11801 
        if ftype == TType.STRING:
11802 
          self.success = iprot.readString();
11803 
        else:
11804 
          iprot.skip(ftype)
11805 
      elif fid == 1:
559 chandransh 11806 
        if ftype == TType.STRUCT:
11807 
          self.scx = ShoppingCartException()
11808 
          self.scx.read(iprot)
11809 
        else:
11810 
          iprot.skip(ftype)
11811 
      else:
11812 
        iprot.skip(ftype)
11813 
      iprot.readFieldEnd()
11814 
    iprot.readStructEnd()
11815 
 
11816 
  def write(self, oprot):
11817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11819 
      return
11820 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11821 
    if self.success is not None:
2035 rajveer 11822 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11823 
      oprot.writeString(self.success)
11824 
      oprot.writeFieldEnd()
3431 rajveer 11825 
    if self.scx is not None:
559 chandransh 11826 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11827 
      self.scx.write(oprot)
11828 
      oprot.writeFieldEnd()
11829 
    oprot.writeFieldStop()
11830 
    oprot.writeStructEnd()
11831 
 
3431 rajveer 11832 
  def validate(self):
11833 
    return
11834 
 
11835 
 
559 chandransh 11836 
  def __repr__(self):
11837 
    L = ['%s=%r' % (key, value)
11838 
      for key, value in self.__dict__.iteritems()]
11839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11840 
 
11841 
  def __eq__(self, other):
11842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11843 
 
11844 
  def __ne__(self, other):
11845 
    return not (self == other)
11846 
 
11847 
class deleteItemFromCart_args:
11848 
  """
11849 
  Attributes:
11850 
   - cartId
11851 
   - itemId
11852 
  """
11853 
 
11854 
  thrift_spec = (
11855 
    None, # 0
11856 
    (1, TType.I64, 'cartId', None, None, ), # 1
11857 
    (2, TType.I64, 'itemId', None, None, ), # 2
11858 
  )
11859 
 
11860 
  def __init__(self, cartId=None, itemId=None,):
11861 
    self.cartId = cartId
11862 
    self.itemId = itemId
11863 
 
11864 
  def read(self, iprot):
11865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11867 
      return
11868 
    iprot.readStructBegin()
11869 
    while True:
11870 
      (fname, ftype, fid) = iprot.readFieldBegin()
11871 
      if ftype == TType.STOP:
11872 
        break
11873 
      if fid == 1:
11874 
        if ftype == TType.I64:
11875 
          self.cartId = iprot.readI64();
11876 
        else:
11877 
          iprot.skip(ftype)
11878 
      elif fid == 2:
11879 
        if ftype == TType.I64:
11880 
          self.itemId = iprot.readI64();
11881 
        else:
11882 
          iprot.skip(ftype)
11883 
      else:
11884 
        iprot.skip(ftype)
11885 
      iprot.readFieldEnd()
11886 
    iprot.readStructEnd()
11887 
 
11888 
  def write(self, oprot):
11889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11891 
      return
11892 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11893 
    if self.cartId is not None:
559 chandransh 11894 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11895 
      oprot.writeI64(self.cartId)
11896 
      oprot.writeFieldEnd()
3431 rajveer 11897 
    if self.itemId is not None:
559 chandransh 11898 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11899 
      oprot.writeI64(self.itemId)
11900 
      oprot.writeFieldEnd()
11901 
    oprot.writeFieldStop()
11902 
    oprot.writeStructEnd()
11903 
 
3431 rajveer 11904 
  def validate(self):
11905 
    return
11906 
 
11907 
 
559 chandransh 11908 
  def __repr__(self):
11909 
    L = ['%s=%r' % (key, value)
11910 
      for key, value in self.__dict__.iteritems()]
11911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11912 
 
11913 
  def __eq__(self, other):
11914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11915 
 
11916 
  def __ne__(self, other):
11917 
    return not (self == other)
11918 
 
11919 
class deleteItemFromCart_result:
11920 
  """
11921 
  Attributes:
11922 
   - scx
11923 
  """
11924 
 
11925 
  thrift_spec = (
11926 
    None, # 0
11927 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11928 
  )
11929 
 
11930 
  def __init__(self, scx=None,):
11931 
    self.scx = scx
11932 
 
11933 
  def read(self, iprot):
11934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11936 
      return
11937 
    iprot.readStructBegin()
11938 
    while True:
11939 
      (fname, ftype, fid) = iprot.readFieldBegin()
11940 
      if ftype == TType.STOP:
11941 
        break
11942 
      if fid == 1:
11943 
        if ftype == TType.STRUCT:
11944 
          self.scx = ShoppingCartException()
11945 
          self.scx.read(iprot)
11946 
        else:
11947 
          iprot.skip(ftype)
11948 
      else:
11949 
        iprot.skip(ftype)
11950 
      iprot.readFieldEnd()
11951 
    iprot.readStructEnd()
11952 
 
11953 
  def write(self, oprot):
11954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11956 
      return
11957 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11958 
    if self.scx is not None:
559 chandransh 11959 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11960 
      self.scx.write(oprot)
11961 
      oprot.writeFieldEnd()
11962 
    oprot.writeFieldStop()
11963 
    oprot.writeStructEnd()
11964 
 
3431 rajveer 11965 
  def validate(self):
11966 
    return
11967 
 
11968 
 
559 chandransh 11969 
  def __repr__(self):
11970 
    L = ['%s=%r' % (key, value)
11971 
      for key, value in self.__dict__.iteritems()]
11972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11973 
 
11974 
  def __eq__(self, other):
11975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11976 
 
11977 
  def __ne__(self, other):
11978 
    return not (self == other)
11979 
 
11980 
class addAddressToCart_args:
11981 
  """
11982 
  Attributes:
11983 
   - cartId
11984 
   - addressId
11985 
  """
11986 
 
11987 
  thrift_spec = (
11988 
    None, # 0
11989 
    (1, TType.I64, 'cartId', None, None, ), # 1
11990 
    (2, TType.I64, 'addressId', None, None, ), # 2
11991 
  )
11992 
 
11993 
  def __init__(self, cartId=None, addressId=None,):
11994 
    self.cartId = cartId
11995 
    self.addressId = addressId
11996 
 
11997 
  def read(self, iprot):
11998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12000 
      return
12001 
    iprot.readStructBegin()
12002 
    while True:
12003 
      (fname, ftype, fid) = iprot.readFieldBegin()
12004 
      if ftype == TType.STOP:
12005 
        break
12006 
      if fid == 1:
12007 
        if ftype == TType.I64:
12008 
          self.cartId = iprot.readI64();
12009 
        else:
12010 
          iprot.skip(ftype)
12011 
      elif fid == 2:
12012 
        if ftype == TType.I64:
12013 
          self.addressId = iprot.readI64();
12014 
        else:
12015 
          iprot.skip(ftype)
12016 
      else:
12017 
        iprot.skip(ftype)
12018 
      iprot.readFieldEnd()
12019 
    iprot.readStructEnd()
12020 
 
12021 
  def write(self, oprot):
12022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12024 
      return
12025 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 12026 
    if self.cartId is not None:
559 chandransh 12027 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12028 
      oprot.writeI64(self.cartId)
12029 
      oprot.writeFieldEnd()
3431 rajveer 12030 
    if self.addressId is not None:
559 chandransh 12031 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
12032 
      oprot.writeI64(self.addressId)
12033 
      oprot.writeFieldEnd()
12034 
    oprot.writeFieldStop()
12035 
    oprot.writeStructEnd()
12036 
 
3431 rajveer 12037 
  def validate(self):
12038 
    return
12039 
 
12040 
 
559 chandransh 12041 
  def __repr__(self):
12042 
    L = ['%s=%r' % (key, value)
12043 
      for key, value in self.__dict__.iteritems()]
12044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12045 
 
12046 
  def __eq__(self, other):
12047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12048 
 
12049 
  def __ne__(self, other):
12050 
    return not (self == other)
12051 
 
12052 
class addAddressToCart_result:
575 chandransh 12053 
  """
12054 
  Attributes:
12055 
   - scx
12056 
  """
559 chandransh 12057 
 
12058 
  thrift_spec = (
575 chandransh 12059 
    None, # 0
12060 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12061 
  )
12062 
 
575 chandransh 12063 
  def __init__(self, scx=None,):
12064 
    self.scx = scx
12065 
 
559 chandransh 12066 
  def read(self, iprot):
12067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12069 
      return
12070 
    iprot.readStructBegin()
12071 
    while True:
12072 
      (fname, ftype, fid) = iprot.readFieldBegin()
12073 
      if ftype == TType.STOP:
12074 
        break
575 chandransh 12075 
      if fid == 1:
12076 
        if ftype == TType.STRUCT:
12077 
          self.scx = ShoppingCartException()
12078 
          self.scx.read(iprot)
12079 
        else:
12080 
          iprot.skip(ftype)
559 chandransh 12081 
      else:
12082 
        iprot.skip(ftype)
12083 
      iprot.readFieldEnd()
12084 
    iprot.readStructEnd()
12085 
 
12086 
  def write(self, oprot):
12087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12089 
      return
12090 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 12091 
    if self.scx is not None:
575 chandransh 12092 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12093 
      self.scx.write(oprot)
12094 
      oprot.writeFieldEnd()
559 chandransh 12095 
    oprot.writeFieldStop()
12096 
    oprot.writeStructEnd()
12097 
 
3431 rajveer 12098 
  def validate(self):
12099 
    return
12100 
 
12101 
 
559 chandransh 12102 
  def __repr__(self):
12103 
    L = ['%s=%r' % (key, value)
12104 
      for key, value in self.__dict__.iteritems()]
12105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12106 
 
12107 
  def __eq__(self, other):
12108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12109 
 
12110 
  def __ne__(self, other):
12111 
    return not (self == other)
12112 
 
5553 rajveer 12113 
class addStoreToCart_args:
12114 
  """
12115 
  Attributes:
12116 
   - cartId
12117 
   - storeId
12118 
  """
12119 
 
12120 
  thrift_spec = (
12121 
    None, # 0
12122 
    (1, TType.I64, 'cartId', None, None, ), # 1
12123 
    (2, TType.I64, 'storeId', None, None, ), # 2
12124 
  )
12125 
 
12126 
  def __init__(self, cartId=None, storeId=None,):
12127 
    self.cartId = cartId
12128 
    self.storeId = storeId
12129 
 
12130 
  def read(self, iprot):
12131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12133 
      return
12134 
    iprot.readStructBegin()
12135 
    while True:
12136 
      (fname, ftype, fid) = iprot.readFieldBegin()
12137 
      if ftype == TType.STOP:
12138 
        break
12139 
      if fid == 1:
12140 
        if ftype == TType.I64:
12141 
          self.cartId = iprot.readI64();
12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      elif fid == 2:
12145 
        if ftype == TType.I64:
12146 
          self.storeId = iprot.readI64();
12147 
        else:
12148 
          iprot.skip(ftype)
12149 
      else:
12150 
        iprot.skip(ftype)
12151 
      iprot.readFieldEnd()
12152 
    iprot.readStructEnd()
12153 
 
12154 
  def write(self, oprot):
12155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12157 
      return
12158 
    oprot.writeStructBegin('addStoreToCart_args')
12159 
    if self.cartId is not None:
12160 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12161 
      oprot.writeI64(self.cartId)
12162 
      oprot.writeFieldEnd()
12163 
    if self.storeId is not None:
12164 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
12165 
      oprot.writeI64(self.storeId)
12166 
      oprot.writeFieldEnd()
12167 
    oprot.writeFieldStop()
12168 
    oprot.writeStructEnd()
12169 
 
12170 
  def validate(self):
12171 
    return
12172 
 
12173 
 
12174 
  def __repr__(self):
12175 
    L = ['%s=%r' % (key, value)
12176 
      for key, value in self.__dict__.iteritems()]
12177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12178 
 
12179 
  def __eq__(self, other):
12180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12181 
 
12182 
  def __ne__(self, other):
12183 
    return not (self == other)
12184 
 
12185 
class addStoreToCart_result:
12186 
  """
12187 
  Attributes:
12188 
   - scx
12189 
  """
12190 
 
12191 
  thrift_spec = (
12192 
    None, # 0
12193 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12194 
  )
12195 
 
12196 
  def __init__(self, scx=None,):
12197 
    self.scx = scx
12198 
 
12199 
  def read(self, iprot):
12200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12202 
      return
12203 
    iprot.readStructBegin()
12204 
    while True:
12205 
      (fname, ftype, fid) = iprot.readFieldBegin()
12206 
      if ftype == TType.STOP:
12207 
        break
12208 
      if fid == 1:
12209 
        if ftype == TType.STRUCT:
12210 
          self.scx = ShoppingCartException()
12211 
          self.scx.read(iprot)
12212 
        else:
12213 
          iprot.skip(ftype)
12214 
      else:
12215 
        iprot.skip(ftype)
12216 
      iprot.readFieldEnd()
12217 
    iprot.readStructEnd()
12218 
 
12219 
  def write(self, oprot):
12220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12222 
      return
12223 
    oprot.writeStructBegin('addStoreToCart_result')
12224 
    if self.scx is not None:
12225 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12226 
      self.scx.write(oprot)
12227 
      oprot.writeFieldEnd()
12228 
    oprot.writeFieldStop()
12229 
    oprot.writeStructEnd()
12230 
 
12231 
  def validate(self):
12232 
    return
12233 
 
12234 
 
12235 
  def __repr__(self):
12236 
    L = ['%s=%r' % (key, value)
12237 
      for key, value in self.__dict__.iteritems()]
12238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12239 
 
12240 
  def __eq__(self, other):
12241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12242 
 
12243 
  def __ne__(self, other):
12244 
    return not (self == other)
12245 
 
1976 varun.gupt 12246 
class applyCouponToCart_args:
12247 
  """
12248 
  Attributes:
6922 anupam.sin 12249 
   - cart
1976 varun.gupt 12250 
   - couponCode
12251 
  """
12252 
 
12253 
  thrift_spec = (
12254 
    None, # 0
6922 anupam.sin 12255 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 12256 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
12257 
  )
12258 
 
6922 anupam.sin 12259 
  def __init__(self, cart=None, couponCode=None,):
12260 
    self.cart = cart
1976 varun.gupt 12261 
    self.couponCode = couponCode
12262 
 
12263 
  def read(self, iprot):
12264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12266 
      return
12267 
    iprot.readStructBegin()
12268 
    while True:
12269 
      (fname, ftype, fid) = iprot.readFieldBegin()
12270 
      if ftype == TType.STOP:
12271 
        break
12272 
      if fid == 1:
6922 anupam.sin 12273 
        if ftype == TType.STRUCT:
12274 
          self.cart = Cart()
12275 
          self.cart.read(iprot)
1976 varun.gupt 12276 
        else:
12277 
          iprot.skip(ftype)
12278 
      elif fid == 2:
12279 
        if ftype == TType.STRING:
12280 
          self.couponCode = iprot.readString();
12281 
        else:
12282 
          iprot.skip(ftype)
12283 
      else:
12284 
        iprot.skip(ftype)
12285 
      iprot.readFieldEnd()
12286 
    iprot.readStructEnd()
12287 
 
12288 
  def write(self, oprot):
12289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12291 
      return
12292 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 12293 
    if self.cart is not None:
12294 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
12295 
      self.cart.write(oprot)
1976 varun.gupt 12296 
      oprot.writeFieldEnd()
3431 rajveer 12297 
    if self.couponCode is not None:
1976 varun.gupt 12298 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
12299 
      oprot.writeString(self.couponCode)
12300 
      oprot.writeFieldEnd()
12301 
    oprot.writeFieldStop()
12302 
    oprot.writeStructEnd()
12303 
 
3431 rajveer 12304 
  def validate(self):
12305 
    return
12306 
 
12307 
 
1976 varun.gupt 12308 
  def __repr__(self):
12309 
    L = ['%s=%r' % (key, value)
12310 
      for key, value in self.__dict__.iteritems()]
12311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12312 
 
12313 
  def __eq__(self, other):
12314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12315 
 
12316 
  def __ne__(self, other):
12317 
    return not (self == other)
12318 
 
12319 
class applyCouponToCart_result:
12320 
  """
12321 
  Attributes:
12322 
   - scx
12323 
  """
12324 
 
12325 
  thrift_spec = (
12326 
    None, # 0
12327 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12328 
  )
12329 
 
12330 
  def __init__(self, scx=None,):
12331 
    self.scx = scx
12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 1:
12343 
        if ftype == TType.STRUCT:
12344 
          self.scx = ShoppingCartException()
12345 
          self.scx.read(iprot)
12346 
        else:
12347 
          iprot.skip(ftype)
12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
12357 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 12358 
    if self.scx is not None:
1976 varun.gupt 12359 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12360 
      self.scx.write(oprot)
12361 
      oprot.writeFieldEnd()
12362 
    oprot.writeFieldStop()
12363 
    oprot.writeStructEnd()
12364 
 
3431 rajveer 12365 
  def validate(self):
12366 
    return
12367 
 
12368 
 
1976 varun.gupt 12369 
  def __repr__(self):
12370 
    L = ['%s=%r' % (key, value)
12371 
      for key, value in self.__dict__.iteritems()]
12372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12373 
 
12374 
  def __eq__(self, other):
12375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12376 
 
12377 
  def __ne__(self, other):
12378 
    return not (self == other)
12379 
 
12380 
class removeCoupon_args:
12381 
  """
12382 
  Attributes:
12383 
   - cartId
12384 
  """
12385 
 
12386 
  thrift_spec = (
12387 
    None, # 0
12388 
    (1, TType.I64, 'cartId', None, None, ), # 1
12389 
  )
12390 
 
12391 
  def __init__(self, cartId=None,):
12392 
    self.cartId = cartId
12393 
 
12394 
  def read(self, iprot):
12395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12397 
      return
12398 
    iprot.readStructBegin()
12399 
    while True:
12400 
      (fname, ftype, fid) = iprot.readFieldBegin()
12401 
      if ftype == TType.STOP:
12402 
        break
12403 
      if fid == 1:
12404 
        if ftype == TType.I64:
12405 
          self.cartId = iprot.readI64();
12406 
        else:
12407 
          iprot.skip(ftype)
12408 
      else:
12409 
        iprot.skip(ftype)
12410 
      iprot.readFieldEnd()
12411 
    iprot.readStructEnd()
12412 
 
12413 
  def write(self, oprot):
12414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12416 
      return
12417 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 12418 
    if self.cartId is not None:
1976 varun.gupt 12419 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12420 
      oprot.writeI64(self.cartId)
12421 
      oprot.writeFieldEnd()
12422 
    oprot.writeFieldStop()
12423 
    oprot.writeStructEnd()
12424 
 
3431 rajveer 12425 
  def validate(self):
12426 
    return
12427 
 
12428 
 
1976 varun.gupt 12429 
  def __repr__(self):
12430 
    L = ['%s=%r' % (key, value)
12431 
      for key, value in self.__dict__.iteritems()]
12432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12433 
 
12434 
  def __eq__(self, other):
12435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12436 
 
12437 
  def __ne__(self, other):
12438 
    return not (self == other)
12439 
 
12440 
class removeCoupon_result:
12441 
  """
12442 
  Attributes:
12443 
   - scx
12444 
  """
12445 
 
12446 
  thrift_spec = (
12447 
    None, # 0
12448 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12449 
  )
12450 
 
12451 
  def __init__(self, scx=None,):
12452 
    self.scx = scx
12453 
 
12454 
  def read(self, iprot):
12455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12457 
      return
12458 
    iprot.readStructBegin()
12459 
    while True:
12460 
      (fname, ftype, fid) = iprot.readFieldBegin()
12461 
      if ftype == TType.STOP:
12462 
        break
12463 
      if fid == 1:
12464 
        if ftype == TType.STRUCT:
12465 
          self.scx = ShoppingCartException()
12466 
          self.scx.read(iprot)
12467 
        else:
12468 
          iprot.skip(ftype)
12469 
      else:
12470 
        iprot.skip(ftype)
12471 
      iprot.readFieldEnd()
12472 
    iprot.readStructEnd()
12473 
 
12474 
  def write(self, oprot):
12475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12477 
      return
12478 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 12479 
    if self.scx is not None:
1976 varun.gupt 12480 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12481 
      self.scx.write(oprot)
12482 
      oprot.writeFieldEnd()
12483 
    oprot.writeFieldStop()
12484 
    oprot.writeStructEnd()
12485 
 
3431 rajveer 12486 
  def validate(self):
12487 
    return
12488 
 
12489 
 
1976 varun.gupt 12490 
  def __repr__(self):
12491 
    L = ['%s=%r' % (key, value)
12492 
      for key, value in self.__dict__.iteritems()]
12493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12494 
 
12495 
  def __eq__(self, other):
12496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12497 
 
12498 
  def __ne__(self, other):
12499 
    return not (self == other)
12500 
 
3554 varun.gupt 12501 
class deleteDiscountsFromCart_args:
12502 
  """
12503 
  Attributes:
12504 
   - cartId
12505 
  """
12506 
 
12507 
  thrift_spec = (
12508 
    None, # 0
12509 
    (1, TType.I64, 'cartId', None, None, ), # 1
12510 
  )
12511 
 
12512 
  def __init__(self, cartId=None,):
12513 
    self.cartId = cartId
12514 
 
12515 
  def read(self, iprot):
12516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12518 
      return
12519 
    iprot.readStructBegin()
12520 
    while True:
12521 
      (fname, ftype, fid) = iprot.readFieldBegin()
12522 
      if ftype == TType.STOP:
12523 
        break
12524 
      if fid == 1:
12525 
        if ftype == TType.I64:
12526 
          self.cartId = iprot.readI64();
12527 
        else:
12528 
          iprot.skip(ftype)
12529 
      else:
12530 
        iprot.skip(ftype)
12531 
      iprot.readFieldEnd()
12532 
    iprot.readStructEnd()
12533 
 
12534 
  def write(self, oprot):
12535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12537 
      return
12538 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12539 
    if self.cartId is not None:
12540 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12541 
      oprot.writeI64(self.cartId)
12542 
      oprot.writeFieldEnd()
12543 
    oprot.writeFieldStop()
12544 
    oprot.writeStructEnd()
12545 
 
12546 
  def validate(self):
12547 
    return
12548 
 
12549 
 
12550 
  def __repr__(self):
12551 
    L = ['%s=%r' % (key, value)
12552 
      for key, value in self.__dict__.iteritems()]
12553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12554 
 
12555 
  def __eq__(self, other):
12556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12557 
 
12558 
  def __ne__(self, other):
12559 
    return not (self == other)
12560 
 
12561 
class deleteDiscountsFromCart_result:
12562 
  """
12563 
  Attributes:
12564 
   - scx
12565 
  """
12566 
 
12567 
  thrift_spec = (
12568 
    None, # 0
12569 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12570 
  )
12571 
 
12572 
  def __init__(self, scx=None,):
12573 
    self.scx = scx
12574 
 
12575 
  def read(self, iprot):
12576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12578 
      return
12579 
    iprot.readStructBegin()
12580 
    while True:
12581 
      (fname, ftype, fid) = iprot.readFieldBegin()
12582 
      if ftype == TType.STOP:
12583 
        break
12584 
      if fid == 1:
12585 
        if ftype == TType.STRUCT:
12586 
          self.scx = ShoppingCartException()
12587 
          self.scx.read(iprot)
12588 
        else:
12589 
          iprot.skip(ftype)
12590 
      else:
12591 
        iprot.skip(ftype)
12592 
      iprot.readFieldEnd()
12593 
    iprot.readStructEnd()
12594 
 
12595 
  def write(self, oprot):
12596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12598 
      return
12599 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12600 
    if self.scx is not None:
12601 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12602 
      self.scx.write(oprot)
12603 
      oprot.writeFieldEnd()
12604 
    oprot.writeFieldStop()
12605 
    oprot.writeStructEnd()
12606 
 
12607 
  def validate(self):
12608 
    return
12609 
 
12610 
 
12611 
  def __repr__(self):
12612 
    L = ['%s=%r' % (key, value)
12613 
      for key, value in self.__dict__.iteritems()]
12614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12615 
 
12616 
  def __eq__(self, other):
12617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12618 
 
12619 
  def __ne__(self, other):
12620 
    return not (self == other)
12621 
 
12622 
class saveDiscounts_args:
12623 
  """
12624 
  Attributes:
12625 
   - discounts
12626 
  """
12627 
 
12628 
  thrift_spec = (
12629 
    None, # 0
12630 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12631 
  )
12632 
 
12633 
  def __init__(self, discounts=None,):
12634 
    self.discounts = discounts
12635 
 
12636 
  def read(self, iprot):
12637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12639 
      return
12640 
    iprot.readStructBegin()
12641 
    while True:
12642 
      (fname, ftype, fid) = iprot.readFieldBegin()
12643 
      if ftype == TType.STOP:
12644 
        break
12645 
      if fid == 1:
12646 
        if ftype == TType.LIST:
12647 
          self.discounts = []
11592 amit.gupta 12648 
          (_etype163, _size160) = iprot.readListBegin()
12649 
          for _i164 in xrange(_size160):
12650 
            _elem165 = Discount()
12651 
            _elem165.read(iprot)
12652 
            self.discounts.append(_elem165)
3554 varun.gupt 12653 
          iprot.readListEnd()
12654 
        else:
12655 
          iprot.skip(ftype)
12656 
      else:
12657 
        iprot.skip(ftype)
12658 
      iprot.readFieldEnd()
12659 
    iprot.readStructEnd()
12660 
 
12661 
  def write(self, oprot):
12662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12664 
      return
12665 
    oprot.writeStructBegin('saveDiscounts_args')
12666 
    if self.discounts is not None:
12667 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12668 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12669 
      for iter166 in self.discounts:
12670 
        iter166.write(oprot)
3554 varun.gupt 12671 
      oprot.writeListEnd()
12672 
      oprot.writeFieldEnd()
12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
12676 
  def validate(self):
12677 
    return
12678 
 
12679 
 
12680 
  def __repr__(self):
12681 
    L = ['%s=%r' % (key, value)
12682 
      for key, value in self.__dict__.iteritems()]
12683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12684 
 
12685 
  def __eq__(self, other):
12686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12687 
 
12688 
  def __ne__(self, other):
12689 
    return not (self == other)
12690 
 
12691 
class saveDiscounts_result:
12692 
  """
12693 
  Attributes:
12694 
   - scx
12695 
  """
12696 
 
12697 
  thrift_spec = (
12698 
    None, # 0
12699 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12700 
  )
12701 
 
12702 
  def __init__(self, scx=None,):
12703 
    self.scx = scx
12704 
 
12705 
  def read(self, iprot):
12706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12708 
      return
12709 
    iprot.readStructBegin()
12710 
    while True:
12711 
      (fname, ftype, fid) = iprot.readFieldBegin()
12712 
      if ftype == TType.STOP:
12713 
        break
12714 
      if fid == 1:
12715 
        if ftype == TType.STRUCT:
12716 
          self.scx = ShoppingCartException()
12717 
          self.scx.read(iprot)
12718 
        else:
12719 
          iprot.skip(ftype)
12720 
      else:
12721 
        iprot.skip(ftype)
12722 
      iprot.readFieldEnd()
12723 
    iprot.readStructEnd()
12724 
 
12725 
  def write(self, oprot):
12726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12728 
      return
12729 
    oprot.writeStructBegin('saveDiscounts_result')
12730 
    if self.scx is not None:
12731 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12732 
      self.scx.write(oprot)
12733 
      oprot.writeFieldEnd()
12734 
    oprot.writeFieldStop()
12735 
    oprot.writeStructEnd()
12736 
 
12737 
  def validate(self):
12738 
    return
12739 
 
12740 
 
12741 
  def __repr__(self):
12742 
    L = ['%s=%r' % (key, value)
12743 
      for key, value in self.__dict__.iteritems()]
12744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12745 
 
12746 
  def __eq__(self, other):
12747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12748 
 
12749 
  def __ne__(self, other):
12750 
    return not (self == other)
12751 
 
690 chandransh 12752 
class createOrders_args:
559 chandransh 12753 
  """
12754 
  Attributes:
12755 
   - cartId
2815 vikas 12756 
   - sessionSource
12757 
   - sessionStartTime
3858 vikas 12758 
   - firstSource
12759 
   - firstSourceTime
5326 rajveer 12760 
   - userId
6389 rajveer 12761 
   - schemeId
11526 amit.gupta 12762 
   - orderSource
21454 amit.gupta 12763 
   - selfPickup
559 chandransh 12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    None, # 0
12768 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12769 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12770 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12771 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12772 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12773 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12774 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12775 
    (8, TType.I64, 'orderSource', None, None, ), # 8
21454 amit.gupta 12776 
    (9, TType.BOOL, 'selfPickup', None, None, ), # 9
559 chandransh 12777 
  )
12778 
 
21454 amit.gupta 12779 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None, selfPickup=None,):
559 chandransh 12780 
    self.cartId = cartId
2815 vikas 12781 
    self.sessionSource = sessionSource
12782 
    self.sessionStartTime = sessionStartTime
3858 vikas 12783 
    self.firstSource = firstSource
12784 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12785 
    self.userId = userId
6389 rajveer 12786 
    self.schemeId = schemeId
11526 amit.gupta 12787 
    self.orderSource = orderSource
21454 amit.gupta 12788 
    self.selfPickup = selfPickup
559 chandransh 12789 
 
12790 
  def read(self, iprot):
12791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12793 
      return
12794 
    iprot.readStructBegin()
12795 
    while True:
12796 
      (fname, ftype, fid) = iprot.readFieldBegin()
12797 
      if ftype == TType.STOP:
12798 
        break
12799 
      if fid == 1:
12800 
        if ftype == TType.I64:
12801 
          self.cartId = iprot.readI64();
12802 
        else:
12803 
          iprot.skip(ftype)
2815 vikas 12804 
      elif fid == 2:
12805 
        if ftype == TType.STRING:
12806 
          self.sessionSource = iprot.readString();
12807 
        else:
12808 
          iprot.skip(ftype)
12809 
      elif fid == 3:
12810 
        if ftype == TType.I64:
12811 
          self.sessionStartTime = iprot.readI64();
12812 
        else:
12813 
          iprot.skip(ftype)
3858 vikas 12814 
      elif fid == 4:
12815 
        if ftype == TType.STRING:
12816 
          self.firstSource = iprot.readString();
12817 
        else:
12818 
          iprot.skip(ftype)
12819 
      elif fid == 5:
12820 
        if ftype == TType.I64:
12821 
          self.firstSourceTime = iprot.readI64();
12822 
        else:
12823 
          iprot.skip(ftype)
5326 rajveer 12824 
      elif fid == 6:
12825 
        if ftype == TType.I64:
12826 
          self.userId = iprot.readI64();
12827 
        else:
12828 
          iprot.skip(ftype)
6389 rajveer 12829 
      elif fid == 7:
12830 
        if ftype == TType.I64:
12831 
          self.schemeId = iprot.readI64();
12832 
        else:
12833 
          iprot.skip(ftype)
11526 amit.gupta 12834 
      elif fid == 8:
12835 
        if ftype == TType.I64:
12836 
          self.orderSource = iprot.readI64();
12837 
        else:
12838 
          iprot.skip(ftype)
21454 amit.gupta 12839 
      elif fid == 9:
12840 
        if ftype == TType.BOOL:
12841 
          self.selfPickup = iprot.readBool();
12842 
        else:
12843 
          iprot.skip(ftype)
559 chandransh 12844 
      else:
12845 
        iprot.skip(ftype)
12846 
      iprot.readFieldEnd()
12847 
    iprot.readStructEnd()
12848 
 
12849 
  def write(self, oprot):
12850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12852 
      return
690 chandransh 12853 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12854 
    if self.cartId is not None:
559 chandransh 12855 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12856 
      oprot.writeI64(self.cartId)
12857 
      oprot.writeFieldEnd()
3431 rajveer 12858 
    if self.sessionSource is not None:
2815 vikas 12859 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12860 
      oprot.writeString(self.sessionSource)
12861 
      oprot.writeFieldEnd()
3431 rajveer 12862 
    if self.sessionStartTime is not None:
2815 vikas 12863 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12864 
      oprot.writeI64(self.sessionStartTime)
12865 
      oprot.writeFieldEnd()
3858 vikas 12866 
    if self.firstSource is not None:
12867 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12868 
      oprot.writeString(self.firstSource)
12869 
      oprot.writeFieldEnd()
12870 
    if self.firstSourceTime is not None:
12871 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12872 
      oprot.writeI64(self.firstSourceTime)
12873 
      oprot.writeFieldEnd()
5326 rajveer 12874 
    if self.userId is not None:
12875 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12876 
      oprot.writeI64(self.userId)
12877 
      oprot.writeFieldEnd()
6389 rajveer 12878 
    if self.schemeId is not None:
12879 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12880 
      oprot.writeI64(self.schemeId)
12881 
      oprot.writeFieldEnd()
11526 amit.gupta 12882 
    if self.orderSource is not None:
12883 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12884 
      oprot.writeI64(self.orderSource)
12885 
      oprot.writeFieldEnd()
21454 amit.gupta 12886 
    if self.selfPickup is not None:
12887 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 9)
12888 
      oprot.writeBool(self.selfPickup)
12889 
      oprot.writeFieldEnd()
559 chandransh 12890 
    oprot.writeFieldStop()
12891 
    oprot.writeStructEnd()
12892 
 
3431 rajveer 12893 
  def validate(self):
12894 
    return
12895 
 
12896 
 
559 chandransh 12897 
  def __repr__(self):
12898 
    L = ['%s=%r' % (key, value)
12899 
      for key, value in self.__dict__.iteritems()]
12900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12901 
 
12902 
  def __eq__(self, other):
12903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12904 
 
12905 
  def __ne__(self, other):
12906 
    return not (self == other)
12907 
 
690 chandransh 12908 
class createOrders_result:
559 chandransh 12909 
  """
12910 
  Attributes:
94 ashish 12911 
   - success
559 chandransh 12912 
   - scx
94 ashish 12913 
  """
12914 
 
12915 
  thrift_spec = (
575 chandransh 12916 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12917 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12918 
  )
12919 
 
559 chandransh 12920 
  def __init__(self, success=None, scx=None,):
94 ashish 12921 
    self.success = success
559 chandransh 12922 
    self.scx = scx
94 ashish 12923 
 
12924 
  def read(self, iprot):
12925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12927 
      return
12928 
    iprot.readStructBegin()
12929 
    while True:
12930 
      (fname, ftype, fid) = iprot.readFieldBegin()
12931 
      if ftype == TType.STOP:
12932 
        break
12933 
      if fid == 0:
575 chandransh 12934 
        if ftype == TType.I64:
12935 
          self.success = iprot.readI64();
94 ashish 12936 
        else:
12937 
          iprot.skip(ftype)
12938 
      elif fid == 1:
12939 
        if ftype == TType.STRUCT:
559 chandransh 12940 
          self.scx = ShoppingCartException()
12941 
          self.scx.read(iprot)
94 ashish 12942 
        else:
12943 
          iprot.skip(ftype)
12944 
      else:
12945 
        iprot.skip(ftype)
12946 
      iprot.readFieldEnd()
12947 
    iprot.readStructEnd()
12948 
 
12949 
  def write(self, oprot):
12950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12952 
      return
690 chandransh 12953 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12954 
    if self.success is not None:
575 chandransh 12955 
      oprot.writeFieldBegin('success', TType.I64, 0)
12956 
      oprot.writeI64(self.success)
94 ashish 12957 
      oprot.writeFieldEnd()
3431 rajveer 12958 
    if self.scx is not None:
559 chandransh 12959 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12960 
      self.scx.write(oprot)
94 ashish 12961 
      oprot.writeFieldEnd()
12962 
    oprot.writeFieldStop()
12963 
    oprot.writeStructEnd()
12964 
 
3431 rajveer 12965 
  def validate(self):
12966 
    return
12967 
 
12968 
 
94 ashish 12969 
  def __repr__(self):
12970 
    L = ['%s=%r' % (key, value)
12971 
      for key, value in self.__dict__.iteritems()]
12972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12973 
 
12974 
  def __eq__(self, other):
12975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12976 
 
12977 
  def __ne__(self, other):
12978 
    return not (self == other)
12979 
 
559 chandransh 12980 
class validateCart_args:
94 ashish 12981 
  """
12982 
  Attributes:
559 chandransh 12983 
   - cartId
3557 rajveer 12984 
   - sourceId
94 ashish 12985 
  """
12986 
 
12987 
  thrift_spec = (
12988 
    None, # 0
559 chandransh 12989 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12990 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12991 
  )
12992 
 
3557 rajveer 12993 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12994 
    self.cartId = cartId
3557 rajveer 12995 
    self.sourceId = sourceId
94 ashish 12996 
 
12997 
  def read(self, iprot):
12998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13000 
      return
13001 
    iprot.readStructBegin()
13002 
    while True:
13003 
      (fname, ftype, fid) = iprot.readFieldBegin()
13004 
      if ftype == TType.STOP:
13005 
        break
13006 
      if fid == 1:
13007 
        if ftype == TType.I64:
559 chandransh 13008 
          self.cartId = iprot.readI64();
94 ashish 13009 
        else:
13010 
          iprot.skip(ftype)
3557 rajveer 13011 
      elif fid == 2:
13012 
        if ftype == TType.I64:
13013 
          self.sourceId = iprot.readI64();
13014 
        else:
13015 
          iprot.skip(ftype)
94 ashish 13016 
      else:
13017 
        iprot.skip(ftype)
13018 
      iprot.readFieldEnd()
13019 
    iprot.readStructEnd()
13020 
 
13021 
  def write(self, oprot):
13022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13024 
      return
559 chandransh 13025 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 13026 
    if self.cartId is not None:
559 chandransh 13027 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13028 
      oprot.writeI64(self.cartId)
94 ashish 13029 
      oprot.writeFieldEnd()
3557 rajveer 13030 
    if self.sourceId is not None:
13031 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13032 
      oprot.writeI64(self.sourceId)
13033 
      oprot.writeFieldEnd()
94 ashish 13034 
    oprot.writeFieldStop()
13035 
    oprot.writeStructEnd()
13036 
 
3431 rajveer 13037 
  def validate(self):
13038 
    return
13039 
 
13040 
 
94 ashish 13041 
  def __repr__(self):
13042 
    L = ['%s=%r' % (key, value)
13043 
      for key, value in self.__dict__.iteritems()]
13044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13045 
 
13046 
  def __eq__(self, other):
13047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13048 
 
13049 
  def __ne__(self, other):
13050 
    return not (self == other)
13051 
 
559 chandransh 13052 
class validateCart_result:
94 ashish 13053 
  """
13054 
  Attributes:
13055 
   - success
575 chandransh 13056 
   - scex
94 ashish 13057 
  """
13058 
 
13059 
  thrift_spec = (
6736 amit.gupta 13060 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 13061 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 13062 
  )
13063 
 
575 chandransh 13064 
  def __init__(self, success=None, scex=None,):
94 ashish 13065 
    self.success = success
575 chandransh 13066 
    self.scex = scex
94 ashish 13067 
 
13068 
  def read(self, iprot):
13069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13071 
      return
13072 
    iprot.readStructBegin()
13073 
    while True:
13074 
      (fname, ftype, fid) = iprot.readFieldBegin()
13075 
      if ftype == TType.STOP:
13076 
        break
13077 
      if fid == 0:
6736 amit.gupta 13078 
        if ftype == TType.LIST:
13079 
          self.success = []
11592 amit.gupta 13080 
          (_etype170, _size167) = iprot.readListBegin()
13081 
          for _i171 in xrange(_size167):
13082 
            _elem172 = iprot.readString();
13083 
            self.success.append(_elem172)
6736 amit.gupta 13084 
          iprot.readListEnd()
94 ashish 13085 
        else:
13086 
          iprot.skip(ftype)
575 chandransh 13087 
      elif fid == 1:
13088 
        if ftype == TType.STRUCT:
13089 
          self.scex = ShoppingCartException()
13090 
          self.scex.read(iprot)
13091 
        else:
13092 
          iprot.skip(ftype)
94 ashish 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
559 chandransh 13102 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 13103 
    if self.success is not None:
6736 amit.gupta 13104 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13105 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 13106 
      for iter173 in self.success:
13107 
        oprot.writeString(iter173)
6736 amit.gupta 13108 
      oprot.writeListEnd()
94 ashish 13109 
      oprot.writeFieldEnd()
3431 rajveer 13110 
    if self.scex is not None:
575 chandransh 13111 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13112 
      self.scex.write(oprot)
13113 
      oprot.writeFieldEnd()
559 chandransh 13114 
    oprot.writeFieldStop()
13115 
    oprot.writeStructEnd()
13116 
 
3431 rajveer 13117 
  def validate(self):
13118 
    return
13119 
 
13120 
 
559 chandransh 13121 
  def __repr__(self):
13122 
    L = ['%s=%r' % (key, value)
13123 
      for key, value in self.__dict__.iteritems()]
13124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13125 
 
13126 
  def __eq__(self, other):
13127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13128 
 
13129 
  def __ne__(self, other):
13130 
    return not (self == other)
13131 
 
11980 amit.gupta 13132 
class validateCartWithDealerCoupon_args:
13133 
  """
13134 
  Attributes:
13135 
   - cartId
13136 
   - sourceId
13137 
   - dealCoupon
13138 
  """
13139 
 
13140 
  thrift_spec = (
13141 
    None, # 0
13142 
    (1, TType.I64, 'cartId', None, None, ), # 1
13143 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13144 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
13145 
  )
13146 
 
13147 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
13148 
    self.cartId = cartId
13149 
    self.sourceId = sourceId
13150 
    self.dealCoupon = dealCoupon
13151 
 
13152 
  def read(self, iprot):
13153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13155 
      return
13156 
    iprot.readStructBegin()
13157 
    while True:
13158 
      (fname, ftype, fid) = iprot.readFieldBegin()
13159 
      if ftype == TType.STOP:
13160 
        break
13161 
      if fid == 1:
13162 
        if ftype == TType.I64:
13163 
          self.cartId = iprot.readI64();
13164 
        else:
13165 
          iprot.skip(ftype)
13166 
      elif fid == 2:
13167 
        if ftype == TType.I64:
13168 
          self.sourceId = iprot.readI64();
13169 
        else:
13170 
          iprot.skip(ftype)
13171 
      elif fid == 3:
13172 
        if ftype == TType.STRING:
13173 
          self.dealCoupon = iprot.readString();
13174 
        else:
13175 
          iprot.skip(ftype)
13176 
      else:
13177 
        iprot.skip(ftype)
13178 
      iprot.readFieldEnd()
13179 
    iprot.readStructEnd()
13180 
 
13181 
  def write(self, oprot):
13182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13184 
      return
13185 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
13186 
    if self.cartId is not None:
13187 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13188 
      oprot.writeI64(self.cartId)
13189 
      oprot.writeFieldEnd()
13190 
    if self.sourceId is not None:
13191 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13192 
      oprot.writeI64(self.sourceId)
13193 
      oprot.writeFieldEnd()
13194 
    if self.dealCoupon is not None:
13195 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
13196 
      oprot.writeString(self.dealCoupon)
13197 
      oprot.writeFieldEnd()
13198 
    oprot.writeFieldStop()
13199 
    oprot.writeStructEnd()
13200 
 
13201 
  def validate(self):
13202 
    return
13203 
 
13204 
 
13205 
  def __repr__(self):
13206 
    L = ['%s=%r' % (key, value)
13207 
      for key, value in self.__dict__.iteritems()]
13208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13209 
 
13210 
  def __eq__(self, other):
13211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13212 
 
13213 
  def __ne__(self, other):
13214 
    return not (self == other)
13215 
 
13216 
class validateCartWithDealerCoupon_result:
13217 
  """
13218 
  Attributes:
13219 
   - success
13220 
   - scex
13221 
  """
13222 
 
13223 
  thrift_spec = (
13224 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13225 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13226 
  )
13227 
 
13228 
  def __init__(self, success=None, scex=None,):
13229 
    self.success = success
13230 
    self.scex = scex
13231 
 
13232 
  def read(self, iprot):
13233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13235 
      return
13236 
    iprot.readStructBegin()
13237 
    while True:
13238 
      (fname, ftype, fid) = iprot.readFieldBegin()
13239 
      if ftype == TType.STOP:
13240 
        break
13241 
      if fid == 0:
13242 
        if ftype == TType.LIST:
13243 
          self.success = []
13244 
          (_etype177, _size174) = iprot.readListBegin()
13245 
          for _i178 in xrange(_size174):
13246 
            _elem179 = iprot.readString();
13247 
            self.success.append(_elem179)
13248 
          iprot.readListEnd()
13249 
        else:
13250 
          iprot.skip(ftype)
13251 
      elif fid == 1:
13252 
        if ftype == TType.STRUCT:
13253 
          self.scex = ShoppingCartException()
13254 
          self.scex.read(iprot)
13255 
        else:
13256 
          iprot.skip(ftype)
13257 
      else:
13258 
        iprot.skip(ftype)
13259 
      iprot.readFieldEnd()
13260 
    iprot.readStructEnd()
13261 
 
13262 
  def write(self, oprot):
13263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13265 
      return
13266 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
13267 
    if self.success is not None:
13268 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13269 
      oprot.writeListBegin(TType.STRING, len(self.success))
13270 
      for iter180 in self.success:
13271 
        oprot.writeString(iter180)
13272 
      oprot.writeListEnd()
13273 
      oprot.writeFieldEnd()
13274 
    if self.scex is not None:
13275 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13276 
      self.scex.write(oprot)
13277 
      oprot.writeFieldEnd()
13278 
    oprot.writeFieldStop()
13279 
    oprot.writeStructEnd()
13280 
 
13281 
  def validate(self):
13282 
    return
13283 
 
13284 
 
13285 
  def __repr__(self):
13286 
    L = ['%s=%r' % (key, value)
13287 
      for key, value in self.__dict__.iteritems()]
13288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13289 
 
13290 
  def __eq__(self, other):
13291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13292 
 
13293 
  def __ne__(self, other):
13294 
    return not (self == other)
13295 
 
690 chandransh 13296 
class mergeCart_args:
575 chandransh 13297 
  """
13298 
  Attributes:
690 chandransh 13299 
   - fromCartId
13300 
   - toCartId
13301 
  """
13302 
 
13303 
  thrift_spec = (
13304 
    None, # 0
13305 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
13306 
    (2, TType.I64, 'toCartId', None, None, ), # 2
13307 
  )
13308 
 
13309 
  def __init__(self, fromCartId=None, toCartId=None,):
13310 
    self.fromCartId = fromCartId
13311 
    self.toCartId = toCartId
13312 
 
13313 
  def read(self, iprot):
13314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13316 
      return
13317 
    iprot.readStructBegin()
13318 
    while True:
13319 
      (fname, ftype, fid) = iprot.readFieldBegin()
13320 
      if ftype == TType.STOP:
13321 
        break
13322 
      if fid == 1:
13323 
        if ftype == TType.I64:
13324 
          self.fromCartId = iprot.readI64();
13325 
        else:
13326 
          iprot.skip(ftype)
13327 
      elif fid == 2:
13328 
        if ftype == TType.I64:
13329 
          self.toCartId = iprot.readI64();
13330 
        else:
13331 
          iprot.skip(ftype)
13332 
      else:
13333 
        iprot.skip(ftype)
13334 
      iprot.readFieldEnd()
13335 
    iprot.readStructEnd()
13336 
 
13337 
  def write(self, oprot):
13338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13340 
      return
13341 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 13342 
    if self.fromCartId is not None:
690 chandransh 13343 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
13344 
      oprot.writeI64(self.fromCartId)
13345 
      oprot.writeFieldEnd()
3431 rajveer 13346 
    if self.toCartId is not None:
690 chandransh 13347 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
13348 
      oprot.writeI64(self.toCartId)
13349 
      oprot.writeFieldEnd()
13350 
    oprot.writeFieldStop()
13351 
    oprot.writeStructEnd()
13352 
 
3431 rajveer 13353 
  def validate(self):
13354 
    return
13355 
 
13356 
 
690 chandransh 13357 
  def __repr__(self):
13358 
    L = ['%s=%r' % (key, value)
13359 
      for key, value in self.__dict__.iteritems()]
13360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13361 
 
13362 
  def __eq__(self, other):
13363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13364 
 
13365 
  def __ne__(self, other):
13366 
    return not (self == other)
13367 
 
13368 
class mergeCart_result:
13369 
 
13370 
  thrift_spec = (
13371 
  )
13372 
 
13373 
  def read(self, iprot):
13374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13376 
      return
13377 
    iprot.readStructBegin()
13378 
    while True:
13379 
      (fname, ftype, fid) = iprot.readFieldBegin()
13380 
      if ftype == TType.STOP:
13381 
        break
13382 
      else:
13383 
        iprot.skip(ftype)
13384 
      iprot.readFieldEnd()
13385 
    iprot.readStructEnd()
13386 
 
13387 
  def write(self, oprot):
13388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13390 
      return
13391 
    oprot.writeStructBegin('mergeCart_result')
13392 
    oprot.writeFieldStop()
13393 
    oprot.writeStructEnd()
13394 
 
3431 rajveer 13395 
  def validate(self):
13396 
    return
13397 
 
13398 
 
690 chandransh 13399 
  def __repr__(self):
13400 
    L = ['%s=%r' % (key, value)
13401 
      for key, value in self.__dict__.iteritems()]
13402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13403 
 
13404 
  def __eq__(self, other):
13405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13406 
 
13407 
  def __ne__(self, other):
13408 
    return not (self == other)
13409 
 
13410 
class checkOut_args:
13411 
  """
13412 
  Attributes:
575 chandransh 13413 
   - cartId
13414 
  """
13415 
 
13416 
  thrift_spec = (
13417 
    None, # 0
13418 
    (1, TType.I64, 'cartId', None, None, ), # 1
13419 
  )
13420 
 
13421 
  def __init__(self, cartId=None,):
13422 
    self.cartId = cartId
13423 
 
13424 
  def read(self, iprot):
13425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13427 
      return
13428 
    iprot.readStructBegin()
13429 
    while True:
13430 
      (fname, ftype, fid) = iprot.readFieldBegin()
13431 
      if ftype == TType.STOP:
13432 
        break
13433 
      if fid == 1:
13434 
        if ftype == TType.I64:
13435 
          self.cartId = iprot.readI64();
13436 
        else:
13437 
          iprot.skip(ftype)
13438 
      else:
13439 
        iprot.skip(ftype)
13440 
      iprot.readFieldEnd()
13441 
    iprot.readStructEnd()
13442 
 
13443 
  def write(self, oprot):
13444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13446 
      return
690 chandransh 13447 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 13448 
    if self.cartId is not None:
575 chandransh 13449 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13450 
      oprot.writeI64(self.cartId)
13451 
      oprot.writeFieldEnd()
13452 
    oprot.writeFieldStop()
13453 
    oprot.writeStructEnd()
13454 
 
3431 rajveer 13455 
  def validate(self):
13456 
    return
13457 
 
13458 
 
575 chandransh 13459 
  def __repr__(self):
13460 
    L = ['%s=%r' % (key, value)
13461 
      for key, value in self.__dict__.iteritems()]
13462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13463 
 
13464 
  def __eq__(self, other):
13465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13466 
 
13467 
  def __ne__(self, other):
13468 
    return not (self == other)
13469 
 
690 chandransh 13470 
class checkOut_result:
575 chandransh 13471 
  """
13472 
  Attributes:
13473 
   - success
13474 
   - scex
13475 
  """
13476 
 
13477 
  thrift_spec = (
13478 
    (0, TType.BOOL, 'success', None, None, ), # 0
13479 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13480 
  )
13481 
 
13482 
  def __init__(self, success=None, scex=None,):
13483 
    self.success = success
13484 
    self.scex = scex
13485 
 
13486 
  def read(self, iprot):
13487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13489 
      return
13490 
    iprot.readStructBegin()
13491 
    while True:
13492 
      (fname, ftype, fid) = iprot.readFieldBegin()
13493 
      if ftype == TType.STOP:
13494 
        break
13495 
      if fid == 0:
13496 
        if ftype == TType.BOOL:
13497 
          self.success = iprot.readBool();
13498 
        else:
13499 
          iprot.skip(ftype)
13500 
      elif fid == 1:
13501 
        if ftype == TType.STRUCT:
13502 
          self.scex = ShoppingCartException()
13503 
          self.scex.read(iprot)
13504 
        else:
13505 
          iprot.skip(ftype)
13506 
      else:
13507 
        iprot.skip(ftype)
13508 
      iprot.readFieldEnd()
13509 
    iprot.readStructEnd()
13510 
 
13511 
  def write(self, oprot):
13512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13514 
      return
690 chandransh 13515 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 13516 
    if self.success is not None:
575 chandransh 13517 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13518 
      oprot.writeBool(self.success)
13519 
      oprot.writeFieldEnd()
3431 rajveer 13520 
    if self.scex is not None:
575 chandransh 13521 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13522 
      self.scex.write(oprot)
13523 
      oprot.writeFieldEnd()
13524 
    oprot.writeFieldStop()
13525 
    oprot.writeStructEnd()
13526 
 
3431 rajveer 13527 
  def validate(self):
13528 
    return
13529 
 
13530 
 
575 chandransh 13531 
  def __repr__(self):
13532 
    L = ['%s=%r' % (key, value)
13533 
      for key, value in self.__dict__.iteritems()]
13534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13535 
 
13536 
  def __eq__(self, other):
13537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13538 
 
13539 
  def __ne__(self, other):
13540 
    return not (self == other)
13541 
 
690 chandransh 13542 
class resetCart_args:
559 chandransh 13543 
  """
13544 
  Attributes:
690 chandransh 13545 
   - cartId
13546 
   - items
559 chandransh 13547 
  """
13548 
 
13549 
  thrift_spec = (
13550 
    None, # 0
690 chandransh 13551 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13552 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13553 
  )
13554 
 
690 chandransh 13555 
  def __init__(self, cartId=None, items=None,):
13556 
    self.cartId = cartId
13557 
    self.items = items
559 chandransh 13558 
 
13559 
  def read(self, iprot):
13560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13562 
      return
13563 
    iprot.readStructBegin()
13564 
    while True:
13565 
      (fname, ftype, fid) = iprot.readFieldBegin()
13566 
      if ftype == TType.STOP:
13567 
        break
13568 
      if fid == 1:
13569 
        if ftype == TType.I64:
690 chandransh 13570 
          self.cartId = iprot.readI64();
559 chandransh 13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      elif fid == 2:
690 chandransh 13574 
        if ftype == TType.MAP:
13575 
          self.items = {}
11980 amit.gupta 13576 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13577 
          for _i185 in xrange(_size181):
13578 
            _key186 = iprot.readI64();
13579 
            _val187 = iprot.readDouble();
13580 
            self.items[_key186] = _val187
690 chandransh 13581 
          iprot.readMapEnd()
559 chandransh 13582 
        else:
13583 
          iprot.skip(ftype)
13584 
      else:
13585 
        iprot.skip(ftype)
13586 
      iprot.readFieldEnd()
13587 
    iprot.readStructEnd()
13588 
 
13589 
  def write(self, oprot):
13590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13592 
      return
690 chandransh 13593 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13594 
    if self.cartId is not None:
690 chandransh 13595 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13596 
      oprot.writeI64(self.cartId)
94 ashish 13597 
      oprot.writeFieldEnd()
3431 rajveer 13598 
    if self.items is not None:
690 chandransh 13599 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13600 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13601 
      for kiter188,viter189 in self.items.items():
13602 
        oprot.writeI64(kiter188)
13603 
        oprot.writeDouble(viter189)
690 chandransh 13604 
      oprot.writeMapEnd()
559 chandransh 13605 
      oprot.writeFieldEnd()
94 ashish 13606 
    oprot.writeFieldStop()
13607 
    oprot.writeStructEnd()
13608 
 
3431 rajveer 13609 
  def validate(self):
13610 
    return
13611 
 
13612 
 
94 ashish 13613 
  def __repr__(self):
13614 
    L = ['%s=%r' % (key, value)
13615 
      for key, value in self.__dict__.iteritems()]
13616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13617 
 
13618 
  def __eq__(self, other):
13619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13620 
 
13621 
  def __ne__(self, other):
13622 
    return not (self == other)
13623 
 
690 chandransh 13624 
class resetCart_result:
13625 
  """
13626 
  Attributes:
13627 
   - success
13628 
   - scex
13629 
  """
559 chandransh 13630 
 
13631 
  thrift_spec = (
690 chandransh 13632 
    (0, TType.BOOL, 'success', None, None, ), # 0
13633 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13634 
  )
13635 
 
690 chandransh 13636 
  def __init__(self, success=None, scex=None,):
13637 
    self.success = success
13638 
    self.scex = scex
13639 
 
559 chandransh 13640 
  def read(self, iprot):
13641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13643 
      return
13644 
    iprot.readStructBegin()
13645 
    while True:
13646 
      (fname, ftype, fid) = iprot.readFieldBegin()
13647 
      if ftype == TType.STOP:
13648 
        break
690 chandransh 13649 
      if fid == 0:
13650 
        if ftype == TType.BOOL:
13651 
          self.success = iprot.readBool();
13652 
        else:
13653 
          iprot.skip(ftype)
13654 
      elif fid == 1:
13655 
        if ftype == TType.STRUCT:
13656 
          self.scex = ShoppingCartException()
13657 
          self.scex.read(iprot)
13658 
        else:
13659 
          iprot.skip(ftype)
559 chandransh 13660 
      else:
13661 
        iprot.skip(ftype)
13662 
      iprot.readFieldEnd()
13663 
    iprot.readStructEnd()
13664 
 
13665 
  def write(self, oprot):
13666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13668 
      return
690 chandransh 13669 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13670 
    if self.success is not None:
690 chandransh 13671 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13672 
      oprot.writeBool(self.success)
13673 
      oprot.writeFieldEnd()
3431 rajveer 13674 
    if self.scex is not None:
690 chandransh 13675 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13676 
      self.scex.write(oprot)
13677 
      oprot.writeFieldEnd()
559 chandransh 13678 
    oprot.writeFieldStop()
13679 
    oprot.writeStructEnd()
13680 
 
3431 rajveer 13681 
  def validate(self):
13682 
    return
13683 
 
13684 
 
559 chandransh 13685 
  def __repr__(self):
13686 
    L = ['%s=%r' % (key, value)
13687 
      for key, value in self.__dict__.iteritems()]
13688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13689 
 
13690 
  def __eq__(self, other):
13691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13692 
 
13693 
  def __ne__(self, other):
13694 
    return not (self == other)
13695 
 
2981 rajveer 13696 
class getUserCount_args:
94 ashish 13697 
  """
13698 
  Attributes:
2981 rajveer 13699 
   - userType
559 chandransh 13700 
  """
13701 
 
13702 
  thrift_spec = (
13703 
    None, # 0
2981 rajveer 13704 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13705 
  )
13706 
 
2981 rajveer 13707 
  def __init__(self, userType=None,):
13708 
    self.userType = userType
559 chandransh 13709 
 
13710 
  def read(self, iprot):
13711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13713 
      return
13714 
    iprot.readStructBegin()
13715 
    while True:
13716 
      (fname, ftype, fid) = iprot.readFieldBegin()
13717 
      if ftype == TType.STOP:
13718 
        break
13719 
      if fid == 1:
2981 rajveer 13720 
        if ftype == TType.I32:
13721 
          self.userType = iprot.readI32();
559 chandransh 13722 
        else:
13723 
          iprot.skip(ftype)
13724 
      else:
13725 
        iprot.skip(ftype)
13726 
      iprot.readFieldEnd()
13727 
    iprot.readStructEnd()
13728 
 
13729 
  def write(self, oprot):
13730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13732 
      return
2981 rajveer 13733 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13734 
    if self.userType is not None:
2981 rajveer 13735 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13736 
      oprot.writeI32(self.userType)
559 chandransh 13737 
      oprot.writeFieldEnd()
13738 
    oprot.writeFieldStop()
13739 
    oprot.writeStructEnd()
13740 
 
3431 rajveer 13741 
  def validate(self):
13742 
    return
13743 
 
13744 
 
559 chandransh 13745 
  def __repr__(self):
13746 
    L = ['%s=%r' % (key, value)
13747 
      for key, value in self.__dict__.iteritems()]
13748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13749 
 
13750 
  def __eq__(self, other):
13751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13752 
 
13753 
  def __ne__(self, other):
13754 
    return not (self == other)
13755 
 
2981 rajveer 13756 
class getUserCount_result:
94 ashish 13757 
  """
13758 
  Attributes:
13759 
   - success
13760 
  """
13761 
 
13762 
  thrift_spec = (
2981 rajveer 13763 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13764 
  )
13765 
 
2981 rajveer 13766 
  def __init__(self, success=None,):
94 ashish 13767 
    self.success = success
13768 
 
13769 
  def read(self, iprot):
13770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13772 
      return
13773 
    iprot.readStructBegin()
13774 
    while True:
13775 
      (fname, ftype, fid) = iprot.readFieldBegin()
13776 
      if ftype == TType.STOP:
13777 
        break
13778 
      if fid == 0:
2981 rajveer 13779 
        if ftype == TType.I64:
13780 
          self.success = iprot.readI64();
94 ashish 13781 
        else:
13782 
          iprot.skip(ftype)
13783 
      else:
13784 
        iprot.skip(ftype)
13785 
      iprot.readFieldEnd()
13786 
    iprot.readStructEnd()
13787 
 
13788 
  def write(self, oprot):
13789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13791 
      return
2981 rajveer 13792 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13793 
    if self.success is not None:
2981 rajveer 13794 
      oprot.writeFieldBegin('success', TType.I64, 0)
13795 
      oprot.writeI64(self.success)
94 ashish 13796 
      oprot.writeFieldEnd()
13797 
    oprot.writeFieldStop()
13798 
    oprot.writeStructEnd()
13799 
 
3431 rajveer 13800 
  def validate(self):
13801 
    return
13802 
 
13803 
 
94 ashish 13804 
  def __repr__(self):
13805 
    L = ['%s=%r' % (key, value)
13806 
      for key, value in self.__dict__.iteritems()]
13807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13808 
 
13809 
  def __eq__(self, other):
13810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13811 
 
13812 
  def __ne__(self, other):
13813 
    return not (self == other)
13814 
 
2981 rajveer 13815 
class getAllUsers_args:
94 ashish 13816 
  """
13817 
  Attributes:
2981 rajveer 13818 
   - userType
13819 
   - startDate
13820 
   - endDate
94 ashish 13821 
  """
13822 
 
13823 
  thrift_spec = (
13824 
    None, # 0
2981 rajveer 13825 
    (1, TType.I32, 'userType', None, None, ), # 1
13826 
    (2, TType.I64, 'startDate', None, None, ), # 2
13827 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13828 
  )
13829 
 
2981 rajveer 13830 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13831 
    self.userType = userType
13832 
    self.startDate = startDate
13833 
    self.endDate = endDate
94 ashish 13834 
 
13835 
  def read(self, iprot):
13836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13838 
      return
13839 
    iprot.readStructBegin()
13840 
    while True:
13841 
      (fname, ftype, fid) = iprot.readFieldBegin()
13842 
      if ftype == TType.STOP:
13843 
        break
13844 
      if fid == 1:
2981 rajveer 13845 
        if ftype == TType.I32:
13846 
          self.userType = iprot.readI32();
94 ashish 13847 
        else:
13848 
          iprot.skip(ftype)
13849 
      elif fid == 2:
559 chandransh 13850 
        if ftype == TType.I64:
2981 rajveer 13851 
          self.startDate = iprot.readI64();
94 ashish 13852 
        else:
13853 
          iprot.skip(ftype)
2981 rajveer 13854 
      elif fid == 3:
13855 
        if ftype == TType.I64:
13856 
          self.endDate = iprot.readI64();
13857 
        else:
13858 
          iprot.skip(ftype)
94 ashish 13859 
      else:
13860 
        iprot.skip(ftype)
13861 
      iprot.readFieldEnd()
13862 
    iprot.readStructEnd()
13863 
 
13864 
  def write(self, oprot):
13865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13867 
      return
2981 rajveer 13868 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13869 
    if self.userType is not None:
2981 rajveer 13870 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13871 
      oprot.writeI32(self.userType)
94 ashish 13872 
      oprot.writeFieldEnd()
3431 rajveer 13873 
    if self.startDate is not None:
2981 rajveer 13874 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13875 
      oprot.writeI64(self.startDate)
94 ashish 13876 
      oprot.writeFieldEnd()
3431 rajveer 13877 
    if self.endDate is not None:
2981 rajveer 13878 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13879 
      oprot.writeI64(self.endDate)
13880 
      oprot.writeFieldEnd()
94 ashish 13881 
    oprot.writeFieldStop()
13882 
    oprot.writeStructEnd()
13883 
 
3431 rajveer 13884 
  def validate(self):
13885 
    return
13886 
 
13887 
 
94 ashish 13888 
  def __repr__(self):
13889 
    L = ['%s=%r' % (key, value)
13890 
      for key, value in self.__dict__.iteritems()]
13891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13892 
 
13893 
  def __eq__(self, other):
13894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13895 
 
13896 
  def __ne__(self, other):
13897 
    return not (self == other)
13898 
 
2981 rajveer 13899 
class getAllUsers_result:
94 ashish 13900 
  """
13901 
  Attributes:
13902 
   - success
13903 
  """
13904 
 
13905 
  thrift_spec = (
2981 rajveer 13906 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13907 
  )
13908 
 
2981 rajveer 13909 
  def __init__(self, success=None,):
94 ashish 13910 
    self.success = success
13911 
 
13912 
  def read(self, iprot):
13913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13915 
      return
13916 
    iprot.readStructBegin()
13917 
    while True:
13918 
      (fname, ftype, fid) = iprot.readFieldBegin()
13919 
      if ftype == TType.STOP:
13920 
        break
13921 
      if fid == 0:
2981 rajveer 13922 
        if ftype == TType.LIST:
13923 
          self.success = []
11980 amit.gupta 13924 
          (_etype193, _size190) = iprot.readListBegin()
13925 
          for _i194 in xrange(_size190):
13926 
            _elem195 = User()
13927 
            _elem195.read(iprot)
13928 
            self.success.append(_elem195)
2981 rajveer 13929 
          iprot.readListEnd()
94 ashish 13930 
        else:
13931 
          iprot.skip(ftype)
13932 
      else:
13933 
        iprot.skip(ftype)
13934 
      iprot.readFieldEnd()
13935 
    iprot.readStructEnd()
13936 
 
13937 
  def write(self, oprot):
13938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13940 
      return
2981 rajveer 13941 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13942 
    if self.success is not None:
2981 rajveer 13943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13945 
      for iter196 in self.success:
13946 
        iter196.write(oprot)
2981 rajveer 13947 
      oprot.writeListEnd()
94 ashish 13948 
      oprot.writeFieldEnd()
13949 
    oprot.writeFieldStop()
13950 
    oprot.writeStructEnd()
13951 
 
3431 rajveer 13952 
  def validate(self):
13953 
    return
13954 
 
13955 
 
94 ashish 13956 
  def __repr__(self):
13957 
    L = ['%s=%r' % (key, value)
13958 
      for key, value in self.__dict__.iteritems()]
13959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13960 
 
13961 
  def __eq__(self, other):
13962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13963 
 
13964 
  def __ne__(self, other):
13965 
    return not (self == other)
13966 
 
2981 rajveer 13967 
class getMyResearchItems_args:
559 chandransh 13968 
  """
13969 
  Attributes:
772 rajveer 13970 
   - userId
559 chandransh 13971 
  """
13972 
 
13973 
  thrift_spec = (
13974 
    None, # 0
772 rajveer 13975 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13976 
  )
13977 
 
772 rajveer 13978 
  def __init__(self, userId=None,):
13979 
    self.userId = userId
559 chandransh 13980 
 
13981 
  def read(self, iprot):
13982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13984 
      return
13985 
    iprot.readStructBegin()
13986 
    while True:
13987 
      (fname, ftype, fid) = iprot.readFieldBegin()
13988 
      if ftype == TType.STOP:
13989 
        break
13990 
      if fid == 1:
13991 
        if ftype == TType.I64:
772 rajveer 13992 
          self.userId = iprot.readI64();
559 chandransh 13993 
        else:
13994 
          iprot.skip(ftype)
13995 
      else:
13996 
        iprot.skip(ftype)
13997 
      iprot.readFieldEnd()
13998 
    iprot.readStructEnd()
13999 
 
14000 
  def write(self, oprot):
14001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14003 
      return
2981 rajveer 14004 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 14005 
    if self.userId is not None:
772 rajveer 14006 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14007 
      oprot.writeI64(self.userId)
559 chandransh 14008 
      oprot.writeFieldEnd()
14009 
    oprot.writeFieldStop()
14010 
    oprot.writeStructEnd()
14011 
 
3431 rajveer 14012 
  def validate(self):
14013 
    return
14014 
 
14015 
 
559 chandransh 14016 
  def __repr__(self):
14017 
    L = ['%s=%r' % (key, value)
14018 
      for key, value in self.__dict__.iteritems()]
14019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14020 
 
14021 
  def __eq__(self, other):
14022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14023 
 
14024 
  def __ne__(self, other):
14025 
    return not (self == other)
14026 
 
2981 rajveer 14027 
class getMyResearchItems_result:
559 chandransh 14028 
  """
14029 
  Attributes:
130 ashish 14030 
   - success
559 chandransh 14031 
   - scx
130 ashish 14032 
  """
14033 
 
14034 
  thrift_spec = (
2981 rajveer 14035 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 14036 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 14037 
  )
14038 
 
559 chandransh 14039 
  def __init__(self, success=None, scx=None,):
130 ashish 14040 
    self.success = success
559 chandransh 14041 
    self.scx = scx
130 ashish 14042 
 
14043 
  def read(self, iprot):
14044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14046 
      return
14047 
    iprot.readStructBegin()
14048 
    while True:
14049 
      (fname, ftype, fid) = iprot.readFieldBegin()
14050 
      if ftype == TType.STOP:
14051 
        break
14052 
      if fid == 0:
2981 rajveer 14053 
        if ftype == TType.LIST:
14054 
          self.success = []
11980 amit.gupta 14055 
          (_etype200, _size197) = iprot.readListBegin()
14056 
          for _i201 in xrange(_size197):
14057 
            _elem202 = iprot.readI64();
14058 
            self.success.append(_elem202)
2981 rajveer 14059 
          iprot.readListEnd()
130 ashish 14060 
        else:
14061 
          iprot.skip(ftype)
14062 
      elif fid == 1:
14063 
        if ftype == TType.STRUCT:
559 chandransh 14064 
          self.scx = WidgetException()
14065 
          self.scx.read(iprot)
130 ashish 14066 
        else:
14067 
          iprot.skip(ftype)
14068 
      else:
14069 
        iprot.skip(ftype)
14070 
      iprot.readFieldEnd()
14071 
    iprot.readStructEnd()
14072 
 
14073 
  def write(self, oprot):
14074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14076 
      return
2981 rajveer 14077 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 14078 
    if self.success is not None:
2981 rajveer 14079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14080 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14081 
      for iter203 in self.success:
14082 
        oprot.writeI64(iter203)
2981 rajveer 14083 
      oprot.writeListEnd()
130 ashish 14084 
      oprot.writeFieldEnd()
3431 rajveer 14085 
    if self.scx is not None:
559 chandransh 14086 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14087 
      self.scx.write(oprot)
130 ashish 14088 
      oprot.writeFieldEnd()
14089 
    oprot.writeFieldStop()
14090 
    oprot.writeStructEnd()
14091 
 
3431 rajveer 14092 
  def validate(self):
14093 
    return
14094 
 
14095 
 
130 ashish 14096 
  def __repr__(self):
14097 
    L = ['%s=%r' % (key, value)
14098 
      for key, value in self.__dict__.iteritems()]
14099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14100 
 
14101 
  def __eq__(self, other):
14102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14103 
 
14104 
  def __ne__(self, other):
14105 
    return not (self == other)
14106 
 
2981 rajveer 14107 
class updateMyResearch_args:
130 ashish 14108 
  """
14109 
  Attributes:
2981 rajveer 14110 
   - userId
14111 
   - itemId
130 ashish 14112 
  """
14113 
 
14114 
  thrift_spec = (
14115 
    None, # 0
2981 rajveer 14116 
    (1, TType.I64, 'userId', None, None, ), # 1
14117 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 14118 
  )
14119 
 
2981 rajveer 14120 
  def __init__(self, userId=None, itemId=None,):
14121 
    self.userId = userId
14122 
    self.itemId = itemId
130 ashish 14123 
 
14124 
  def read(self, iprot):
14125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14127 
      return
14128 
    iprot.readStructBegin()
14129 
    while True:
14130 
      (fname, ftype, fid) = iprot.readFieldBegin()
14131 
      if ftype == TType.STOP:
14132 
        break
14133 
      if fid == 1:
559 chandransh 14134 
        if ftype == TType.I64:
2981 rajveer 14135 
          self.userId = iprot.readI64();
130 ashish 14136 
        else:
14137 
          iprot.skip(ftype)
14138 
      elif fid == 2:
559 chandransh 14139 
        if ftype == TType.I64:
2981 rajveer 14140 
          self.itemId = iprot.readI64();
559 chandransh 14141 
        else:
14142 
          iprot.skip(ftype)
130 ashish 14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
2981 rajveer 14152 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 14153 
    if self.userId is not None:
2981 rajveer 14154 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14155 
      oprot.writeI64(self.userId)
130 ashish 14156 
      oprot.writeFieldEnd()
3431 rajveer 14157 
    if self.itemId is not None:
2981 rajveer 14158 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14159 
      oprot.writeI64(self.itemId)
130 ashish 14160 
      oprot.writeFieldEnd()
14161 
    oprot.writeFieldStop()
14162 
    oprot.writeStructEnd()
14163 
 
3431 rajveer 14164 
  def validate(self):
14165 
    return
14166 
 
14167 
 
130 ashish 14168 
  def __repr__(self):
14169 
    L = ['%s=%r' % (key, value)
14170 
      for key, value in self.__dict__.iteritems()]
14171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14172 
 
14173 
  def __eq__(self, other):
14174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14175 
 
14176 
  def __ne__(self, other):
14177 
    return not (self == other)
14178 
 
2981 rajveer 14179 
class updateMyResearch_result:
14180 
  """
14181 
  Attributes:
14182 
   - success
14183 
   - scx
14184 
  """
559 chandransh 14185 
 
14186 
  thrift_spec = (
2981 rajveer 14187 
    (0, TType.BOOL, 'success', None, None, ), # 0
14188 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 14189 
  )
14190 
 
2981 rajveer 14191 
  def __init__(self, success=None, scx=None,):
14192 
    self.success = success
14193 
    self.scx = scx
14194 
 
559 chandransh 14195 
  def read(self, iprot):
14196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14198 
      return
14199 
    iprot.readStructBegin()
14200 
    while True:
14201 
      (fname, ftype, fid) = iprot.readFieldBegin()
14202 
      if ftype == TType.STOP:
14203 
        break
2981 rajveer 14204 
      if fid == 0:
14205 
        if ftype == TType.BOOL:
14206 
          self.success = iprot.readBool();
14207 
        else:
14208 
          iprot.skip(ftype)
14209 
      elif fid == 1:
14210 
        if ftype == TType.STRUCT:
14211 
          self.scx = WidgetException()
14212 
          self.scx.read(iprot)
14213 
        else:
14214 
          iprot.skip(ftype)
559 chandransh 14215 
      else:
14216 
        iprot.skip(ftype)
14217 
      iprot.readFieldEnd()
14218 
    iprot.readStructEnd()
14219 
 
14220 
  def write(self, oprot):
14221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14223 
      return
2981 rajveer 14224 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 14225 
    if self.success is not None:
2981 rajveer 14226 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14227 
      oprot.writeBool(self.success)
14228 
      oprot.writeFieldEnd()
3431 rajveer 14229 
    if self.scx is not None:
2981 rajveer 14230 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14231 
      self.scx.write(oprot)
14232 
      oprot.writeFieldEnd()
559 chandransh 14233 
    oprot.writeFieldStop()
14234 
    oprot.writeStructEnd()
14235 
 
3431 rajveer 14236 
  def validate(self):
14237 
    return
14238 
 
14239 
 
559 chandransh 14240 
  def __repr__(self):
14241 
    L = ['%s=%r' % (key, value)
14242 
      for key, value in self.__dict__.iteritems()]
14243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14244 
 
14245 
  def __eq__(self, other):
14246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14247 
 
14248 
  def __ne__(self, other):
14249 
    return not (self == other)
14250 
 
2981 rajveer 14251 
class deleteItemFromMyResearch_args:
1596 ankur.sing 14252 
  """
14253 
  Attributes:
2981 rajveer 14254 
   - userId
14255 
   - itemId
1596 ankur.sing 14256 
  """
559 chandransh 14257 
 
1596 ankur.sing 14258 
  thrift_spec = (
14259 
    None, # 0
2981 rajveer 14260 
    (1, TType.I64, 'userId', None, None, ), # 1
14261 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 14262 
  )
14263 
 
2981 rajveer 14264 
  def __init__(self, userId=None, itemId=None,):
14265 
    self.userId = userId
14266 
    self.itemId = itemId
1596 ankur.sing 14267 
 
14268 
  def read(self, iprot):
14269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14271 
      return
14272 
    iprot.readStructBegin()
14273 
    while True:
14274 
      (fname, ftype, fid) = iprot.readFieldBegin()
14275 
      if ftype == TType.STOP:
14276 
        break
14277 
      if fid == 1:
2981 rajveer 14278 
        if ftype == TType.I64:
14279 
          self.userId = iprot.readI64();
1596 ankur.sing 14280 
        else:
14281 
          iprot.skip(ftype)
2981 rajveer 14282 
      elif fid == 2:
14283 
        if ftype == TType.I64:
14284 
          self.itemId = iprot.readI64();
14285 
        else:
14286 
          iprot.skip(ftype)
1596 ankur.sing 14287 
      else:
14288 
        iprot.skip(ftype)
14289 
      iprot.readFieldEnd()
14290 
    iprot.readStructEnd()
14291 
 
14292 
  def write(self, oprot):
14293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14295 
      return
2981 rajveer 14296 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 14297 
    if self.userId is not None:
2981 rajveer 14298 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14299 
      oprot.writeI64(self.userId)
1596 ankur.sing 14300 
      oprot.writeFieldEnd()
3431 rajveer 14301 
    if self.itemId is not None:
2981 rajveer 14302 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14303 
      oprot.writeI64(self.itemId)
14304 
      oprot.writeFieldEnd()
1596 ankur.sing 14305 
    oprot.writeFieldStop()
14306 
    oprot.writeStructEnd()
14307 
 
3431 rajveer 14308 
  def validate(self):
14309 
    return
14310 
 
14311 
 
1596 ankur.sing 14312 
  def __repr__(self):
14313 
    L = ['%s=%r' % (key, value)
14314 
      for key, value in self.__dict__.iteritems()]
14315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14316 
 
14317 
  def __eq__(self, other):
14318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14319 
 
14320 
  def __ne__(self, other):
14321 
    return not (self == other)
14322 
 
2981 rajveer 14323 
class deleteItemFromMyResearch_result:
1596 ankur.sing 14324 
  """
14325 
  Attributes:
2981 rajveer 14326 
   - scx
1596 ankur.sing 14327 
  """
14328 
 
14329 
  thrift_spec = (
2981 rajveer 14330 
    None, # 0
14331 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 14332 
  )
14333 
 
2981 rajveer 14334 
  def __init__(self, scx=None,):
14335 
    self.scx = scx
1596 ankur.sing 14336 
 
14337 
  def read(self, iprot):
14338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14340 
      return
14341 
    iprot.readStructBegin()
14342 
    while True:
14343 
      (fname, ftype, fid) = iprot.readFieldBegin()
14344 
      if ftype == TType.STOP:
14345 
        break
2981 rajveer 14346 
      if fid == 1:
14347 
        if ftype == TType.STRUCT:
14348 
          self.scx = WidgetException()
14349 
          self.scx.read(iprot)
1596 ankur.sing 14350 
        else:
14351 
          iprot.skip(ftype)
14352 
      else:
14353 
        iprot.skip(ftype)
14354 
      iprot.readFieldEnd()
14355 
    iprot.readStructEnd()
14356 
 
14357 
  def write(self, oprot):
14358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14360 
      return
2981 rajveer 14361 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 14362 
    if self.scx is not None:
2981 rajveer 14363 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14364 
      self.scx.write(oprot)
1596 ankur.sing 14365 
      oprot.writeFieldEnd()
14366 
    oprot.writeFieldStop()
14367 
    oprot.writeStructEnd()
14368 
 
3431 rajveer 14369 
  def validate(self):
14370 
    return
14371 
 
14372 
 
1596 ankur.sing 14373 
  def __repr__(self):
14374 
    L = ['%s=%r' % (key, value)
14375 
      for key, value in self.__dict__.iteritems()]
14376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14377 
 
14378 
  def __eq__(self, other):
14379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14380 
 
14381 
  def __ne__(self, other):
14382 
    return not (self == other)
14383 
 
2981 rajveer 14384 
class getBrowseHistoryItems_args:
1673 ankur.sing 14385 
  """
14386 
  Attributes:
2981 rajveer 14387 
   - userId
1673 ankur.sing 14388 
  """
1596 ankur.sing 14389 
 
1673 ankur.sing 14390 
  thrift_spec = (
14391 
    None, # 0
2981 rajveer 14392 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 14393 
  )
14394 
 
2981 rajveer 14395 
  def __init__(self, userId=None,):
14396 
    self.userId = userId
1673 ankur.sing 14397 
 
14398 
  def read(self, iprot):
14399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14401 
      return
14402 
    iprot.readStructBegin()
14403 
    while True:
14404 
      (fname, ftype, fid) = iprot.readFieldBegin()
14405 
      if ftype == TType.STOP:
14406 
        break
14407 
      if fid == 1:
1891 ankur.sing 14408 
        if ftype == TType.I64:
2981 rajveer 14409 
          self.userId = iprot.readI64();
1891 ankur.sing 14410 
        else:
14411 
          iprot.skip(ftype)
1673 ankur.sing 14412 
      else:
14413 
        iprot.skip(ftype)
14414 
      iprot.readFieldEnd()
14415 
    iprot.readStructEnd()
14416 
 
14417 
  def write(self, oprot):
14418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14420 
      return
2981 rajveer 14421 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 14422 
    if self.userId is not None:
2981 rajveer 14423 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14424 
      oprot.writeI64(self.userId)
1673 ankur.sing 14425 
      oprot.writeFieldEnd()
14426 
    oprot.writeFieldStop()
14427 
    oprot.writeStructEnd()
14428 
 
3431 rajveer 14429 
  def validate(self):
14430 
    return
14431 
 
14432 
 
1673 ankur.sing 14433 
  def __repr__(self):
14434 
    L = ['%s=%r' % (key, value)
14435 
      for key, value in self.__dict__.iteritems()]
14436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14437 
 
14438 
  def __eq__(self, other):
14439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14440 
 
14441 
  def __ne__(self, other):
14442 
    return not (self == other)
14443 
 
2981 rajveer 14444 
class getBrowseHistoryItems_result:
1673 ankur.sing 14445 
  """
14446 
  Attributes:
14447 
   - success
2981 rajveer 14448 
   - scx
1673 ankur.sing 14449 
  """
14450 
 
14451 
  thrift_spec = (
2981 rajveer 14452 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14453 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 14454 
  )
14455 
 
2981 rajveer 14456 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 14457 
    self.success = success
2981 rajveer 14458 
    self.scx = scx
1673 ankur.sing 14459 
 
14460 
  def read(self, iprot):
14461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14463 
      return
14464 
    iprot.readStructBegin()
14465 
    while True:
14466 
      (fname, ftype, fid) = iprot.readFieldBegin()
14467 
      if ftype == TType.STOP:
14468 
        break
14469 
      if fid == 0:
14470 
        if ftype == TType.LIST:
14471 
          self.success = []
11980 amit.gupta 14472 
          (_etype207, _size204) = iprot.readListBegin()
14473 
          for _i208 in xrange(_size204):
14474 
            _elem209 = iprot.readI64();
14475 
            self.success.append(_elem209)
1673 ankur.sing 14476 
          iprot.readListEnd()
14477 
        else:
14478 
          iprot.skip(ftype)
2981 rajveer 14479 
      elif fid == 1:
14480 
        if ftype == TType.STRUCT:
14481 
          self.scx = WidgetException()
14482 
          self.scx.read(iprot)
14483 
        else:
14484 
          iprot.skip(ftype)
1673 ankur.sing 14485 
      else:
14486 
        iprot.skip(ftype)
14487 
      iprot.readFieldEnd()
14488 
    iprot.readStructEnd()
14489 
 
14490 
  def write(self, oprot):
14491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14493 
      return
2981 rajveer 14494 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 14495 
    if self.success is not None:
1673 ankur.sing 14496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 14497 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14498 
      for iter210 in self.success:
14499 
        oprot.writeI64(iter210)
1673 ankur.sing 14500 
      oprot.writeListEnd()
14501 
      oprot.writeFieldEnd()
3431 rajveer 14502 
    if self.scx is not None:
2981 rajveer 14503 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14504 
      self.scx.write(oprot)
2642 varun.gupt 14505 
      oprot.writeFieldEnd()
14506 
    oprot.writeFieldStop()
14507 
    oprot.writeStructEnd()
14508 
 
3431 rajveer 14509 
  def validate(self):
14510 
    return
14511 
 
14512 
 
2642 varun.gupt 14513 
  def __repr__(self):
14514 
    L = ['%s=%r' % (key, value)
14515 
      for key, value in self.__dict__.iteritems()]
14516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14517 
 
14518 
  def __eq__(self, other):
14519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14520 
 
14521 
  def __ne__(self, other):
14522 
    return not (self == other)
14523 
 
2981 rajveer 14524 
class updateBrowseHistory_args:
2642 varun.gupt 14525 
  """
14526 
  Attributes:
2981 rajveer 14527 
   - userId
14528 
   - itemId
2642 varun.gupt 14529 
  """
14530 
 
14531 
  thrift_spec = (
14532 
    None, # 0
2981 rajveer 14533 
    (1, TType.I64, 'userId', None, None, ), # 1
14534 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 14535 
  )
14536 
 
2981 rajveer 14537 
  def __init__(self, userId=None, itemId=None,):
14538 
    self.userId = userId
14539 
    self.itemId = itemId
2642 varun.gupt 14540 
 
14541 
  def read(self, iprot):
14542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14544 
      return
14545 
    iprot.readStructBegin()
14546 
    while True:
14547 
      (fname, ftype, fid) = iprot.readFieldBegin()
14548 
      if ftype == TType.STOP:
14549 
        break
14550 
      if fid == 1:
14551 
        if ftype == TType.I64:
2981 rajveer 14552 
          self.userId = iprot.readI64();
2642 varun.gupt 14553 
        else:
14554 
          iprot.skip(ftype)
14555 
      elif fid == 2:
14556 
        if ftype == TType.I64:
2981 rajveer 14557 
          self.itemId = iprot.readI64();
2642 varun.gupt 14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      else:
14561 
        iprot.skip(ftype)
14562 
      iprot.readFieldEnd()
14563 
    iprot.readStructEnd()
14564 
 
14565 
  def write(self, oprot):
14566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14568 
      return
2981 rajveer 14569 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14570 
    if self.userId is not None:
2981 rajveer 14571 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14572 
      oprot.writeI64(self.userId)
2642 varun.gupt 14573 
      oprot.writeFieldEnd()
3431 rajveer 14574 
    if self.itemId is not None:
2981 rajveer 14575 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14576 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14577 
      oprot.writeFieldEnd()
14578 
    oprot.writeFieldStop()
14579 
    oprot.writeStructEnd()
14580 
 
3431 rajveer 14581 
  def validate(self):
14582 
    return
14583 
 
14584 
 
2642 varun.gupt 14585 
  def __repr__(self):
14586 
    L = ['%s=%r' % (key, value)
14587 
      for key, value in self.__dict__.iteritems()]
14588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14589 
 
14590 
  def __eq__(self, other):
14591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14592 
 
14593 
  def __ne__(self, other):
14594 
    return not (self == other)
14595 
 
2981 rajveer 14596 
class updateBrowseHistory_result:
2642 varun.gupt 14597 
 
14598 
  thrift_spec = (
14599 
  )
14600 
 
14601 
  def read(self, iprot):
14602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14604 
      return
14605 
    iprot.readStructBegin()
14606 
    while True:
14607 
      (fname, ftype, fid) = iprot.readFieldBegin()
14608 
      if ftype == TType.STOP:
14609 
        break
14610 
      else:
14611 
        iprot.skip(ftype)
14612 
      iprot.readFieldEnd()
14613 
    iprot.readStructEnd()
14614 
 
14615 
  def write(self, oprot):
14616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14618 
      return
2981 rajveer 14619 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14620 
    oprot.writeFieldStop()
14621 
    oprot.writeStructEnd()
14622 
 
3431 rajveer 14623 
  def validate(self):
14624 
    return
14625 
 
14626 
 
2642 varun.gupt 14627 
  def __repr__(self):
14628 
    L = ['%s=%r' % (key, value)
14629 
      for key, value in self.__dict__.iteritems()]
14630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14631 
 
14632 
  def __eq__(self, other):
14633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14634 
 
14635 
  def __ne__(self, other):
14636 
    return not (self == other)
14637 
 
3385 varun.gupt 14638 
class getCartsWithCouponCount_args:
14639 
  """
14640 
  Attributes:
14641 
   - couponCode
14642 
  """
2642 varun.gupt 14643 
 
3385 varun.gupt 14644 
  thrift_spec = (
14645 
    None, # 0
14646 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14647 
  )
14648 
 
14649 
  def __init__(self, couponCode=None,):
14650 
    self.couponCode = couponCode
14651 
 
14652 
  def read(self, iprot):
14653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14655 
      return
14656 
    iprot.readStructBegin()
14657 
    while True:
14658 
      (fname, ftype, fid) = iprot.readFieldBegin()
14659 
      if ftype == TType.STOP:
14660 
        break
14661 
      if fid == 1:
14662 
        if ftype == TType.STRING:
14663 
          self.couponCode = iprot.readString();
14664 
        else:
14665 
          iprot.skip(ftype)
14666 
      else:
14667 
        iprot.skip(ftype)
14668 
      iprot.readFieldEnd()
14669 
    iprot.readStructEnd()
14670 
 
14671 
  def write(self, oprot):
14672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14674 
      return
14675 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14676 
    if self.couponCode is not None:
3385 varun.gupt 14677 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14678 
      oprot.writeString(self.couponCode)
14679 
      oprot.writeFieldEnd()
14680 
    oprot.writeFieldStop()
14681 
    oprot.writeStructEnd()
14682 
 
3431 rajveer 14683 
  def validate(self):
14684 
    return
14685 
 
14686 
 
3385 varun.gupt 14687 
  def __repr__(self):
14688 
    L = ['%s=%r' % (key, value)
14689 
      for key, value in self.__dict__.iteritems()]
14690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14691 
 
14692 
  def __eq__(self, other):
14693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14694 
 
14695 
  def __ne__(self, other):
14696 
    return not (self == other)
14697 
 
14698 
class getCartsWithCouponCount_result:
14699 
  """
14700 
  Attributes:
14701 
   - success
14702 
  """
14703 
 
14704 
  thrift_spec = (
14705 
    (0, TType.I64, 'success', None, None, ), # 0
14706 
  )
14707 
 
14708 
  def __init__(self, success=None,):
14709 
    self.success = success
14710 
 
14711 
  def read(self, iprot):
14712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14714 
      return
14715 
    iprot.readStructBegin()
14716 
    while True:
14717 
      (fname, ftype, fid) = iprot.readFieldBegin()
14718 
      if ftype == TType.STOP:
14719 
        break
14720 
      if fid == 0:
14721 
        if ftype == TType.I64:
14722 
          self.success = iprot.readI64();
14723 
        else:
14724 
          iprot.skip(ftype)
14725 
      else:
14726 
        iprot.skip(ftype)
14727 
      iprot.readFieldEnd()
14728 
    iprot.readStructEnd()
14729 
 
14730 
  def write(self, oprot):
14731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14733 
      return
14734 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14735 
    if self.success is not None:
3385 varun.gupt 14736 
      oprot.writeFieldBegin('success', TType.I64, 0)
14737 
      oprot.writeI64(self.success)
14738 
      oprot.writeFieldEnd()
14739 
    oprot.writeFieldStop()
14740 
    oprot.writeStructEnd()
14741 
 
3431 rajveer 14742 
  def validate(self):
14743 
    return
14744 
 
14745 
 
3385 varun.gupt 14746 
  def __repr__(self):
14747 
    L = ['%s=%r' % (key, value)
14748 
      for key, value in self.__dict__.iteritems()]
14749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14750 
 
14751 
  def __eq__(self, other):
14752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14753 
 
14754 
  def __ne__(self, other):
14755 
    return not (self == other)
3499 mandeep.dh 14756 
 
14757 
class increaseTrustLevel_args:
14758 
  """
14759 
  Attributes:
14760 
   - userId
14761 
   - trustLevelDelta
14762 
  """
14763 
 
14764 
  thrift_spec = (
14765 
    None, # 0
14766 
    (1, TType.I64, 'userId', None, None, ), # 1
14767 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14768 
  )
14769 
 
14770 
  def __init__(self, userId=None, trustLevelDelta=None,):
14771 
    self.userId = userId
14772 
    self.trustLevelDelta = trustLevelDelta
14773 
 
14774 
  def read(self, iprot):
14775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14777 
      return
14778 
    iprot.readStructBegin()
14779 
    while True:
14780 
      (fname, ftype, fid) = iprot.readFieldBegin()
14781 
      if ftype == TType.STOP:
14782 
        break
14783 
      if fid == 1:
14784 
        if ftype == TType.I64:
14785 
          self.userId = iprot.readI64();
14786 
        else:
14787 
          iprot.skip(ftype)
14788 
      elif fid == 2:
14789 
        if ftype == TType.DOUBLE:
14790 
          self.trustLevelDelta = iprot.readDouble();
14791 
        else:
14792 
          iprot.skip(ftype)
14793 
      else:
14794 
        iprot.skip(ftype)
14795 
      iprot.readFieldEnd()
14796 
    iprot.readStructEnd()
14797 
 
14798 
  def write(self, oprot):
14799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14801 
      return
14802 
    oprot.writeStructBegin('increaseTrustLevel_args')
14803 
    if self.userId is not None:
14804 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14805 
      oprot.writeI64(self.userId)
14806 
      oprot.writeFieldEnd()
14807 
    if self.trustLevelDelta is not None:
14808 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14809 
      oprot.writeDouble(self.trustLevelDelta)
14810 
      oprot.writeFieldEnd()
14811 
    oprot.writeFieldStop()
14812 
    oprot.writeStructEnd()
14813 
 
14814 
  def validate(self):
14815 
    return
14816 
 
14817 
 
14818 
  def __repr__(self):
14819 
    L = ['%s=%r' % (key, value)
14820 
      for key, value in self.__dict__.iteritems()]
14821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14822 
 
14823 
  def __eq__(self, other):
14824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14825 
 
14826 
  def __ne__(self, other):
14827 
    return not (self == other)
4668 varun.gupt 14828 
 
5407 amar.kumar 14829 
class getTrustLevel_args:
14830 
  """
14831 
  Attributes:
14832 
   - userId
14833 
  """
14834 
 
14835 
  thrift_spec = (
14836 
    None, # 0
14837 
    (1, TType.I64, 'userId', None, None, ), # 1
14838 
  )
14839 
 
14840 
  def __init__(self, userId=None,):
14841 
    self.userId = userId
14842 
 
14843 
  def read(self, iprot):
14844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14846 
      return
14847 
    iprot.readStructBegin()
14848 
    while True:
14849 
      (fname, ftype, fid) = iprot.readFieldBegin()
14850 
      if ftype == TType.STOP:
14851 
        break
14852 
      if fid == 1:
14853 
        if ftype == TType.I64:
14854 
          self.userId = iprot.readI64();
14855 
        else:
14856 
          iprot.skip(ftype)
14857 
      else:
14858 
        iprot.skip(ftype)
14859 
      iprot.readFieldEnd()
14860 
    iprot.readStructEnd()
14861 
 
14862 
  def write(self, oprot):
14863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14865 
      return
14866 
    oprot.writeStructBegin('getTrustLevel_args')
14867 
    if self.userId is not None:
14868 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14869 
      oprot.writeI64(self.userId)
14870 
      oprot.writeFieldEnd()
14871 
    oprot.writeFieldStop()
14872 
    oprot.writeStructEnd()
14873 
 
14874 
  def validate(self):
14875 
    return
14876 
 
14877 
 
14878 
  def __repr__(self):
14879 
    L = ['%s=%r' % (key, value)
14880 
      for key, value in self.__dict__.iteritems()]
14881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14882 
 
14883 
  def __eq__(self, other):
14884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14885 
 
14886 
  def __ne__(self, other):
14887 
    return not (self == other)
14888 
 
14889 
class getTrustLevel_result:
14890 
  """
14891 
  Attributes:
14892 
   - success
14893 
  """
14894 
 
14895 
  thrift_spec = (
14896 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14897 
  )
14898 
 
14899 
  def __init__(self, success=None,):
14900 
    self.success = success
14901 
 
14902 
  def read(self, iprot):
14903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14905 
      return
14906 
    iprot.readStructBegin()
14907 
    while True:
14908 
      (fname, ftype, fid) = iprot.readFieldBegin()
14909 
      if ftype == TType.STOP:
14910 
        break
14911 
      if fid == 0:
14912 
        if ftype == TType.DOUBLE:
14913 
          self.success = iprot.readDouble();
14914 
        else:
14915 
          iprot.skip(ftype)
14916 
      else:
14917 
        iprot.skip(ftype)
14918 
      iprot.readFieldEnd()
14919 
    iprot.readStructEnd()
14920 
 
14921 
  def write(self, oprot):
14922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14924 
      return
14925 
    oprot.writeStructBegin('getTrustLevel_result')
14926 
    if self.success is not None:
14927 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14928 
      oprot.writeDouble(self.success)
14929 
      oprot.writeFieldEnd()
14930 
    oprot.writeFieldStop()
14931 
    oprot.writeStructEnd()
14932 
 
14933 
  def validate(self):
14934 
    return
14935 
 
14936 
 
14937 
  def __repr__(self):
14938 
    L = ['%s=%r' % (key, value)
14939 
      for key, value in self.__dict__.iteritems()]
14940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14941 
 
14942 
  def __eq__(self, other):
14943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14944 
 
14945 
  def __ne__(self, other):
14946 
    return not (self == other)
14947 
 
4668 varun.gupt 14948 
class showCODOption_args:
14949 
  """
14950 
  Attributes:
14951 
   - cartId
14952 
   - sourceId
14953 
   - pincode
14954 
  """
14955 
 
14956 
  thrift_spec = (
14957 
    None, # 0
14958 
    (1, TType.I64, 'cartId', None, None, ), # 1
14959 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14960 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14961 
  )
14962 
 
14963 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14964 
    self.cartId = cartId
14965 
    self.sourceId = sourceId
14966 
    self.pincode = pincode
14967 
 
14968 
  def read(self, iprot):
14969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14971 
      return
14972 
    iprot.readStructBegin()
14973 
    while True:
14974 
      (fname, ftype, fid) = iprot.readFieldBegin()
14975 
      if ftype == TType.STOP:
14976 
        break
14977 
      if fid == 1:
14978 
        if ftype == TType.I64:
14979 
          self.cartId = iprot.readI64();
14980 
        else:
14981 
          iprot.skip(ftype)
14982 
      elif fid == 2:
14983 
        if ftype == TType.I64:
14984 
          self.sourceId = iprot.readI64();
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      elif fid == 3:
14988 
        if ftype == TType.STRING:
14989 
          self.pincode = iprot.readString();
14990 
        else:
14991 
          iprot.skip(ftype)
14992 
      else:
14993 
        iprot.skip(ftype)
14994 
      iprot.readFieldEnd()
14995 
    iprot.readStructEnd()
14996 
 
14997 
  def write(self, oprot):
14998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15000 
      return
15001 
    oprot.writeStructBegin('showCODOption_args')
15002 
    if self.cartId is not None:
15003 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15004 
      oprot.writeI64(self.cartId)
15005 
      oprot.writeFieldEnd()
15006 
    if self.sourceId is not None:
15007 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15008 
      oprot.writeI64(self.sourceId)
15009 
      oprot.writeFieldEnd()
15010 
    if self.pincode is not None:
15011 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
15012 
      oprot.writeString(self.pincode)
15013 
      oprot.writeFieldEnd()
15014 
    oprot.writeFieldStop()
15015 
    oprot.writeStructEnd()
15016 
 
15017 
  def validate(self):
15018 
    return
15019 
 
15020 
 
15021 
  def __repr__(self):
15022 
    L = ['%s=%r' % (key, value)
15023 
      for key, value in self.__dict__.iteritems()]
15024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15025 
 
15026 
  def __eq__(self, other):
15027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15028 
 
15029 
  def __ne__(self, other):
15030 
    return not (self == other)
15031 
 
15032 
class showCODOption_result:
15033 
  """
15034 
  Attributes:
15035 
   - success
15036 
  """
15037 
 
15038 
  thrift_spec = (
15039 
    (0, TType.BOOL, 'success', None, None, ), # 0
15040 
  )
15041 
 
15042 
  def __init__(self, success=None,):
15043 
    self.success = success
15044 
 
15045 
  def read(self, iprot):
15046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15048 
      return
15049 
    iprot.readStructBegin()
15050 
    while True:
15051 
      (fname, ftype, fid) = iprot.readFieldBegin()
15052 
      if ftype == TType.STOP:
15053 
        break
15054 
      if fid == 0:
15055 
        if ftype == TType.BOOL:
15056 
          self.success = iprot.readBool();
15057 
        else:
15058 
          iprot.skip(ftype)
15059 
      else:
15060 
        iprot.skip(ftype)
15061 
      iprot.readFieldEnd()
15062 
    iprot.readStructEnd()
15063 
 
15064 
  def write(self, oprot):
15065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15067 
      return
15068 
    oprot.writeStructBegin('showCODOption_result')
15069 
    if self.success is not None:
15070 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15071 
      oprot.writeBool(self.success)
15072 
      oprot.writeFieldEnd()
15073 
    oprot.writeFieldStop()
15074 
    oprot.writeStructEnd()
15075 
 
15076 
  def validate(self):
15077 
    return
15078 
 
15079 
 
15080 
  def __repr__(self):
15081 
    L = ['%s=%r' % (key, value)
15082 
      for key, value in self.__dict__.iteritems()]
15083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15084 
 
15085 
  def __eq__(self, other):
15086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15087 
 
15088 
  def __ne__(self, other):
15089 
    return not (self == other)
5623 anupam.sin 15090 
 
15091 
class getUserEmails_args:
15092 
  """
15093 
  Attributes:
15094 
   - startDate
15095 
   - endDate
15096 
  """
15097 
 
15098 
  thrift_spec = (
15099 
    None, # 0
15100 
    (1, TType.I64, 'startDate', None, None, ), # 1
15101 
    (2, TType.I64, 'endDate', None, None, ), # 2
15102 
  )
15103 
 
15104 
  def __init__(self, startDate=None, endDate=None,):
15105 
    self.startDate = startDate
15106 
    self.endDate = endDate
15107 
 
15108 
  def read(self, iprot):
15109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15111 
      return
15112 
    iprot.readStructBegin()
15113 
    while True:
15114 
      (fname, ftype, fid) = iprot.readFieldBegin()
15115 
      if ftype == TType.STOP:
15116 
        break
15117 
      if fid == 1:
15118 
        if ftype == TType.I64:
15119 
          self.startDate = iprot.readI64();
15120 
        else:
15121 
          iprot.skip(ftype)
15122 
      elif fid == 2:
15123 
        if ftype == TType.I64:
15124 
          self.endDate = iprot.readI64();
15125 
        else:
15126 
          iprot.skip(ftype)
15127 
      else:
15128 
        iprot.skip(ftype)
15129 
      iprot.readFieldEnd()
15130 
    iprot.readStructEnd()
15131 
 
15132 
  def write(self, oprot):
15133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15135 
      return
15136 
    oprot.writeStructBegin('getUserEmails_args')
15137 
    if self.startDate is not None:
15138 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
15139 
      oprot.writeI64(self.startDate)
15140 
      oprot.writeFieldEnd()
15141 
    if self.endDate is not None:
15142 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
15143 
      oprot.writeI64(self.endDate)
15144 
      oprot.writeFieldEnd()
15145 
    oprot.writeFieldStop()
15146 
    oprot.writeStructEnd()
15147 
 
15148 
  def validate(self):
15149 
    return
15150 
 
15151 
 
15152 
  def __repr__(self):
15153 
    L = ['%s=%r' % (key, value)
15154 
      for key, value in self.__dict__.iteritems()]
15155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15156 
 
15157 
  def __eq__(self, other):
15158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15159 
 
15160 
  def __ne__(self, other):
15161 
    return not (self == other)
15162 
 
15163 
class getUserEmails_result:
15164 
  """
15165 
  Attributes:
15166 
   - success
15167 
  """
15168 
 
15169 
  thrift_spec = (
15170 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15171 
  )
15172 
 
15173 
  def __init__(self, success=None,):
15174 
    self.success = success
15175 
 
15176 
  def read(self, iprot):
15177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15179 
      return
15180 
    iprot.readStructBegin()
15181 
    while True:
15182 
      (fname, ftype, fid) = iprot.readFieldBegin()
15183 
      if ftype == TType.STOP:
15184 
        break
15185 
      if fid == 0:
15186 
        if ftype == TType.LIST:
15187 
          self.success = []
11980 amit.gupta 15188 
          (_etype214, _size211) = iprot.readListBegin()
15189 
          for _i215 in xrange(_size211):
15190 
            _elem216 = iprot.readString();
15191 
            self.success.append(_elem216)
5623 anupam.sin 15192 
          iprot.readListEnd()
15193 
        else:
15194 
          iprot.skip(ftype)
15195 
      else:
15196 
        iprot.skip(ftype)
15197 
      iprot.readFieldEnd()
15198 
    iprot.readStructEnd()
15199 
 
15200 
  def write(self, oprot):
15201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15203 
      return
15204 
    oprot.writeStructBegin('getUserEmails_result')
15205 
    if self.success is not None:
15206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15207 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 15208 
      for iter217 in self.success:
15209 
        oprot.writeString(iter217)
5623 anupam.sin 15210 
      oprot.writeListEnd()
15211 
      oprot.writeFieldEnd()
15212 
    oprot.writeFieldStop()
15213 
    oprot.writeStructEnd()
15214 
 
15215 
  def validate(self):
15216 
    return
15217 
 
15218 
 
15219 
  def __repr__(self):
15220 
    L = ['%s=%r' % (key, value)
15221 
      for key, value in self.__dict__.iteritems()]
15222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15223 
 
15224 
  def __eq__(self, other):
15225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15226 
 
15227 
  def __ne__(self, other):
15228 
    return not (self == other)
6821 amar.kumar 15229 
 
6903 anupam.sin 15230 
class insureItem_args:
15231 
  """
15232 
  Attributes:
15233 
   - itemId
15234 
   - cartId
15235 
   - toInsure
9299 kshitij.so 15236 
   - insurerType
6903 anupam.sin 15237 
  """
15238 
 
15239 
  thrift_spec = (
15240 
    None, # 0
15241 
    (1, TType.I64, 'itemId', None, None, ), # 1
15242 
    (2, TType.I64, 'cartId', None, None, ), # 2
15243 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 15244 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 15245 
  )
15246 
 
9299 kshitij.so 15247 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 15248 
    self.itemId = itemId
15249 
    self.cartId = cartId
15250 
    self.toInsure = toInsure
9299 kshitij.so 15251 
    self.insurerType = insurerType
6903 anupam.sin 15252 
 
15253 
  def read(self, iprot):
15254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15256 
      return
15257 
    iprot.readStructBegin()
15258 
    while True:
15259 
      (fname, ftype, fid) = iprot.readFieldBegin()
15260 
      if ftype == TType.STOP:
15261 
        break
15262 
      if fid == 1:
15263 
        if ftype == TType.I64:
15264 
          self.itemId = iprot.readI64();
15265 
        else:
15266 
          iprot.skip(ftype)
15267 
      elif fid == 2:
15268 
        if ftype == TType.I64:
15269 
          self.cartId = iprot.readI64();
15270 
        else:
15271 
          iprot.skip(ftype)
15272 
      elif fid == 3:
15273 
        if ftype == TType.BOOL:
15274 
          self.toInsure = iprot.readBool();
15275 
        else:
15276 
          iprot.skip(ftype)
9299 kshitij.so 15277 
      elif fid == 4:
15278 
        if ftype == TType.I32:
15279 
          self.insurerType = iprot.readI32();
15280 
        else:
15281 
          iprot.skip(ftype)
6903 anupam.sin 15282 
      else:
15283 
        iprot.skip(ftype)
15284 
      iprot.readFieldEnd()
15285 
    iprot.readStructEnd()
15286 
 
15287 
  def write(self, oprot):
15288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15290 
      return
15291 
    oprot.writeStructBegin('insureItem_args')
15292 
    if self.itemId is not None:
15293 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15294 
      oprot.writeI64(self.itemId)
15295 
      oprot.writeFieldEnd()
15296 
    if self.cartId is not None:
15297 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
15298 
      oprot.writeI64(self.cartId)
15299 
      oprot.writeFieldEnd()
15300 
    if self.toInsure is not None:
15301 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
15302 
      oprot.writeBool(self.toInsure)
15303 
      oprot.writeFieldEnd()
9299 kshitij.so 15304 
    if self.insurerType is not None:
15305 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
15306 
      oprot.writeI32(self.insurerType)
15307 
      oprot.writeFieldEnd()
6903 anupam.sin 15308 
    oprot.writeFieldStop()
15309 
    oprot.writeStructEnd()
15310 
 
15311 
  def validate(self):
15312 
    return
15313 
 
15314 
 
15315 
  def __repr__(self):
15316 
    L = ['%s=%r' % (key, value)
15317 
      for key, value in self.__dict__.iteritems()]
15318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15319 
 
15320 
  def __eq__(self, other):
15321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15322 
 
15323 
  def __ne__(self, other):
15324 
    return not (self == other)
15325 
 
15326 
class insureItem_result:
15327 
  """
15328 
  Attributes:
15329 
   - success
15330 
  """
15331 
 
15332 
  thrift_spec = (
15333 
    (0, TType.BOOL, 'success', None, None, ), # 0
15334 
  )
15335 
 
15336 
  def __init__(self, success=None,):
15337 
    self.success = success
15338 
 
15339 
  def read(self, iprot):
15340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15342 
      return
15343 
    iprot.readStructBegin()
15344 
    while True:
15345 
      (fname, ftype, fid) = iprot.readFieldBegin()
15346 
      if ftype == TType.STOP:
15347 
        break
15348 
      if fid == 0:
15349 
        if ftype == TType.BOOL:
15350 
          self.success = iprot.readBool();
15351 
        else:
15352 
          iprot.skip(ftype)
15353 
      else:
15354 
        iprot.skip(ftype)
15355 
      iprot.readFieldEnd()
15356 
    iprot.readStructEnd()
15357 
 
15358 
  def write(self, oprot):
15359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15361 
      return
15362 
    oprot.writeStructBegin('insureItem_result')
15363 
    if self.success is not None:
15364 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15365 
      oprot.writeBool(self.success)
15366 
      oprot.writeFieldEnd()
15367 
    oprot.writeFieldStop()
15368 
    oprot.writeStructEnd()
15369 
 
15370 
  def validate(self):
15371 
    return
15372 
 
15373 
 
15374 
  def __repr__(self):
15375 
    L = ['%s=%r' % (key, value)
15376 
      for key, value in self.__dict__.iteritems()]
15377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15378 
 
15379 
  def __eq__(self, other):
15380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15381 
 
15382 
  def __ne__(self, other):
15383 
    return not (self == other)
15384 
 
15385 
class cancelInsurance_args:
15386 
  """
15387 
  Attributes:
15388 
   - cartId
15389 
  """
15390 
 
15391 
  thrift_spec = (
15392 
    None, # 0
15393 
    (1, TType.I64, 'cartId', None, None, ), # 1
15394 
  )
15395 
 
15396 
  def __init__(self, cartId=None,):
15397 
    self.cartId = cartId
15398 
 
15399 
  def read(self, iprot):
15400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15402 
      return
15403 
    iprot.readStructBegin()
15404 
    while True:
15405 
      (fname, ftype, fid) = iprot.readFieldBegin()
15406 
      if ftype == TType.STOP:
15407 
        break
15408 
      if fid == 1:
15409 
        if ftype == TType.I64:
15410 
          self.cartId = iprot.readI64();
15411 
        else:
15412 
          iprot.skip(ftype)
15413 
      else:
15414 
        iprot.skip(ftype)
15415 
      iprot.readFieldEnd()
15416 
    iprot.readStructEnd()
15417 
 
15418 
  def write(self, oprot):
15419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15421 
      return
15422 
    oprot.writeStructBegin('cancelInsurance_args')
15423 
    if self.cartId is not None:
15424 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15425 
      oprot.writeI64(self.cartId)
15426 
      oprot.writeFieldEnd()
15427 
    oprot.writeFieldStop()
15428 
    oprot.writeStructEnd()
15429 
 
15430 
  def validate(self):
15431 
    return
15432 
 
15433 
 
15434 
  def __repr__(self):
15435 
    L = ['%s=%r' % (key, value)
15436 
      for key, value in self.__dict__.iteritems()]
15437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15438 
 
15439 
  def __eq__(self, other):
15440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15441 
 
15442 
  def __ne__(self, other):
15443 
    return not (self == other)
15444 
 
15445 
class cancelInsurance_result:
15446 
  """
15447 
  Attributes:
15448 
   - success
15449 
  """
15450 
 
15451 
  thrift_spec = (
15452 
    (0, TType.BOOL, 'success', None, None, ), # 0
15453 
  )
15454 
 
15455 
  def __init__(self, success=None,):
15456 
    self.success = success
15457 
 
15458 
  def read(self, iprot):
15459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15461 
      return
15462 
    iprot.readStructBegin()
15463 
    while True:
15464 
      (fname, ftype, fid) = iprot.readFieldBegin()
15465 
      if ftype == TType.STOP:
15466 
        break
15467 
      if fid == 0:
15468 
        if ftype == TType.BOOL:
15469 
          self.success = iprot.readBool();
15470 
        else:
15471 
          iprot.skip(ftype)
15472 
      else:
15473 
        iprot.skip(ftype)
15474 
      iprot.readFieldEnd()
15475 
    iprot.readStructEnd()
15476 
 
15477 
  def write(self, oprot):
15478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15480 
      return
15481 
    oprot.writeStructBegin('cancelInsurance_result')
15482 
    if self.success is not None:
15483 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15484 
      oprot.writeBool(self.success)
15485 
      oprot.writeFieldEnd()
15486 
    oprot.writeFieldStop()
15487 
    oprot.writeStructEnd()
15488 
 
15489 
  def validate(self):
15490 
    return
15491 
 
15492 
 
15493 
  def __repr__(self):
15494 
    L = ['%s=%r' % (key, value)
15495 
      for key, value in self.__dict__.iteritems()]
15496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15497 
 
15498 
  def __eq__(self, other):
15499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15500 
 
15501 
  def __ne__(self, other):
15502 
    return not (self == other)
15503 
 
15504 
class storeInsuranceSpecificDetails_args:
15505 
  """
15506 
  Attributes:
15507 
   - addressId
15508 
   - dob
15509 
   - guardianName
15510 
  """
15511 
 
15512 
  thrift_spec = (
15513 
    None, # 0
15514 
    (1, TType.I64, 'addressId', None, None, ), # 1
15515 
    (2, TType.STRING, 'dob', None, None, ), # 2
15516 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
15517 
  )
15518 
 
15519 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
15520 
    self.addressId = addressId
15521 
    self.dob = dob
15522 
    self.guardianName = guardianName
15523 
 
15524 
  def read(self, iprot):
15525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15527 
      return
15528 
    iprot.readStructBegin()
15529 
    while True:
15530 
      (fname, ftype, fid) = iprot.readFieldBegin()
15531 
      if ftype == TType.STOP:
15532 
        break
15533 
      if fid == 1:
15534 
        if ftype == TType.I64:
15535 
          self.addressId = iprot.readI64();
15536 
        else:
15537 
          iprot.skip(ftype)
15538 
      elif fid == 2:
15539 
        if ftype == TType.STRING:
15540 
          self.dob = iprot.readString();
15541 
        else:
15542 
          iprot.skip(ftype)
15543 
      elif fid == 3:
15544 
        if ftype == TType.STRING:
15545 
          self.guardianName = iprot.readString();
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15558 
    if self.addressId is not None:
15559 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15560 
      oprot.writeI64(self.addressId)
15561 
      oprot.writeFieldEnd()
15562 
    if self.dob is not None:
15563 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15564 
      oprot.writeString(self.dob)
15565 
      oprot.writeFieldEnd()
15566 
    if self.guardianName is not None:
15567 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15568 
      oprot.writeString(self.guardianName)
15569 
      oprot.writeFieldEnd()
15570 
    oprot.writeFieldStop()
15571 
    oprot.writeStructEnd()
15572 
 
15573 
  def validate(self):
15574 
    return
15575 
 
15576 
 
15577 
  def __repr__(self):
15578 
    L = ['%s=%r' % (key, value)
15579 
      for key, value in self.__dict__.iteritems()]
15580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15581 
 
15582 
  def __eq__(self, other):
15583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15584 
 
15585 
  def __ne__(self, other):
15586 
    return not (self == other)
15587 
 
15588 
class storeInsuranceSpecificDetails_result:
15589 
  """
15590 
  Attributes:
15591 
   - success
15592 
  """
15593 
 
15594 
  thrift_spec = (
15595 
    (0, TType.BOOL, 'success', None, None, ), # 0
15596 
  )
15597 
 
15598 
  def __init__(self, success=None,):
15599 
    self.success = success
15600 
 
15601 
  def read(self, iprot):
15602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15604 
      return
15605 
    iprot.readStructBegin()
15606 
    while True:
15607 
      (fname, ftype, fid) = iprot.readFieldBegin()
15608 
      if ftype == TType.STOP:
15609 
        break
15610 
      if fid == 0:
15611 
        if ftype == TType.BOOL:
15612 
          self.success = iprot.readBool();
15613 
        else:
15614 
          iprot.skip(ftype)
15615 
      else:
15616 
        iprot.skip(ftype)
15617 
      iprot.readFieldEnd()
15618 
    iprot.readStructEnd()
15619 
 
15620 
  def write(self, oprot):
15621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15623 
      return
15624 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15625 
    if self.success is not None:
15626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15627 
      oprot.writeBool(self.success)
15628 
      oprot.writeFieldEnd()
15629 
    oprot.writeFieldStop()
15630 
    oprot.writeStructEnd()
15631 
 
15632 
  def validate(self):
15633 
    return
15634 
 
15635 
 
15636 
  def __repr__(self):
15637 
    L = ['%s=%r' % (key, value)
15638 
      for key, value in self.__dict__.iteritems()]
15639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15640 
 
15641 
  def __eq__(self, other):
15642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15643 
 
15644 
  def __ne__(self, other):
15645 
    return not (self == other)
15646 
 
15647 
class isInsuranceDetailPresent_args:
15648 
  """
15649 
  Attributes:
15650 
   - addressId
15651 
  """
15652 
 
15653 
  thrift_spec = (
15654 
    None, # 0
15655 
    (1, TType.I64, 'addressId', None, None, ), # 1
15656 
  )
15657 
 
15658 
  def __init__(self, addressId=None,):
15659 
    self.addressId = addressId
15660 
 
15661 
  def read(self, iprot):
15662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15664 
      return
15665 
    iprot.readStructBegin()
15666 
    while True:
15667 
      (fname, ftype, fid) = iprot.readFieldBegin()
15668 
      if ftype == TType.STOP:
15669 
        break
15670 
      if fid == 1:
15671 
        if ftype == TType.I64:
15672 
          self.addressId = iprot.readI64();
15673 
        else:
15674 
          iprot.skip(ftype)
15675 
      else:
15676 
        iprot.skip(ftype)
15677 
      iprot.readFieldEnd()
15678 
    iprot.readStructEnd()
15679 
 
15680 
  def write(self, oprot):
15681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15683 
      return
15684 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15685 
    if self.addressId is not None:
15686 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15687 
      oprot.writeI64(self.addressId)
15688 
      oprot.writeFieldEnd()
15689 
    oprot.writeFieldStop()
15690 
    oprot.writeStructEnd()
15691 
 
15692 
  def validate(self):
15693 
    return
15694 
 
15695 
 
15696 
  def __repr__(self):
15697 
    L = ['%s=%r' % (key, value)
15698 
      for key, value in self.__dict__.iteritems()]
15699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15700 
 
15701 
  def __eq__(self, other):
15702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15703 
 
15704 
  def __ne__(self, other):
15705 
    return not (self == other)
15706 
 
15707 
class isInsuranceDetailPresent_result:
15708 
  """
15709 
  Attributes:
15710 
   - success
15711 
  """
15712 
 
15713 
  thrift_spec = (
15714 
    (0, TType.BOOL, 'success', None, None, ), # 0
15715 
  )
15716 
 
15717 
  def __init__(self, success=None,):
15718 
    self.success = success
15719 
 
15720 
  def read(self, iprot):
15721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15723 
      return
15724 
    iprot.readStructBegin()
15725 
    while True:
15726 
      (fname, ftype, fid) = iprot.readFieldBegin()
15727 
      if ftype == TType.STOP:
15728 
        break
15729 
      if fid == 0:
15730 
        if ftype == TType.BOOL:
15731 
          self.success = iprot.readBool();
15732 
        else:
15733 
          iprot.skip(ftype)
15734 
      else:
15735 
        iprot.skip(ftype)
15736 
      iprot.readFieldEnd()
15737 
    iprot.readStructEnd()
15738 
 
15739 
  def write(self, oprot):
15740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15742 
      return
15743 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15744 
    if self.success is not None:
15745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15746 
      oprot.writeBool(self.success)
15747 
      oprot.writeFieldEnd()
15748 
    oprot.writeFieldStop()
15749 
    oprot.writeStructEnd()
15750 
 
15751 
  def validate(self):
15752 
    return
15753 
 
15754 
 
15755 
  def __repr__(self):
15756 
    L = ['%s=%r' % (key, value)
15757 
      for key, value in self.__dict__.iteritems()]
15758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15759 
 
15760 
  def __eq__(self, other):
15761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15762 
 
15763 
  def __ne__(self, other):
15764 
    return not (self == other)
15765 
 
9791 rajveer 15766 
class getProductsAddedToCart_args:
6821 amar.kumar 15767 
  """
15768 
  Attributes:
15769 
   - startDate
15770 
   - endDate
15771 
  """
15772 
 
15773 
  thrift_spec = (
15774 
    None, # 0
9791 rajveer 15775 
    (1, TType.I64, 'startDate', None, None, ), # 1
15776 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15777 
  )
15778 
 
9791 rajveer 15779 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15780 
    self.startDate = startDate
15781 
    self.endDate = endDate
15782 
 
15783 
  def read(self, iprot):
15784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15786 
      return
15787 
    iprot.readStructBegin()
15788 
    while True:
15789 
      (fname, ftype, fid) = iprot.readFieldBegin()
15790 
      if ftype == TType.STOP:
15791 
        break
15792 
      if fid == 1:
15793 
        if ftype == TType.I64:
9791 rajveer 15794 
          self.startDate = iprot.readI64();
6821 amar.kumar 15795 
        else:
15796 
          iprot.skip(ftype)
15797 
      elif fid == 2:
15798 
        if ftype == TType.I64:
15799 
          self.endDate = iprot.readI64();
15800 
        else:
15801 
          iprot.skip(ftype)
15802 
      else:
15803 
        iprot.skip(ftype)
15804 
      iprot.readFieldEnd()
15805 
    iprot.readStructEnd()
15806 
 
15807 
  def write(self, oprot):
15808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15810 
      return
9791 rajveer 15811 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15812 
    if self.startDate is not None:
9791 rajveer 15813 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15814 
      oprot.writeI64(self.startDate)
15815 
      oprot.writeFieldEnd()
15816 
    if self.endDate is not None:
9791 rajveer 15817 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15818 
      oprot.writeI64(self.endDate)
15819 
      oprot.writeFieldEnd()
15820 
    oprot.writeFieldStop()
15821 
    oprot.writeStructEnd()
15822 
 
15823 
  def validate(self):
15824 
    return
15825 
 
15826 
 
15827 
  def __repr__(self):
15828 
    L = ['%s=%r' % (key, value)
15829 
      for key, value in self.__dict__.iteritems()]
15830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15831 
 
15832 
  def __eq__(self, other):
15833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15834 
 
15835 
  def __ne__(self, other):
15836 
    return not (self == other)
15837 
 
9791 rajveer 15838 
class getProductsAddedToCart_result:
6821 amar.kumar 15839 
  """
15840 
  Attributes:
15841 
   - success
15842 
  """
15843 
 
15844 
  thrift_spec = (
9791 rajveer 15845 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15846 
  )
15847 
 
15848 
  def __init__(self, success=None,):
15849 
    self.success = success
15850 
 
15851 
  def read(self, iprot):
15852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15854 
      return
15855 
    iprot.readStructBegin()
15856 
    while True:
15857 
      (fname, ftype, fid) = iprot.readFieldBegin()
15858 
      if ftype == TType.STOP:
15859 
        break
15860 
      if fid == 0:
9791 rajveer 15861 
        if ftype == TType.LIST:
15862 
          self.success = []
11980 amit.gupta 15863 
          (_etype221, _size218) = iprot.readListBegin()
15864 
          for _i222 in xrange(_size218):
15865 
            _elem223 = iprot.readI64();
15866 
            self.success.append(_elem223)
9791 rajveer 15867 
          iprot.readListEnd()
6821 amar.kumar 15868 
        else:
15869 
          iprot.skip(ftype)
15870 
      else:
15871 
        iprot.skip(ftype)
15872 
      iprot.readFieldEnd()
15873 
    iprot.readStructEnd()
15874 
 
15875 
  def write(self, oprot):
15876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15878 
      return
9791 rajveer 15879 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15880 
    if self.success is not None:
9791 rajveer 15881 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15882 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15883 
      for iter224 in self.success:
15884 
        oprot.writeI64(iter224)
9791 rajveer 15885 
      oprot.writeListEnd()
6821 amar.kumar 15886 
      oprot.writeFieldEnd()
15887 
    oprot.writeFieldStop()
15888 
    oprot.writeStructEnd()
15889 
 
15890 
  def validate(self):
15891 
    return
15892 
 
15893 
 
15894 
  def __repr__(self):
15895 
    L = ['%s=%r' % (key, value)
15896 
      for key, value in self.__dict__.iteritems()]
15897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15898 
 
15899 
  def __eq__(self, other):
15900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15901 
 
15902 
  def __ne__(self, other):
15903 
    return not (self == other)
11592 amit.gupta 15904 
 
15905 
class validateCartPlus_args:
15906 
  """
15907 
  Attributes:
15908 
   - cartId
15909 
   - sourceId
11980 amit.gupta 15910 
   - dealerCoupon
11592 amit.gupta 15911 
  """
15912 
 
15913 
  thrift_spec = (
15914 
    None, # 0
15915 
    (1, TType.I64, 'cartId', None, None, ), # 1
15916 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15917 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15918 
  )
15919 
 
11980 amit.gupta 15920 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15921 
    self.cartId = cartId
15922 
    self.sourceId = sourceId
11980 amit.gupta 15923 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15924 
 
15925 
  def read(self, iprot):
15926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15928 
      return
15929 
    iprot.readStructBegin()
15930 
    while True:
15931 
      (fname, ftype, fid) = iprot.readFieldBegin()
15932 
      if ftype == TType.STOP:
15933 
        break
15934 
      if fid == 1:
15935 
        if ftype == TType.I64:
15936 
          self.cartId = iprot.readI64();
15937 
        else:
15938 
          iprot.skip(ftype)
15939 
      elif fid == 2:
15940 
        if ftype == TType.I64:
15941 
          self.sourceId = iprot.readI64();
15942 
        else:
15943 
          iprot.skip(ftype)
11980 amit.gupta 15944 
      elif fid == 3:
15945 
        if ftype == TType.STRING:
15946 
          self.dealerCoupon = iprot.readString();
15947 
        else:
15948 
          iprot.skip(ftype)
11592 amit.gupta 15949 
      else:
15950 
        iprot.skip(ftype)
15951 
      iprot.readFieldEnd()
15952 
    iprot.readStructEnd()
15953 
 
15954 
  def write(self, oprot):
15955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15957 
      return
15958 
    oprot.writeStructBegin('validateCartPlus_args')
15959 
    if self.cartId is not None:
15960 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15961 
      oprot.writeI64(self.cartId)
15962 
      oprot.writeFieldEnd()
15963 
    if self.sourceId is not None:
15964 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15965 
      oprot.writeI64(self.sourceId)
15966 
      oprot.writeFieldEnd()
11980 amit.gupta 15967 
    if self.dealerCoupon is not None:
15968 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15969 
      oprot.writeString(self.dealerCoupon)
15970 
      oprot.writeFieldEnd()
11592 amit.gupta 15971 
    oprot.writeFieldStop()
15972 
    oprot.writeStructEnd()
15973 
 
15974 
  def validate(self):
15975 
    return
15976 
 
15977 
 
15978 
  def __repr__(self):
15979 
    L = ['%s=%r' % (key, value)
15980 
      for key, value in self.__dict__.iteritems()]
15981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15982 
 
15983 
  def __eq__(self, other):
15984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15985 
 
15986 
  def __ne__(self, other):
15987 
    return not (self == other)
15988 
 
15989 
class validateCartPlus_result:
15990 
  """
15991 
  Attributes:
15992 
   - success
15993 
   - scex
15994 
  """
15995 
 
15996 
  thrift_spec = (
15997 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15998 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15999 
  )
16000 
 
16001 
  def __init__(self, success=None, scex=None,):
16002 
    self.success = success
16003 
    self.scex = scex
16004 
 
16005 
  def read(self, iprot):
16006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16008 
      return
16009 
    iprot.readStructBegin()
16010 
    while True:
16011 
      (fname, ftype, fid) = iprot.readFieldBegin()
16012 
      if ftype == TType.STOP:
16013 
        break
16014 
      if fid == 0:
16015 
        if ftype == TType.STRUCT:
16016 
          self.success = CartPlus()
16017 
          self.success.read(iprot)
16018 
        else:
16019 
          iprot.skip(ftype)
16020 
      elif fid == 1:
16021 
        if ftype == TType.STRUCT:
16022 
          self.scex = ShoppingCartException()
16023 
          self.scex.read(iprot)
16024 
        else:
16025 
          iprot.skip(ftype)
16026 
      else:
16027 
        iprot.skip(ftype)
16028 
      iprot.readFieldEnd()
16029 
    iprot.readStructEnd()
16030 
 
16031 
  def write(self, oprot):
16032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16034 
      return
16035 
    oprot.writeStructBegin('validateCartPlus_result')
16036 
    if self.success is not None:
16037 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16038 
      self.success.write(oprot)
16039 
      oprot.writeFieldEnd()
16040 
    if self.scex is not None:
16041 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
16042 
      self.scex.write(oprot)
16043 
      oprot.writeFieldEnd()
16044 
    oprot.writeFieldStop()
16045 
    oprot.writeStructEnd()
16046 
 
16047 
  def validate(self):
16048 
    return
16049 
 
16050 
 
16051 
  def __repr__(self):
16052 
    L = ['%s=%r' % (key, value)
16053 
      for key, value in self.__dict__.iteritems()]
16054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16055 
 
16056 
  def __eq__(self, other):
16057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16058 
 
16059 
  def __ne__(self, other):
16060 
    return not (self == other)
11679 vikram.rag 16061 
 
16062 
class isPrivateDealUser_args:
16063 
  """
16064 
  Attributes:
16065 
   - userId
16066 
  """
16067 
 
16068 
  thrift_spec = (
16069 
    None, # 0
16070 
    (1, TType.I64, 'userId', None, None, ), # 1
16071 
  )
16072 
 
16073 
  def __init__(self, userId=None,):
16074 
    self.userId = userId
16075 
 
16076 
  def read(self, iprot):
16077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16079 
      return
16080 
    iprot.readStructBegin()
16081 
    while True:
16082 
      (fname, ftype, fid) = iprot.readFieldBegin()
16083 
      if ftype == TType.STOP:
16084 
        break
16085 
      if fid == 1:
16086 
        if ftype == TType.I64:
16087 
          self.userId = iprot.readI64();
16088 
        else:
16089 
          iprot.skip(ftype)
16090 
      else:
16091 
        iprot.skip(ftype)
16092 
      iprot.readFieldEnd()
16093 
    iprot.readStructEnd()
16094 
 
16095 
  def write(self, oprot):
16096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16098 
      return
16099 
    oprot.writeStructBegin('isPrivateDealUser_args')
16100 
    if self.userId is not None:
16101 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16102 
      oprot.writeI64(self.userId)
16103 
      oprot.writeFieldEnd()
16104 
    oprot.writeFieldStop()
16105 
    oprot.writeStructEnd()
16106 
 
16107 
  def validate(self):
16108 
    return
16109 
 
16110 
 
16111 
  def __repr__(self):
16112 
    L = ['%s=%r' % (key, value)
16113 
      for key, value in self.__dict__.iteritems()]
16114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16115 
 
16116 
  def __eq__(self, other):
16117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16118 
 
16119 
  def __ne__(self, other):
16120 
    return not (self == other)
16121 
 
16122 
class isPrivateDealUser_result:
16123 
  """
16124 
  Attributes:
16125 
   - success
16126 
  """
16127 
 
16128 
  thrift_spec = (
16129 
    (0, TType.BOOL, 'success', None, None, ), # 0
16130 
  )
16131 
 
16132 
  def __init__(self, success=None,):
16133 
    self.success = success
16134 
 
16135 
  def read(self, iprot):
16136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16138 
      return
16139 
    iprot.readStructBegin()
16140 
    while True:
16141 
      (fname, ftype, fid) = iprot.readFieldBegin()
16142 
      if ftype == TType.STOP:
16143 
        break
16144 
      if fid == 0:
16145 
        if ftype == TType.BOOL:
16146 
          self.success = iprot.readBool();
16147 
        else:
16148 
          iprot.skip(ftype)
16149 
      else:
16150 
        iprot.skip(ftype)
16151 
      iprot.readFieldEnd()
16152 
    iprot.readStructEnd()
16153 
 
16154 
  def write(self, oprot):
16155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16157 
      return
16158 
    oprot.writeStructBegin('isPrivateDealUser_result')
16159 
    if self.success is not None:
16160 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16161 
      oprot.writeBool(self.success)
16162 
      oprot.writeFieldEnd()
16163 
    oprot.writeFieldStop()
16164 
    oprot.writeStructEnd()
16165 
 
16166 
  def validate(self):
16167 
    return
16168 
 
16169 
 
16170 
  def __repr__(self):
16171 
    L = ['%s=%r' % (key, value)
16172 
      for key, value in self.__dict__.iteritems()]
16173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16174 
 
16175 
  def __eq__(self, other):
16176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16177 
 
16178 
  def __ne__(self, other):
16179 
    return not (self == other)
11890 kshitij.so 16180 
 
16181 
class addPrivateDealUser_args:
16182 
  """
16183 
  Attributes:
16184 
   - userId
16185 
  """
16186 
 
16187 
  thrift_spec = (
16188 
    None, # 0
16189 
    (1, TType.I64, 'userId', None, None, ), # 1
16190 
  )
16191 
 
16192 
  def __init__(self, userId=None,):
16193 
    self.userId = userId
16194 
 
16195 
  def read(self, iprot):
16196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16198 
      return
16199 
    iprot.readStructBegin()
16200 
    while True:
16201 
      (fname, ftype, fid) = iprot.readFieldBegin()
16202 
      if ftype == TType.STOP:
16203 
        break
16204 
      if fid == 1:
16205 
        if ftype == TType.I64:
16206 
          self.userId = iprot.readI64();
16207 
        else:
16208 
          iprot.skip(ftype)
16209 
      else:
16210 
        iprot.skip(ftype)
16211 
      iprot.readFieldEnd()
16212 
    iprot.readStructEnd()
16213 
 
16214 
  def write(self, oprot):
16215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16217 
      return
16218 
    oprot.writeStructBegin('addPrivateDealUser_args')
16219 
    if self.userId is not None:
16220 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16221 
      oprot.writeI64(self.userId)
16222 
      oprot.writeFieldEnd()
16223 
    oprot.writeFieldStop()
16224 
    oprot.writeStructEnd()
16225 
 
16226 
  def validate(self):
16227 
    return
16228 
 
16229 
 
16230 
  def __repr__(self):
16231 
    L = ['%s=%r' % (key, value)
16232 
      for key, value in self.__dict__.iteritems()]
16233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16234 
 
16235 
  def __eq__(self, other):
16236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16237 
 
16238 
  def __ne__(self, other):
16239 
    return not (self == other)
16240 
 
16241 
class addPrivateDealUser_result:
16242 
  """
16243 
  Attributes:
16244 
   - success
16245 
  """
16246 
 
16247 
  thrift_spec = (
16248 
    (0, TType.BOOL, 'success', None, None, ), # 0
16249 
  )
16250 
 
16251 
  def __init__(self, success=None,):
16252 
    self.success = success
16253 
 
16254 
  def read(self, iprot):
16255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16257 
      return
16258 
    iprot.readStructBegin()
16259 
    while True:
16260 
      (fname, ftype, fid) = iprot.readFieldBegin()
16261 
      if ftype == TType.STOP:
16262 
        break
16263 
      if fid == 0:
16264 
        if ftype == TType.BOOL:
16265 
          self.success = iprot.readBool();
16266 
        else:
16267 
          iprot.skip(ftype)
16268 
      else:
16269 
        iprot.skip(ftype)
16270 
      iprot.readFieldEnd()
16271 
    iprot.readStructEnd()
16272 
 
16273 
  def write(self, oprot):
16274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16276 
      return
16277 
    oprot.writeStructBegin('addPrivateDealUser_result')
16278 
    if self.success is not None:
16279 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16280 
      oprot.writeBool(self.success)
16281 
      oprot.writeFieldEnd()
16282 
    oprot.writeFieldStop()
16283 
    oprot.writeStructEnd()
16284 
 
16285 
  def validate(self):
16286 
    return
16287 
 
16288 
 
16289 
  def __repr__(self):
16290 
    L = ['%s=%r' % (key, value)
16291 
      for key, value in self.__dict__.iteritems()]
16292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16293 
 
16294 
  def __eq__(self, other):
16295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16296 
 
16297 
  def __ne__(self, other):
16298 
    return not (self == other)
16299 
 
16300 
class changePrivateDealUserStatus_args:
16301 
  """
16302 
  Attributes:
16303 
   - userId
16304 
   - isActive
16305 
  """
16306 
 
16307 
  thrift_spec = (
16308 
    None, # 0
16309 
    (1, TType.I64, 'userId', None, None, ), # 1
16310 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
16311 
  )
16312 
 
16313 
  def __init__(self, userId=None, isActive=None,):
16314 
    self.userId = userId
16315 
    self.isActive = isActive
16316 
 
16317 
  def read(self, iprot):
16318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16320 
      return
16321 
    iprot.readStructBegin()
16322 
    while True:
16323 
      (fname, ftype, fid) = iprot.readFieldBegin()
16324 
      if ftype == TType.STOP:
16325 
        break
16326 
      if fid == 1:
16327 
        if ftype == TType.I64:
16328 
          self.userId = iprot.readI64();
16329 
        else:
16330 
          iprot.skip(ftype)
16331 
      elif fid == 2:
16332 
        if ftype == TType.BOOL:
16333 
          self.isActive = iprot.readBool();
16334 
        else:
16335 
          iprot.skip(ftype)
16336 
      else:
16337 
        iprot.skip(ftype)
16338 
      iprot.readFieldEnd()
16339 
    iprot.readStructEnd()
16340 
 
16341 
  def write(self, oprot):
16342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16344 
      return
16345 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
16346 
    if self.userId is not None:
16347 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16348 
      oprot.writeI64(self.userId)
16349 
      oprot.writeFieldEnd()
16350 
    if self.isActive is not None:
16351 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
16352 
      oprot.writeBool(self.isActive)
16353 
      oprot.writeFieldEnd()
16354 
    oprot.writeFieldStop()
16355 
    oprot.writeStructEnd()
16356 
 
16357 
  def validate(self):
16358 
    return
16359 
 
16360 
 
16361 
  def __repr__(self):
16362 
    L = ['%s=%r' % (key, value)
16363 
      for key, value in self.__dict__.iteritems()]
16364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16365 
 
16366 
  def __eq__(self, other):
16367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16368 
 
16369 
  def __ne__(self, other):
16370 
    return not (self == other)
16371 
 
16372 
class changePrivateDealUserStatus_result:
16373 
  """
16374 
  Attributes:
16375 
   - success
16376 
  """
16377 
 
16378 
  thrift_spec = (
16379 
    (0, TType.BOOL, 'success', None, None, ), # 0
16380 
  )
16381 
 
16382 
  def __init__(self, success=None,):
16383 
    self.success = success
16384 
 
16385 
  def read(self, iprot):
16386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16388 
      return
16389 
    iprot.readStructBegin()
16390 
    while True:
16391 
      (fname, ftype, fid) = iprot.readFieldBegin()
16392 
      if ftype == TType.STOP:
16393 
        break
16394 
      if fid == 0:
16395 
        if ftype == TType.BOOL:
16396 
          self.success = iprot.readBool();
16397 
        else:
16398 
          iprot.skip(ftype)
16399 
      else:
16400 
        iprot.skip(ftype)
16401 
      iprot.readFieldEnd()
16402 
    iprot.readStructEnd()
16403 
 
16404 
  def write(self, oprot):
16405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16407 
      return
16408 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
16409 
    if self.success is not None:
16410 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16411 
      oprot.writeBool(self.success)
16412 
      oprot.writeFieldEnd()
16413 
    oprot.writeFieldStop()
16414 
    oprot.writeStructEnd()
16415 
 
16416 
  def validate(self):
16417 
    return
16418 
 
16419 
 
16420 
  def __repr__(self):
16421 
    L = ['%s=%r' % (key, value)
16422 
      for key, value in self.__dict__.iteritems()]
16423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16424 
 
16425 
  def __eq__(self, other):
16426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16427 
 
16428 
  def __ne__(self, other):
16429 
    return not (self == other)
16430 
 
16431 
class getPrivateDealUser_args:
16432 
  """
16433 
  Attributes:
16434 
   - userId
16435 
  """
16436 
 
16437 
  thrift_spec = (
16438 
    None, # 0
16439 
    (1, TType.I64, 'userId', None, None, ), # 1
16440 
  )
16441 
 
16442 
  def __init__(self, userId=None,):
16443 
    self.userId = userId
16444 
 
16445 
  def read(self, iprot):
16446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16448 
      return
16449 
    iprot.readStructBegin()
16450 
    while True:
16451 
      (fname, ftype, fid) = iprot.readFieldBegin()
16452 
      if ftype == TType.STOP:
16453 
        break
16454 
      if fid == 1:
16455 
        if ftype == TType.I64:
16456 
          self.userId = iprot.readI64();
16457 
        else:
16458 
          iprot.skip(ftype)
16459 
      else:
16460 
        iprot.skip(ftype)
16461 
      iprot.readFieldEnd()
16462 
    iprot.readStructEnd()
16463 
 
16464 
  def write(self, oprot):
16465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16467 
      return
16468 
    oprot.writeStructBegin('getPrivateDealUser_args')
16469 
    if self.userId is not None:
16470 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16471 
      oprot.writeI64(self.userId)
16472 
      oprot.writeFieldEnd()
16473 
    oprot.writeFieldStop()
16474 
    oprot.writeStructEnd()
16475 
 
16476 
  def validate(self):
16477 
    return
16478 
 
16479 
 
16480 
  def __repr__(self):
16481 
    L = ['%s=%r' % (key, value)
16482 
      for key, value in self.__dict__.iteritems()]
16483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16484 
 
16485 
  def __eq__(self, other):
16486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16487 
 
16488 
  def __ne__(self, other):
16489 
    return not (self == other)
16490 
 
16491 
class getPrivateDealUser_result:
16492 
  """
16493 
  Attributes:
16494 
   - success
16495 
  """
16496 
 
16497 
  thrift_spec = (
16498 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
16499 
  )
16500 
 
16501 
  def __init__(self, success=None,):
16502 
    self.success = success
16503 
 
16504 
  def read(self, iprot):
16505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16507 
      return
16508 
    iprot.readStructBegin()
16509 
    while True:
16510 
      (fname, ftype, fid) = iprot.readFieldBegin()
16511 
      if ftype == TType.STOP:
16512 
        break
16513 
      if fid == 0:
16514 
        if ftype == TType.STRUCT:
16515 
          self.success = PrivateDealUser()
16516 
          self.success.read(iprot)
16517 
        else:
16518 
          iprot.skip(ftype)
16519 
      else:
16520 
        iprot.skip(ftype)
16521 
      iprot.readFieldEnd()
16522 
    iprot.readStructEnd()
16523 
 
16524 
  def write(self, oprot):
16525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16527 
      return
16528 
    oprot.writeStructBegin('getPrivateDealUser_result')
16529 
    if self.success is not None:
16530 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16531 
      self.success.write(oprot)
16532 
      oprot.writeFieldEnd()
16533 
    oprot.writeFieldStop()
16534 
    oprot.writeStructEnd()
16535 
 
16536 
  def validate(self):
16537 
    return
16538 
 
16539 
 
16540 
  def __repr__(self):
16541 
    L = ['%s=%r' % (key, value)
16542 
      for key, value in self.__dict__.iteritems()]
16543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16544 
 
16545 
  def __eq__(self, other):
16546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16547 
 
16548 
  def __ne__(self, other):
16549 
    return not (self == other)
12696 amit.gupta 16550 
 
16551 
class registerCounter_args:
16552 
  """
16553 
  Attributes:
16554 
   - counter
16555 
   - userId
16556 
  """
16557 
 
16558 
  thrift_spec = (
16559 
    None, # 0
16560 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16561 
    (2, TType.I64, 'userId', None, None, ), # 2
16562 
  )
16563 
 
16564 
  def __init__(self, counter=None, userId=None,):
16565 
    self.counter = counter
16566 
    self.userId = userId
16567 
 
16568 
  def read(self, iprot):
16569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16571 
      return
16572 
    iprot.readStructBegin()
16573 
    while True:
16574 
      (fname, ftype, fid) = iprot.readFieldBegin()
16575 
      if ftype == TType.STOP:
16576 
        break
16577 
      if fid == 1:
16578 
        if ftype == TType.STRUCT:
16579 
          self.counter = Counter()
16580 
          self.counter.read(iprot)
16581 
        else:
16582 
          iprot.skip(ftype)
16583 
      elif fid == 2:
16584 
        if ftype == TType.I64:
16585 
          self.userId = iprot.readI64();
16586 
        else:
16587 
          iprot.skip(ftype)
16588 
      else:
16589 
        iprot.skip(ftype)
16590 
      iprot.readFieldEnd()
16591 
    iprot.readStructEnd()
16592 
 
16593 
  def write(self, oprot):
16594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16596 
      return
16597 
    oprot.writeStructBegin('registerCounter_args')
16598 
    if self.counter is not None:
16599 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16600 
      self.counter.write(oprot)
16601 
      oprot.writeFieldEnd()
16602 
    if self.userId is not None:
16603 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16604 
      oprot.writeI64(self.userId)
16605 
      oprot.writeFieldEnd()
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
16613 
  def __repr__(self):
16614 
    L = ['%s=%r' % (key, value)
16615 
      for key, value in self.__dict__.iteritems()]
16616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16617 
 
16618 
  def __eq__(self, other):
16619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16620 
 
16621 
  def __ne__(self, other):
16622 
    return not (self == other)
16623 
 
16624 
class registerCounter_result:
16625 
  """
16626 
  Attributes:
16627 
   - success
16628 
  """
16629 
 
16630 
  thrift_spec = (
16631 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16632 
  )
16633 
 
16634 
  def __init__(self, success=None,):
16635 
    self.success = success
16636 
 
16637 
  def read(self, iprot):
16638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16640 
      return
16641 
    iprot.readStructBegin()
16642 
    while True:
16643 
      (fname, ftype, fid) = iprot.readFieldBegin()
16644 
      if ftype == TType.STOP:
16645 
        break
16646 
      if fid == 0:
16647 
        if ftype == TType.MAP:
16648 
          self.success = {}
16649 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16650 
          for _i229 in xrange(_size225):
16651 
            _key230 = iprot.readString();
16652 
            _val231 = iprot.readString();
16653 
            self.success[_key230] = _val231
16654 
          iprot.readMapEnd()
16655 
        else:
16656 
          iprot.skip(ftype)
16657 
      else:
16658 
        iprot.skip(ftype)
16659 
      iprot.readFieldEnd()
16660 
    iprot.readStructEnd()
16661 
 
16662 
  def write(self, oprot):
16663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16665 
      return
16666 
    oprot.writeStructBegin('registerCounter_result')
16667 
    if self.success is not None:
16668 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16669 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16670 
      for kiter232,viter233 in self.success.items():
16671 
        oprot.writeString(kiter232)
16672 
        oprot.writeString(viter233)
16673 
      oprot.writeMapEnd()
16674 
      oprot.writeFieldEnd()
16675 
    oprot.writeFieldStop()
16676 
    oprot.writeStructEnd()
16677 
 
16678 
  def validate(self):
16679 
    return
16680 
 
16681 
 
16682 
  def __repr__(self):
16683 
    L = ['%s=%r' % (key, value)
16684 
      for key, value in self.__dict__.iteritems()]
16685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16686 
 
16687 
  def __eq__(self, other):
16688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16689 
 
16690 
  def __ne__(self, other):
16691 
    return not (self == other)
12722 amit.gupta 16692 
 
16693 
class searchCounter_args:
16694 
  """
16695 
  Attributes:
16696 
   - type1
16697 
   - searchString
16698 
  """
16699 
 
16700 
  thrift_spec = (
16701 
    None, # 0
16702 
    (1, TType.STRING, 'type1', None, None, ), # 1
16703 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16704 
  )
16705 
 
16706 
  def __init__(self, type1=None, searchString=None,):
16707 
    self.type1 = type1
16708 
    self.searchString = searchString
16709 
 
16710 
  def read(self, iprot):
16711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16713 
      return
16714 
    iprot.readStructBegin()
16715 
    while True:
16716 
      (fname, ftype, fid) = iprot.readFieldBegin()
16717 
      if ftype == TType.STOP:
16718 
        break
16719 
      if fid == 1:
16720 
        if ftype == TType.STRING:
16721 
          self.type1 = iprot.readString();
16722 
        else:
16723 
          iprot.skip(ftype)
16724 
      elif fid == 2:
16725 
        if ftype == TType.STRING:
16726 
          self.searchString = iprot.readString();
16727 
        else:
16728 
          iprot.skip(ftype)
16729 
      else:
16730 
        iprot.skip(ftype)
16731 
      iprot.readFieldEnd()
16732 
    iprot.readStructEnd()
16733 
 
16734 
  def write(self, oprot):
16735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16737 
      return
16738 
    oprot.writeStructBegin('searchCounter_args')
16739 
    if self.type1 is not None:
16740 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16741 
      oprot.writeString(self.type1)
16742 
      oprot.writeFieldEnd()
16743 
    if self.searchString is not None:
16744 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16745 
      oprot.writeString(self.searchString)
16746 
      oprot.writeFieldEnd()
16747 
    oprot.writeFieldStop()
16748 
    oprot.writeStructEnd()
16749 
 
16750 
  def validate(self):
16751 
    return
16752 
 
16753 
 
16754 
  def __repr__(self):
16755 
    L = ['%s=%r' % (key, value)
16756 
      for key, value in self.__dict__.iteritems()]
16757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16758 
 
16759 
  def __eq__(self, other):
16760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16761 
 
16762 
  def __ne__(self, other):
16763 
    return not (self == other)
16764 
 
16765 
class searchCounter_result:
16766 
  """
16767 
  Attributes:
16768 
   - success
16769 
  """
16770 
 
16771 
  thrift_spec = (
16772 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16773 
  )
16774 
 
16775 
  def __init__(self, success=None,):
16776 
    self.success = success
16777 
 
16778 
  def read(self, iprot):
16779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16781 
      return
16782 
    iprot.readStructBegin()
16783 
    while True:
16784 
      (fname, ftype, fid) = iprot.readFieldBegin()
16785 
      if ftype == TType.STOP:
16786 
        break
16787 
      if fid == 0:
16788 
        if ftype == TType.LIST:
16789 
          self.success = []
16790 
          (_etype237, _size234) = iprot.readListBegin()
16791 
          for _i238 in xrange(_size234):
16792 
            _elem239 = Counter()
16793 
            _elem239.read(iprot)
16794 
            self.success.append(_elem239)
16795 
          iprot.readListEnd()
16796 
        else:
16797 
          iprot.skip(ftype)
16798 
      else:
16799 
        iprot.skip(ftype)
16800 
      iprot.readFieldEnd()
16801 
    iprot.readStructEnd()
16802 
 
16803 
  def write(self, oprot):
16804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16806 
      return
16807 
    oprot.writeStructBegin('searchCounter_result')
16808 
    if self.success is not None:
16809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16811 
      for iter240 in self.success:
16812 
        iter240.write(oprot)
16813 
      oprot.writeListEnd()
16814 
      oprot.writeFieldEnd()
16815 
    oprot.writeFieldStop()
16816 
    oprot.writeStructEnd()
16817 
 
16818 
  def validate(self):
16819 
    return
16820 
 
16821 
 
16822 
  def __repr__(self):
16823 
    L = ['%s=%r' % (key, value)
16824 
      for key, value in self.__dict__.iteritems()]
16825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16826 
 
16827 
  def __eq__(self, other):
16828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16829 
 
16830 
  def __ne__(self, other):
16831 
    return not (self == other)
16832 
 
18977 amit.gupta 16833 
class getCounterByUserId_args:
16834 
  """
16835 
  Attributes:
16836 
   - userId
16837 
  """
16838 
 
16839 
  thrift_spec = (
16840 
    None, # 0
16841 
    (1, TType.I64, 'userId', None, None, ), # 1
16842 
  )
16843 
 
16844 
  def __init__(self, userId=None,):
16845 
    self.userId = userId
16846 
 
16847 
  def read(self, iprot):
16848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16850 
      return
16851 
    iprot.readStructBegin()
16852 
    while True:
16853 
      (fname, ftype, fid) = iprot.readFieldBegin()
16854 
      if ftype == TType.STOP:
16855 
        break
16856 
      if fid == 1:
16857 
        if ftype == TType.I64:
16858 
          self.userId = iprot.readI64();
16859 
        else:
16860 
          iprot.skip(ftype)
16861 
      else:
16862 
        iprot.skip(ftype)
16863 
      iprot.readFieldEnd()
16864 
    iprot.readStructEnd()
16865 
 
16866 
  def write(self, oprot):
16867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16869 
      return
16870 
    oprot.writeStructBegin('getCounterByUserId_args')
16871 
    if self.userId is not None:
16872 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16873 
      oprot.writeI64(self.userId)
16874 
      oprot.writeFieldEnd()
16875 
    oprot.writeFieldStop()
16876 
    oprot.writeStructEnd()
16877 
 
16878 
  def validate(self):
16879 
    return
16880 
 
16881 
 
16882 
  def __repr__(self):
16883 
    L = ['%s=%r' % (key, value)
16884 
      for key, value in self.__dict__.iteritems()]
16885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16886 
 
16887 
  def __eq__(self, other):
16888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16889 
 
16890 
  def __ne__(self, other):
16891 
    return not (self == other)
16892 
 
16893 
class getCounterByUserId_result:
16894 
  """
16895 
  Attributes:
16896 
   - success
16897 
  """
16898 
 
16899 
  thrift_spec = (
16900 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16901 
  )
16902 
 
16903 
  def __init__(self, success=None,):
16904 
    self.success = success
16905 
 
16906 
  def read(self, iprot):
16907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16909 
      return
16910 
    iprot.readStructBegin()
16911 
    while True:
16912 
      (fname, ftype, fid) = iprot.readFieldBegin()
16913 
      if ftype == TType.STOP:
16914 
        break
16915 
      if fid == 0:
16916 
        if ftype == TType.STRUCT:
16917 
          self.success = Counter()
16918 
          self.success.read(iprot)
16919 
        else:
16920 
          iprot.skip(ftype)
16921 
      else:
16922 
        iprot.skip(ftype)
16923 
      iprot.readFieldEnd()
16924 
    iprot.readStructEnd()
16925 
 
16926 
  def write(self, oprot):
16927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16929 
      return
16930 
    oprot.writeStructBegin('getCounterByUserId_result')
16931 
    if self.success is not None:
16932 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16933 
      self.success.write(oprot)
16934 
      oprot.writeFieldEnd()
16935 
    oprot.writeFieldStop()
16936 
    oprot.writeStructEnd()
16937 
 
16938 
  def validate(self):
16939 
    return
16940 
 
16941 
 
16942 
  def __repr__(self):
16943 
    L = ['%s=%r' % (key, value)
16944 
      for key, value in self.__dict__.iteritems()]
16945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16946 
 
16947 
  def __eq__(self, other):
16948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16949 
 
16950 
  def __ne__(self, other):
16951 
    return not (self == other)
16952 
 
12722 amit.gupta 16953 
class getAllUsersByCounter_args:
16954 
  """
16955 
  Attributes:
16956 
   - counterId
16957 
  """
16958 
 
16959 
  thrift_spec = (
16960 
    None, # 0
16961 
    (1, TType.I64, 'counterId', None, None, ), # 1
16962 
  )
16963 
 
16964 
  def __init__(self, counterId=None,):
16965 
    self.counterId = counterId
16966 
 
16967 
  def read(self, iprot):
16968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16970 
      return
16971 
    iprot.readStructBegin()
16972 
    while True:
16973 
      (fname, ftype, fid) = iprot.readFieldBegin()
16974 
      if ftype == TType.STOP:
16975 
        break
16976 
      if fid == 1:
16977 
        if ftype == TType.I64:
16978 
          self.counterId = iprot.readI64();
16979 
        else:
16980 
          iprot.skip(ftype)
16981 
      else:
16982 
        iprot.skip(ftype)
16983 
      iprot.readFieldEnd()
16984 
    iprot.readStructEnd()
16985 
 
16986 
  def write(self, oprot):
16987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16989 
      return
16990 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16991 
    if self.counterId is not None:
16992 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16993 
      oprot.writeI64(self.counterId)
16994 
      oprot.writeFieldEnd()
16995 
    oprot.writeFieldStop()
16996 
    oprot.writeStructEnd()
16997 
 
16998 
  def validate(self):
16999 
    return
17000 
 
17001 
 
17002 
  def __repr__(self):
17003 
    L = ['%s=%r' % (key, value)
17004 
      for key, value in self.__dict__.iteritems()]
17005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17006 
 
17007 
  def __eq__(self, other):
17008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17009 
 
17010 
  def __ne__(self, other):
17011 
    return not (self == other)
17012 
 
17013 
class getAllUsersByCounter_result:
17014 
  """
17015 
  Attributes:
17016 
   - success
17017 
  """
17018 
 
17019 
  thrift_spec = (
17020 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
17021 
  )
17022 
 
17023 
  def __init__(self, success=None,):
17024 
    self.success = success
17025 
 
17026 
  def read(self, iprot):
17027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17029 
      return
17030 
    iprot.readStructBegin()
17031 
    while True:
17032 
      (fname, ftype, fid) = iprot.readFieldBegin()
17033 
      if ftype == TType.STOP:
17034 
        break
17035 
      if fid == 0:
17036 
        if ftype == TType.LIST:
17037 
          self.success = []
17038 
          (_etype244, _size241) = iprot.readListBegin()
17039 
          for _i245 in xrange(_size241):
17040 
            _elem246 = User()
17041 
            _elem246.read(iprot)
17042 
            self.success.append(_elem246)
17043 
          iprot.readListEnd()
17044 
        else:
17045 
          iprot.skip(ftype)
17046 
      else:
17047 
        iprot.skip(ftype)
17048 
      iprot.readFieldEnd()
17049 
    iprot.readStructEnd()
17050 
 
17051 
  def write(self, oprot):
17052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17054 
      return
17055 
    oprot.writeStructBegin('getAllUsersByCounter_result')
17056 
    if self.success is not None:
17057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17059 
      for iter247 in self.success:
17060 
        iter247.write(oprot)
17061 
      oprot.writeListEnd()
17062 
      oprot.writeFieldEnd()
17063 
    oprot.writeFieldStop()
17064 
    oprot.writeStructEnd()
17065 
 
17066 
  def validate(self):
17067 
    return
17068 
 
17069 
 
17070 
  def __repr__(self):
17071 
    L = ['%s=%r' % (key, value)
17072 
      for key, value in self.__dict__.iteritems()]
17073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17074 
 
17075 
  def __eq__(self, other):
17076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17077 
 
17078 
  def __ne__(self, other):
17079 
    return not (self == other)
15251 manish.sha 17080 
 
17081 
class getActiveAccessTokenForUser_args:
17082 
  """
17083 
  Attributes:
17084 
   - userId
17085 
   - source
17086 
  """
17087 
 
17088 
  thrift_spec = (
17089 
    None, # 0
17090 
    (1, TType.I64, 'userId', None, None, ), # 1
17091 
    (2, TType.STRING, 'source', None, None, ), # 2
17092 
  )
17093 
 
17094 
  def __init__(self, userId=None, source=None,):
17095 
    self.userId = userId
17096 
    self.source = source
17097 
 
17098 
  def read(self, iprot):
17099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17101 
      return
17102 
    iprot.readStructBegin()
17103 
    while True:
17104 
      (fname, ftype, fid) = iprot.readFieldBegin()
17105 
      if ftype == TType.STOP:
17106 
        break
17107 
      if fid == 1:
17108 
        if ftype == TType.I64:
17109 
          self.userId = iprot.readI64();
17110 
        else:
17111 
          iprot.skip(ftype)
17112 
      elif fid == 2:
17113 
        if ftype == TType.STRING:
17114 
          self.source = iprot.readString();
17115 
        else:
17116 
          iprot.skip(ftype)
17117 
      else:
17118 
        iprot.skip(ftype)
17119 
      iprot.readFieldEnd()
17120 
    iprot.readStructEnd()
17121 
 
17122 
  def write(self, oprot):
17123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17125 
      return
17126 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
17127 
    if self.userId is not None:
17128 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17129 
      oprot.writeI64(self.userId)
17130 
      oprot.writeFieldEnd()
17131 
    if self.source is not None:
17132 
      oprot.writeFieldBegin('source', TType.STRING, 2)
17133 
      oprot.writeString(self.source)
17134 
      oprot.writeFieldEnd()
17135 
    oprot.writeFieldStop()
17136 
    oprot.writeStructEnd()
17137 
 
17138 
  def validate(self):
17139 
    return
17140 
 
17141 
 
17142 
  def __repr__(self):
17143 
    L = ['%s=%r' % (key, value)
17144 
      for key, value in self.__dict__.iteritems()]
17145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17146 
 
17147 
  def __eq__(self, other):
17148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17149 
 
17150 
  def __ne__(self, other):
17151 
    return not (self == other)
17152 
 
17153 
class getActiveAccessTokenForUser_result:
17154 
  """
17155 
  Attributes:
17156 
   - success
17157 
  """
17158 
 
17159 
  thrift_spec = (
17160 
    (0, TType.STRING, 'success', None, None, ), # 0
17161 
  )
17162 
 
17163 
  def __init__(self, success=None,):
17164 
    self.success = success
17165 
 
17166 
  def read(self, iprot):
17167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17169 
      return
17170 
    iprot.readStructBegin()
17171 
    while True:
17172 
      (fname, ftype, fid) = iprot.readFieldBegin()
17173 
      if ftype == TType.STOP:
17174 
        break
17175 
      if fid == 0:
17176 
        if ftype == TType.STRING:
17177 
          self.success = iprot.readString();
17178 
        else:
17179 
          iprot.skip(ftype)
17180 
      else:
17181 
        iprot.skip(ftype)
17182 
      iprot.readFieldEnd()
17183 
    iprot.readStructEnd()
17184 
 
17185 
  def write(self, oprot):
17186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17188 
      return
17189 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
17190 
    if self.success is not None:
17191 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17192 
      oprot.writeString(self.success)
17193 
      oprot.writeFieldEnd()
17194 
    oprot.writeFieldStop()
17195 
    oprot.writeStructEnd()
17196 
 
17197 
  def validate(self):
17198 
    return
17199 
 
17200 
 
17201 
  def __repr__(self):
17202 
    L = ['%s=%r' % (key, value)
17203 
      for key, value in self.__dict__.iteritems()]
17204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17205 
 
17206 
  def __eq__(self, other):
17207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17208 
 
17209 
  def __ne__(self, other):
17210 
    return not (self == other)
17211 
 
17212 
class validateAccessToken_args:
17213 
  """
17214 
  Attributes:
17215 
   - accessToken
17216 
  """
17217 
 
17218 
  thrift_spec = (
17219 
    None, # 0
17220 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
17221 
  )
17222 
 
17223 
  def __init__(self, accessToken=None,):
17224 
    self.accessToken = accessToken
17225 
 
17226 
  def read(self, iprot):
17227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17229 
      return
17230 
    iprot.readStructBegin()
17231 
    while True:
17232 
      (fname, ftype, fid) = iprot.readFieldBegin()
17233 
      if ftype == TType.STOP:
17234 
        break
17235 
      if fid == 1:
17236 
        if ftype == TType.STRING:
17237 
          self.accessToken = iprot.readString();
17238 
        else:
17239 
          iprot.skip(ftype)
17240 
      else:
17241 
        iprot.skip(ftype)
17242 
      iprot.readFieldEnd()
17243 
    iprot.readStructEnd()
17244 
 
17245 
  def write(self, oprot):
17246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17248 
      return
17249 
    oprot.writeStructBegin('validateAccessToken_args')
17250 
    if self.accessToken is not None:
17251 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
17252 
      oprot.writeString(self.accessToken)
17253 
      oprot.writeFieldEnd()
17254 
    oprot.writeFieldStop()
17255 
    oprot.writeStructEnd()
17256 
 
17257 
  def validate(self):
17258 
    return
17259 
 
17260 
 
17261 
  def __repr__(self):
17262 
    L = ['%s=%r' % (key, value)
17263 
      for key, value in self.__dict__.iteritems()]
17264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17265 
 
17266 
  def __eq__(self, other):
17267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17268 
 
17269 
  def __ne__(self, other):
17270 
    return not (self == other)
17271 
 
17272 
class validateAccessToken_result:
17273 
  """
17274 
  Attributes:
17275 
   - success
17276 
  """
17277 
 
17278 
  thrift_spec = (
17279 
    (0, TType.BOOL, 'success', None, None, ), # 0
17280 
  )
17281 
 
17282 
  def __init__(self, success=None,):
17283 
    self.success = success
17284 
 
17285 
  def read(self, iprot):
17286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17288 
      return
17289 
    iprot.readStructBegin()
17290 
    while True:
17291 
      (fname, ftype, fid) = iprot.readFieldBegin()
17292 
      if ftype == TType.STOP:
17293 
        break
17294 
      if fid == 0:
17295 
        if ftype == TType.BOOL:
17296 
          self.success = iprot.readBool();
17297 
        else:
17298 
          iprot.skip(ftype)
17299 
      else:
17300 
        iprot.skip(ftype)
17301 
      iprot.readFieldEnd()
17302 
    iprot.readStructEnd()
17303 
 
17304 
  def write(self, oprot):
17305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17307 
      return
17308 
    oprot.writeStructBegin('validateAccessToken_result')
17309 
    if self.success is not None:
17310 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17311 
      oprot.writeBool(self.success)
17312 
      oprot.writeFieldEnd()
17313 
    oprot.writeFieldStop()
17314 
    oprot.writeStructEnd()
17315 
 
17316 
  def validate(self):
17317 
    return
17318 
 
17319 
 
17320 
  def __repr__(self):
17321 
    L = ['%s=%r' % (key, value)
17322 
      for key, value in self.__dict__.iteritems()]
17323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17324 
 
17325 
  def __eq__(self, other):
17326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17327 
 
17328 
  def __ne__(self, other):
17329 
    return not (self == other)
17782 amit.gupta 17330 
 
17331 
class addItemsToCart_args:
17332 
  """
17333 
  Attributes:
17334 
   - cartId
17335 
   - itemQty
17336 
   - couponCode
17337 
  """
17338 
 
17339 
  thrift_spec = (
17340 
    None, # 0
17341 
    (1, TType.I64, 'cartId', None, None, ), # 1
17342 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
17343 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
17344 
  )
17345 
 
17346 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
17347 
    self.cartId = cartId
17348 
    self.itemQty = itemQty
17349 
    self.couponCode = couponCode
17350 
 
17351 
  def read(self, iprot):
17352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17354 
      return
17355 
    iprot.readStructBegin()
17356 
    while True:
17357 
      (fname, ftype, fid) = iprot.readFieldBegin()
17358 
      if ftype == TType.STOP:
17359 
        break
17360 
      if fid == 1:
17361 
        if ftype == TType.I64:
17362 
          self.cartId = iprot.readI64();
17363 
        else:
17364 
          iprot.skip(ftype)
17365 
      elif fid == 2:
17366 
        if ftype == TType.LIST:
17367 
          self.itemQty = []
17368 
          (_etype251, _size248) = iprot.readListBegin()
17369 
          for _i252 in xrange(_size248):
17370 
            _elem253 = ItemQuantity()
17371 
            _elem253.read(iprot)
17372 
            self.itemQty.append(_elem253)
17373 
          iprot.readListEnd()
17374 
        else:
17375 
          iprot.skip(ftype)
17376 
      elif fid == 3:
17377 
        if ftype == TType.STRING:
17378 
          self.couponCode = iprot.readString();
17379 
        else:
17380 
          iprot.skip(ftype)
17381 
      else:
17382 
        iprot.skip(ftype)
17383 
      iprot.readFieldEnd()
17384 
    iprot.readStructEnd()
17385 
 
17386 
  def write(self, oprot):
17387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17389 
      return
17390 
    oprot.writeStructBegin('addItemsToCart_args')
17391 
    if self.cartId is not None:
17392 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17393 
      oprot.writeI64(self.cartId)
17394 
      oprot.writeFieldEnd()
17395 
    if self.itemQty is not None:
17396 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
17397 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
17398 
      for iter254 in self.itemQty:
17399 
        iter254.write(oprot)
17400 
      oprot.writeListEnd()
17401 
      oprot.writeFieldEnd()
17402 
    if self.couponCode is not None:
17403 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
17404 
      oprot.writeString(self.couponCode)
17405 
      oprot.writeFieldEnd()
17406 
    oprot.writeFieldStop()
17407 
    oprot.writeStructEnd()
17408 
 
17409 
  def validate(self):
17410 
    return
17411 
 
17412 
 
17413 
  def __repr__(self):
17414 
    L = ['%s=%r' % (key, value)
17415 
      for key, value in self.__dict__.iteritems()]
17416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17417 
 
17418 
  def __eq__(self, other):
17419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17420 
 
17421 
  def __ne__(self, other):
17422 
    return not (self == other)
17423 
 
17424 
class addItemsToCart_result:
17425 
  """
17426 
  Attributes:
17427 
   - success
17428 
  """
17429 
 
17430 
  thrift_spec = (
17431 
    (0, TType.BOOL, 'success', None, None, ), # 0
17432 
  )
17433 
 
17434 
  def __init__(self, success=None,):
17435 
    self.success = success
17436 
 
17437 
  def read(self, iprot):
17438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17440 
      return
17441 
    iprot.readStructBegin()
17442 
    while True:
17443 
      (fname, ftype, fid) = iprot.readFieldBegin()
17444 
      if ftype == TType.STOP:
17445 
        break
17446 
      if fid == 0:
17447 
        if ftype == TType.BOOL:
17448 
          self.success = iprot.readBool();
17449 
        else:
17450 
          iprot.skip(ftype)
17451 
      else:
17452 
        iprot.skip(ftype)
17453 
      iprot.readFieldEnd()
17454 
    iprot.readStructEnd()
17455 
 
17456 
  def write(self, oprot):
17457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17459 
      return
17460 
    oprot.writeStructBegin('addItemsToCart_result')
17461 
    if self.success is not None:
17462 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17463 
      oprot.writeBool(self.success)
17464 
      oprot.writeFieldEnd()
17465 
    oprot.writeFieldStop()
17466 
    oprot.writeStructEnd()
17467 
 
17468 
  def validate(self):
17469 
    return
17470 
 
17471 
 
17472 
  def __repr__(self):
17473 
    L = ['%s=%r' % (key, value)
17474 
      for key, value in self.__dict__.iteritems()]
17475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17476 
 
17477 
  def __eq__(self, other):
17478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17479 
 
17480 
  def __ne__(self, other):
17481 
    return not (self == other)
17482 
 
17483 
class validateCartNew_args:
17484 
  """
17485 
  Attributes:
17486 
   - cartId
17487 
   - pinCode
17488 
   - sourceId
17489 
  """
17490 
 
17491 
  thrift_spec = (
17492 
    None, # 0
17493 
    (1, TType.I64, 'cartId', None, None, ), # 1
17494 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
17495 
    (3, TType.I64, 'sourceId', None, None, ), # 3
17496 
  )
17497 
 
17498 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
17499 
    self.cartId = cartId
17500 
    self.pinCode = pinCode
17501 
    self.sourceId = sourceId
17502 
 
17503 
  def read(self, iprot):
17504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17506 
      return
17507 
    iprot.readStructBegin()
17508 
    while True:
17509 
      (fname, ftype, fid) = iprot.readFieldBegin()
17510 
      if ftype == TType.STOP:
17511 
        break
17512 
      if fid == 1:
17513 
        if ftype == TType.I64:
17514 
          self.cartId = iprot.readI64();
17515 
        else:
17516 
          iprot.skip(ftype)
17517 
      elif fid == 2:
17518 
        if ftype == TType.STRING:
17519 
          self.pinCode = iprot.readString();
17520 
        else:
17521 
          iprot.skip(ftype)
17522 
      elif fid == 3:
17523 
        if ftype == TType.I64:
17524 
          self.sourceId = iprot.readI64();
17525 
        else:
17526 
          iprot.skip(ftype)
17527 
      else:
17528 
        iprot.skip(ftype)
17529 
      iprot.readFieldEnd()
17530 
    iprot.readStructEnd()
17531 
 
17532 
  def write(self, oprot):
17533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17535 
      return
17536 
    oprot.writeStructBegin('validateCartNew_args')
17537 
    if self.cartId is not None:
17538 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17539 
      oprot.writeI64(self.cartId)
17540 
      oprot.writeFieldEnd()
17541 
    if self.pinCode is not None:
17542 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17543 
      oprot.writeString(self.pinCode)
17544 
      oprot.writeFieldEnd()
17545 
    if self.sourceId is not None:
17546 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17547 
      oprot.writeI64(self.sourceId)
17548 
      oprot.writeFieldEnd()
17549 
    oprot.writeFieldStop()
17550 
    oprot.writeStructEnd()
17551 
 
17552 
  def validate(self):
17553 
    return
17554 
 
17555 
 
17556 
  def __repr__(self):
17557 
    L = ['%s=%r' % (key, value)
17558 
      for key, value in self.__dict__.iteritems()]
17559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17560 
 
17561 
  def __eq__(self, other):
17562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17563 
 
17564 
  def __ne__(self, other):
17565 
    return not (self == other)
17566 
 
17567 
class validateCartNew_result:
17568 
  """
17569 
  Attributes:
17570 
   - success
17571 
  """
17572 
 
17573 
  thrift_spec = (
17574 
    (0, TType.STRING, 'success', None, None, ), # 0
17575 
  )
17576 
 
17577 
  def __init__(self, success=None,):
17578 
    self.success = success
17579 
 
17580 
  def read(self, iprot):
17581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17583 
      return
17584 
    iprot.readStructBegin()
17585 
    while True:
17586 
      (fname, ftype, fid) = iprot.readFieldBegin()
17587 
      if ftype == TType.STOP:
17588 
        break
17589 
      if fid == 0:
17590 
        if ftype == TType.STRING:
17591 
          self.success = iprot.readString();
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('validateCartNew_result')
17604 
    if self.success is not None:
17605 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17606 
      oprot.writeString(self.success)
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)
18530 manish.sha 17625 
 
18644 manish.sha 17626 
class isAddressEditableForCounter_args:
18530 manish.sha 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
18644 manish.sha 17663 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 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 
 
18644 manish.sha 17686 
class isAddressEditableForCounter_result:
18530 manish.sha 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
18644 manish.sha 17722 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 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)
17744 
 
17745 
class getBillingAddressForUser_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('getBillingAddressForUser_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 getBillingAddressForUser_result:
17806 
  """
17807 
  Attributes:
17808 
   - success
17809 
  """
17810 
 
17811 
  thrift_spec = (
17812 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), 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.STRUCT:
17829 
          self.success = Address()
17830 
          self.success.read(iprot)
17831 
        else:
17832 
          iprot.skip(ftype)
17833 
      else:
17834 
        iprot.skip(ftype)
17835 
      iprot.readFieldEnd()
17836 
    iprot.readStructEnd()
17837 
 
17838 
  def write(self, oprot):
17839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17841 
      return
17842 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17843 
    if self.success is not None:
17844 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17845 
      self.success.write(oprot)
17846 
      oprot.writeFieldEnd()
17847 
    oprot.writeFieldStop()
17848 
    oprot.writeStructEnd()
17849 
 
17850 
  def validate(self):
17851 
    return
17852 
 
17853 
 
17854 
  def __repr__(self):
17855 
    L = ['%s=%r' % (key, value)
17856 
      for key, value in self.__dict__.iteritems()]
17857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17858 
 
17859 
  def __eq__(self, other):
17860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17861 
 
17862 
  def __ne__(self, other):
17863 
    return not (self == other)
18590 manish.sha 17864 
 
17865 
class isCreditorAssigned_args:
17866 
  """
17867 
  Attributes:
17868 
   - userId
17869 
  """
17870 
 
17871 
  thrift_spec = (
17872 
    None, # 0
17873 
    (1, TType.I64, 'userId', None, None, ), # 1
17874 
  )
17875 
 
17876 
  def __init__(self, userId=None,):
17877 
    self.userId = userId
17878 
 
17879 
  def read(self, iprot):
17880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17882 
      return
17883 
    iprot.readStructBegin()
17884 
    while True:
17885 
      (fname, ftype, fid) = iprot.readFieldBegin()
17886 
      if ftype == TType.STOP:
17887 
        break
17888 
      if fid == 1:
17889 
        if ftype == TType.I64:
17890 
          self.userId = iprot.readI64();
17891 
        else:
17892 
          iprot.skip(ftype)
17893 
      else:
17894 
        iprot.skip(ftype)
17895 
      iprot.readFieldEnd()
17896 
    iprot.readStructEnd()
17897 
 
17898 
  def write(self, oprot):
17899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17901 
      return
17902 
    oprot.writeStructBegin('isCreditorAssigned_args')
17903 
    if self.userId is not None:
17904 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17905 
      oprot.writeI64(self.userId)
17906 
      oprot.writeFieldEnd()
17907 
    oprot.writeFieldStop()
17908 
    oprot.writeStructEnd()
17909 
 
17910 
  def validate(self):
17911 
    return
17912 
 
17913 
 
17914 
  def __repr__(self):
17915 
    L = ['%s=%r' % (key, value)
17916 
      for key, value in self.__dict__.iteritems()]
17917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17918 
 
17919 
  def __eq__(self, other):
17920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17921 
 
17922 
  def __ne__(self, other):
17923 
    return not (self == other)
17924 
 
17925 
class isCreditorAssigned_result:
17926 
  """
17927 
  Attributes:
17928 
   - success
17929 
  """
17930 
 
17931 
  thrift_spec = (
17932 
    (0, TType.BOOL, 'success', None, None, ), # 0
17933 
  )
17934 
 
17935 
  def __init__(self, success=None,):
17936 
    self.success = success
17937 
 
17938 
  def read(self, iprot):
17939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17941 
      return
17942 
    iprot.readStructBegin()
17943 
    while True:
17944 
      (fname, ftype, fid) = iprot.readFieldBegin()
17945 
      if ftype == TType.STOP:
17946 
        break
17947 
      if fid == 0:
17948 
        if ftype == TType.BOOL:
17949 
          self.success = iprot.readBool();
17950 
        else:
17951 
          iprot.skip(ftype)
17952 
      else:
17953 
        iprot.skip(ftype)
17954 
      iprot.readFieldEnd()
17955 
    iprot.readStructEnd()
17956 
 
17957 
  def write(self, oprot):
17958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17960 
      return
17961 
    oprot.writeStructBegin('isCreditorAssigned_result')
17962 
    if self.success is not None:
17963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17964 
      oprot.writeBool(self.success)
17965 
      oprot.writeFieldEnd()
17966 
    oprot.writeFieldStop()
17967 
    oprot.writeStructEnd()
17968 
 
17969 
  def validate(self):
17970 
    return
17971 
 
17972 
 
17973 
  def __repr__(self):
17974 
    L = ['%s=%r' % (key, value)
17975 
      for key, value in self.__dict__.iteritems()]
17976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17977 
 
17978 
  def __eq__(self, other):
17979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17980 
 
17981 
  def __ne__(self, other):
17982 
    return not (self == other)
18735 manish.sha 17983 
 
17984 
class isTaxInvoiceEnabledUser_args:
17985 
  """
17986 
  Attributes:
17987 
   - userId
17988 
  """
17989 
 
17990 
  thrift_spec = (
17991 
    None, # 0
17992 
    (1, TType.I64, 'userId', None, None, ), # 1
17993 
  )
17994 
 
17995 
  def __init__(self, userId=None,):
17996 
    self.userId = userId
17997 
 
17998 
  def read(self, iprot):
17999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18001 
      return
18002 
    iprot.readStructBegin()
18003 
    while True:
18004 
      (fname, ftype, fid) = iprot.readFieldBegin()
18005 
      if ftype == TType.STOP:
18006 
        break
18007 
      if fid == 1:
18008 
        if ftype == TType.I64:
18009 
          self.userId = iprot.readI64();
18010 
        else:
18011 
          iprot.skip(ftype)
18012 
      else:
18013 
        iprot.skip(ftype)
18014 
      iprot.readFieldEnd()
18015 
    iprot.readStructEnd()
18016 
 
18017 
  def write(self, oprot):
18018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18020 
      return
18021 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
18022 
    if self.userId is not None:
18023 
      oprot.writeFieldBegin('userId', TType.I64, 1)
18024 
      oprot.writeI64(self.userId)
18025 
      oprot.writeFieldEnd()
18026 
    oprot.writeFieldStop()
18027 
    oprot.writeStructEnd()
18028 
 
18029 
  def validate(self):
18030 
    return
18031 
 
18032 
 
18033 
  def __repr__(self):
18034 
    L = ['%s=%r' % (key, value)
18035 
      for key, value in self.__dict__.iteritems()]
18036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18037 
 
18038 
  def __eq__(self, other):
18039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18040 
 
18041 
  def __ne__(self, other):
18042 
    return not (self == other)
18043 
 
18044 
class isTaxInvoiceEnabledUser_result:
18045 
  """
18046 
  Attributes:
18047 
   - success
18048 
  """
18049 
 
18050 
  thrift_spec = (
18051 
    (0, TType.BOOL, 'success', None, None, ), # 0
18052 
  )
18053 
 
18054 
  def __init__(self, success=None,):
18055 
    self.success = success
18056 
 
18057 
  def read(self, iprot):
18058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18060 
      return
18061 
    iprot.readStructBegin()
18062 
    while True:
18063 
      (fname, ftype, fid) = iprot.readFieldBegin()
18064 
      if ftype == TType.STOP:
18065 
        break
18066 
      if fid == 0:
18067 
        if ftype == TType.BOOL:
18068 
          self.success = iprot.readBool();
18069 
        else:
18070 
          iprot.skip(ftype)
18071 
      else:
18072 
        iprot.skip(ftype)
18073 
      iprot.readFieldEnd()
18074 
    iprot.readStructEnd()
18075 
 
18076 
  def write(self, oprot):
18077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18079 
      return
18080 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
18081 
    if self.success is not None:
18082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18083 
      oprot.writeBool(self.success)
18084 
      oprot.writeFieldEnd()
18085 
    oprot.writeFieldStop()
18086 
    oprot.writeStructEnd()
18087 
 
18088 
  def validate(self):
18089 
    return
18090 
 
18091 
 
18092 
  def __repr__(self):
18093 
    L = ['%s=%r' % (key, value)
18094 
      for key, value in self.__dict__.iteritems()]
18095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18096 
 
18097 
  def __eq__(self, other):
18098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18099 
 
18100 
  def __ne__(self, other):
18101 
    return not (self == other)
18764 kshitij.so 18102 
 
19182 amit.gupta 18103 
class taxInvoiceAvailable_args:
18104 
  """
18105 
  Attributes:
18106 
   - addressId
18107 
  """
18108 
 
18109 
  thrift_spec = (
18110 
    None, # 0
18111 
    (1, TType.I64, 'addressId', None, None, ), # 1
18112 
  )
18113 
 
18114 
  def __init__(self, addressId=None,):
18115 
    self.addressId = addressId
18116 
 
18117 
  def read(self, iprot):
18118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18120 
      return
18121 
    iprot.readStructBegin()
18122 
    while True:
18123 
      (fname, ftype, fid) = iprot.readFieldBegin()
18124 
      if ftype == TType.STOP:
18125 
        break
18126 
      if fid == 1:
18127 
        if ftype == TType.I64:
18128 
          self.addressId = iprot.readI64();
18129 
        else:
18130 
          iprot.skip(ftype)
18131 
      else:
18132 
        iprot.skip(ftype)
18133 
      iprot.readFieldEnd()
18134 
    iprot.readStructEnd()
18135 
 
18136 
  def write(self, oprot):
18137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18139 
      return
18140 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
18141 
    if self.addressId is not None:
18142 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
18143 
      oprot.writeI64(self.addressId)
18144 
      oprot.writeFieldEnd()
18145 
    oprot.writeFieldStop()
18146 
    oprot.writeStructEnd()
18147 
 
18148 
  def validate(self):
18149 
    return
18150 
 
18151 
 
18152 
  def __repr__(self):
18153 
    L = ['%s=%r' % (key, value)
18154 
      for key, value in self.__dict__.iteritems()]
18155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18156 
 
18157 
  def __eq__(self, other):
18158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18159 
 
18160 
  def __ne__(self, other):
18161 
    return not (self == other)
18162 
 
18163 
class taxInvoiceAvailable_result:
18164 
  """
18165 
  Attributes:
18166 
   - success
18167 
  """
18168 
 
18169 
  thrift_spec = (
18170 
    (0, TType.BOOL, 'success', None, None, ), # 0
18171 
  )
18172 
 
18173 
  def __init__(self, success=None,):
18174 
    self.success = success
18175 
 
18176 
  def read(self, iprot):
18177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18179 
      return
18180 
    iprot.readStructBegin()
18181 
    while True:
18182 
      (fname, ftype, fid) = iprot.readFieldBegin()
18183 
      if ftype == TType.STOP:
18184 
        break
18185 
      if fid == 0:
18186 
        if ftype == TType.BOOL:
18187 
          self.success = iprot.readBool();
18188 
        else:
18189 
          iprot.skip(ftype)
18190 
      else:
18191 
        iprot.skip(ftype)
18192 
      iprot.readFieldEnd()
18193 
    iprot.readStructEnd()
18194 
 
18195 
  def write(self, oprot):
18196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18198 
      return
18199 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
18200 
    if self.success is not None:
18201 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18202 
      oprot.writeBool(self.success)
18203 
      oprot.writeFieldEnd()
18204 
    oprot.writeFieldStop()
18205 
    oprot.writeStructEnd()
18206 
 
18207 
  def validate(self):
18208 
    return
18209 
 
18210 
 
18211 
  def __repr__(self):
18212 
    L = ['%s=%r' % (key, value)
18213 
      for key, value in self.__dict__.iteritems()]
18214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18215 
 
18216 
  def __eq__(self, other):
18217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18218 
 
18219 
  def __ne__(self, other):
18220 
    return not (self == other)
18221 
 
18764 kshitij.so 18222 
class getCartByValue_args:
18223 
  """
18224 
  Attributes:
18225 
   - cartIds
18226 
  """
18227 
 
18228 
  thrift_spec = (
18229 
    None, # 0
18230 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
18231 
  )
18232 
 
18233 
  def __init__(self, cartIds=None,):
18234 
    self.cartIds = cartIds
18235 
 
18236 
  def read(self, iprot):
18237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18239 
      return
18240 
    iprot.readStructBegin()
18241 
    while True:
18242 
      (fname, ftype, fid) = iprot.readFieldBegin()
18243 
      if ftype == TType.STOP:
18244 
        break
18245 
      if fid == 1:
18246 
        if ftype == TType.LIST:
18247 
          self.cartIds = []
18248 
          (_etype258, _size255) = iprot.readListBegin()
18249 
          for _i259 in xrange(_size255):
18250 
            _elem260 = iprot.readI64();
18251 
            self.cartIds.append(_elem260)
18252 
          iprot.readListEnd()
18253 
        else:
18254 
          iprot.skip(ftype)
18255 
      else:
18256 
        iprot.skip(ftype)
18257 
      iprot.readFieldEnd()
18258 
    iprot.readStructEnd()
18259 
 
18260 
  def write(self, oprot):
18261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18263 
      return
18264 
    oprot.writeStructBegin('getCartByValue_args')
18265 
    if self.cartIds is not None:
18266 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
18267 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
18268 
      for iter261 in self.cartIds:
18269 
        oprot.writeI64(iter261)
18270 
      oprot.writeListEnd()
18271 
      oprot.writeFieldEnd()
18272 
    oprot.writeFieldStop()
18273 
    oprot.writeStructEnd()
18274 
 
18275 
  def validate(self):
18276 
    return
18277 
 
18278 
 
18279 
  def __repr__(self):
18280 
    L = ['%s=%r' % (key, value)
18281 
      for key, value in self.__dict__.iteritems()]
18282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18283 
 
18284 
  def __eq__(self, other):
18285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18286 
 
18287 
  def __ne__(self, other):
18288 
    return not (self == other)
18289 
 
18290 
class getCartByValue_result:
18291 
  """
18292 
  Attributes:
18293 
   - success
18294 
  """
18295 
 
18296 
  thrift_spec = (
18297 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
18298 
  )
18299 
 
18300 
  def __init__(self, success=None,):
18301 
    self.success = success
18302 
 
18303 
  def read(self, iprot):
18304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18306 
      return
18307 
    iprot.readStructBegin()
18308 
    while True:
18309 
      (fname, ftype, fid) = iprot.readFieldBegin()
18310 
      if ftype == TType.STOP:
18311 
        break
18312 
      if fid == 0:
18313 
        if ftype == TType.MAP:
18314 
          self.success = {}
18315 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
18316 
          for _i266 in xrange(_size262):
18317 
            _key267 = iprot.readI64();
18318 
            _val268 = []
18319 
            (_etype272, _size269) = iprot.readListBegin()
18320 
            for _i273 in xrange(_size269):
18321 
              _elem274 = Line()
18322 
              _elem274.read(iprot)
18323 
              _val268.append(_elem274)
18324 
            iprot.readListEnd()
18325 
            self.success[_key267] = _val268
18326 
          iprot.readMapEnd()
18327 
        else:
18328 
          iprot.skip(ftype)
18329 
      else:
18330 
        iprot.skip(ftype)
18331 
      iprot.readFieldEnd()
18332 
    iprot.readStructEnd()
18333 
 
18334 
  def write(self, oprot):
18335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18337 
      return
18338 
    oprot.writeStructBegin('getCartByValue_result')
18339 
    if self.success is not None:
18340 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18341 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
18342 
      for kiter275,viter276 in self.success.items():
18343 
        oprot.writeI64(kiter275)
18344 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
18345 
        for iter277 in viter276:
18346 
          iter277.write(oprot)
18347 
        oprot.writeListEnd()
18348 
      oprot.writeMapEnd()
18349 
      oprot.writeFieldEnd()
18350 
    oprot.writeFieldStop()
18351 
    oprot.writeStructEnd()
18352 
 
18353 
  def validate(self):
18354 
    return
18355 
 
18356 
 
18357 
  def __repr__(self):
18358 
    L = ['%s=%r' % (key, value)
18359 
      for key, value in self.__dict__.iteritems()]
18360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18361 
 
18362 
  def __eq__(self, other):
18363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18364 
 
18365 
  def __ne__(self, other):
18366 
    return not (self == other)
19889 manas 18367 
 
18368 
class getCounterName_args:
18369 
  """
18370 
  Attributes:
18371 
   - userIds
18372 
  """
18373 
 
18374 
  thrift_spec = (
18375 
    None, # 0
18376 
    (1, TType.LIST, 'userIds', (TType.I64,None), None, ), # 1
18377 
  )
18378 
 
18379 
  def __init__(self, userIds=None,):
18380 
    self.userIds = userIds
18381 
 
18382 
  def read(self, iprot):
18383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18385 
      return
18386 
    iprot.readStructBegin()
18387 
    while True:
18388 
      (fname, ftype, fid) = iprot.readFieldBegin()
18389 
      if ftype == TType.STOP:
18390 
        break
18391 
      if fid == 1:
18392 
        if ftype == TType.LIST:
18393 
          self.userIds = []
18394 
          (_etype281, _size278) = iprot.readListBegin()
18395 
          for _i282 in xrange(_size278):
18396 
            _elem283 = iprot.readI64();
18397 
            self.userIds.append(_elem283)
18398 
          iprot.readListEnd()
18399 
        else:
18400 
          iprot.skip(ftype)
18401 
      else:
18402 
        iprot.skip(ftype)
18403 
      iprot.readFieldEnd()
18404 
    iprot.readStructEnd()
18405 
 
18406 
  def write(self, oprot):
18407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18409 
      return
18410 
    oprot.writeStructBegin('getCounterName_args')
18411 
    if self.userIds is not None:
18412 
      oprot.writeFieldBegin('userIds', TType.LIST, 1)
18413 
      oprot.writeListBegin(TType.I64, len(self.userIds))
18414 
      for iter284 in self.userIds:
18415 
        oprot.writeI64(iter284)
18416 
      oprot.writeListEnd()
18417 
      oprot.writeFieldEnd()
18418 
    oprot.writeFieldStop()
18419 
    oprot.writeStructEnd()
18420 
 
18421 
  def validate(self):
18422 
    return
18423 
 
18424 
 
18425 
  def __repr__(self):
18426 
    L = ['%s=%r' % (key, value)
18427 
      for key, value in self.__dict__.iteritems()]
18428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18429 
 
18430 
  def __eq__(self, other):
18431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18432 
 
18433 
  def __ne__(self, other):
18434 
    return not (self == other)
18435 
 
18436 
class getCounterName_result:
18437 
  """
18438 
  Attributes:
18439 
   - success
18440 
  """
18441 
 
18442 
  thrift_spec = (
18443 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18444 
  )
18445 
 
18446 
  def __init__(self, success=None,):
18447 
    self.success = success
18448 
 
18449 
  def read(self, iprot):
18450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18452 
      return
18453 
    iprot.readStructBegin()
18454 
    while True:
18455 
      (fname, ftype, fid) = iprot.readFieldBegin()
18456 
      if ftype == TType.STOP:
18457 
        break
18458 
      if fid == 0:
18459 
        if ftype == TType.MAP:
18460 
          self.success = {}
18461 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
18462 
          for _i289 in xrange(_size285):
18463 
            _key290 = iprot.readI64();
18464 
            _val291 = iprot.readString();
18465 
            self.success[_key290] = _val291
18466 
          iprot.readMapEnd()
18467 
        else:
18468 
          iprot.skip(ftype)
18469 
      else:
18470 
        iprot.skip(ftype)
18471 
      iprot.readFieldEnd()
18472 
    iprot.readStructEnd()
18473 
 
18474 
  def write(self, oprot):
18475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18477 
      return
18478 
    oprot.writeStructBegin('getCounterName_result')
18479 
    if self.success is not None:
18480 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18481 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
18482 
      for kiter292,viter293 in self.success.items():
18483 
        oprot.writeI64(kiter292)
18484 
        oprot.writeString(viter293)
18485 
      oprot.writeMapEnd()
18486 
      oprot.writeFieldEnd()
18487 
    oprot.writeFieldStop()
18488 
    oprot.writeStructEnd()
18489 
 
18490 
  def validate(self):
18491 
    return
18492 
 
18493 
 
18494 
  def __repr__(self):
18495 
    L = ['%s=%r' % (key, value)
18496 
      for key, value in self.__dict__.iteritems()]
18497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18498 
 
18499 
  def __eq__(self, other):
18500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18501 
 
18502 
  def __ne__(self, other):
18503 
    return not (self == other)
20873 kshitij.so 18504 
 
18505 
class setWalletAmountInCart_args:
18506 
  """
18507 
  Attributes:
18508 
   - cartId
18509 
   - wallet_amount
18510 
  """
18511 
 
18512 
  thrift_spec = (
18513 
    None, # 0
18514 
    (1, TType.I64, 'cartId', None, None, ), # 1
18515 
    (2, TType.DOUBLE, 'wallet_amount', None, None, ), # 2
18516 
  )
18517 
 
18518 
  def __init__(self, cartId=None, wallet_amount=None,):
18519 
    self.cartId = cartId
18520 
    self.wallet_amount = wallet_amount
18521 
 
18522 
  def read(self, iprot):
18523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18525 
      return
18526 
    iprot.readStructBegin()
18527 
    while True:
18528 
      (fname, ftype, fid) = iprot.readFieldBegin()
18529 
      if ftype == TType.STOP:
18530 
        break
18531 
      if fid == 1:
18532 
        if ftype == TType.I64:
18533 
          self.cartId = iprot.readI64();
18534 
        else:
18535 
          iprot.skip(ftype)
18536 
      elif fid == 2:
18537 
        if ftype == TType.DOUBLE:
18538 
          self.wallet_amount = iprot.readDouble();
18539 
        else:
18540 
          iprot.skip(ftype)
18541 
      else:
18542 
        iprot.skip(ftype)
18543 
      iprot.readFieldEnd()
18544 
    iprot.readStructEnd()
18545 
 
18546 
  def write(self, oprot):
18547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18549 
      return
18550 
    oprot.writeStructBegin('setWalletAmountInCart_args')
18551 
    if self.cartId is not None:
18552 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
18553 
      oprot.writeI64(self.cartId)
18554 
      oprot.writeFieldEnd()
18555 
    if self.wallet_amount is not None:
18556 
      oprot.writeFieldBegin('wallet_amount', TType.DOUBLE, 2)
18557 
      oprot.writeDouble(self.wallet_amount)
18558 
      oprot.writeFieldEnd()
18559 
    oprot.writeFieldStop()
18560 
    oprot.writeStructEnd()
18561 
 
18562 
  def validate(self):
18563 
    return
18564 
 
18565 
 
18566 
  def __repr__(self):
18567 
    L = ['%s=%r' % (key, value)
18568 
      for key, value in self.__dict__.iteritems()]
18569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18570 
 
18571 
  def __eq__(self, other):
18572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18573 
 
18574 
  def __ne__(self, other):
18575 
    return not (self == other)
18576 
 
18577 
class setWalletAmountInCart_result:
18578 
  """
18579 
  Attributes:
18580 
   - success
18581 
  """
18582 
 
18583 
  thrift_spec = (
18584 
    (0, TType.BOOL, 'success', None, None, ), # 0
18585 
  )
18586 
 
18587 
  def __init__(self, success=None,):
18588 
    self.success = success
18589 
 
18590 
  def read(self, iprot):
18591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18593 
      return
18594 
    iprot.readStructBegin()
18595 
    while True:
18596 
      (fname, ftype, fid) = iprot.readFieldBegin()
18597 
      if ftype == TType.STOP:
18598 
        break
18599 
      if fid == 0:
18600 
        if ftype == TType.BOOL:
18601 
          self.success = iprot.readBool();
18602 
        else:
18603 
          iprot.skip(ftype)
18604 
      else:
18605 
        iprot.skip(ftype)
18606 
      iprot.readFieldEnd()
18607 
    iprot.readStructEnd()
18608 
 
18609 
  def write(self, oprot):
18610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18612 
      return
18613 
    oprot.writeStructBegin('setWalletAmountInCart_result')
18614 
    if self.success is not None:
18615 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18616 
      oprot.writeBool(self.success)
18617 
      oprot.writeFieldEnd()
18618 
    oprot.writeFieldStop()
18619 
    oprot.writeStructEnd()
18620 
 
18621 
  def validate(self):
18622 
    return
18623 
 
18624 
 
18625 
  def __repr__(self):
18626 
    L = ['%s=%r' % (key, value)
18627 
      for key, value in self.__dict__.iteritems()]
18628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18629 
 
18630 
  def __eq__(self, other):
18631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18632 
 
18633 
  def __ne__(self, other):
18634 
    return not (self == other)
22452 amit.gupta 18635 
 
18636 
class addItemPricingToCart_args:
18637 
  """
18638 
  Attributes:
18639 
   - cartId
18640 
   - itemPriceQuantityList
18641 
  """
18642 
 
18643 
  thrift_spec = (
18644 
    None, # 0
18645 
    (1, TType.I64, 'cartId', None, None, ), # 1
18646 
    (2, TType.LIST, 'itemPriceQuantityList', (TType.STRUCT,(ItemPriceQuantity, ItemPriceQuantity.thrift_spec)), None, ), # 2
18647 
  )
18648 
 
18649 
  def __init__(self, cartId=None, itemPriceQuantityList=None,):
18650 
    self.cartId = cartId
18651 
    self.itemPriceQuantityList = itemPriceQuantityList
18652 
 
18653 
  def read(self, iprot):
18654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18656 
      return
18657 
    iprot.readStructBegin()
18658 
    while True:
18659 
      (fname, ftype, fid) = iprot.readFieldBegin()
18660 
      if ftype == TType.STOP:
18661 
        break
18662 
      if fid == 1:
18663 
        if ftype == TType.I64:
18664 
          self.cartId = iprot.readI64();
18665 
        else:
18666 
          iprot.skip(ftype)
18667 
      elif fid == 2:
18668 
        if ftype == TType.LIST:
18669 
          self.itemPriceQuantityList = []
18670 
          (_etype297, _size294) = iprot.readListBegin()
18671 
          for _i298 in xrange(_size294):
18672 
            _elem299 = ItemPriceQuantity()
18673 
            _elem299.read(iprot)
18674 
            self.itemPriceQuantityList.append(_elem299)
18675 
          iprot.readListEnd()
18676 
        else:
18677 
          iprot.skip(ftype)
18678 
      else:
18679 
        iprot.skip(ftype)
18680 
      iprot.readFieldEnd()
18681 
    iprot.readStructEnd()
18682 
 
18683 
  def write(self, oprot):
18684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18686 
      return
18687 
    oprot.writeStructBegin('addItemPricingToCart_args')
18688 
    if self.cartId is not None:
18689 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
18690 
      oprot.writeI64(self.cartId)
18691 
      oprot.writeFieldEnd()
18692 
    if self.itemPriceQuantityList is not None:
18693 
      oprot.writeFieldBegin('itemPriceQuantityList', TType.LIST, 2)
18694 
      oprot.writeListBegin(TType.STRUCT, len(self.itemPriceQuantityList))
18695 
      for iter300 in self.itemPriceQuantityList:
18696 
        iter300.write(oprot)
18697 
      oprot.writeListEnd()
18698 
      oprot.writeFieldEnd()
18699 
    oprot.writeFieldStop()
18700 
    oprot.writeStructEnd()
18701 
 
18702 
  def validate(self):
18703 
    return
18704 
 
18705 
 
18706 
  def __repr__(self):
18707 
    L = ['%s=%r' % (key, value)
18708 
      for key, value in self.__dict__.iteritems()]
18709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18710 
 
18711 
  def __eq__(self, other):
18712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18713 
 
18714 
  def __ne__(self, other):
18715 
    return not (self == other)
18716 
 
18717 
class addItemPricingToCart_result:
18718 
  """
18719 
  Attributes:
18720 
   - success
18721 
  """
18722 
 
18723 
  thrift_spec = (
18724 
    (0, TType.BOOL, 'success', None, None, ), # 0
18725 
  )
18726 
 
18727 
  def __init__(self, success=None,):
18728 
    self.success = success
18729 
 
18730 
  def read(self, iprot):
18731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18733 
      return
18734 
    iprot.readStructBegin()
18735 
    while True:
18736 
      (fname, ftype, fid) = iprot.readFieldBegin()
18737 
      if ftype == TType.STOP:
18738 
        break
18739 
      if fid == 0:
18740 
        if ftype == TType.BOOL:
18741 
          self.success = iprot.readBool();
18742 
        else:
18743 
          iprot.skip(ftype)
18744 
      else:
18745 
        iprot.skip(ftype)
18746 
      iprot.readFieldEnd()
18747 
    iprot.readStructEnd()
18748 
 
18749 
  def write(self, oprot):
18750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18752 
      return
18753 
    oprot.writeStructBegin('addItemPricingToCart_result')
18754 
    if self.success is not None:
18755 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18756 
      oprot.writeBool(self.success)
18757 
      oprot.writeFieldEnd()
18758 
    oprot.writeFieldStop()
18759 
    oprot.writeStructEnd()
18760 
 
18761 
  def validate(self):
18762 
    return
18763 
 
18764 
 
18765 
  def __repr__(self):
18766 
    L = ['%s=%r' % (key, value)
18767 
      for key, value in self.__dict__.iteritems()]
18768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18769 
 
18770 
  def __eq__(self, other):
18771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18772 
 
18773 
  def __ne__(self, other):
18774 
    return not (self == other)