Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
12722 amit.gupta 713 
  def getAllUsersByCounter(self, counterId):
714 
    """
715 
    Parameters:
716 
     - counterId
717 
    """
718 
    pass
719 
 
720 
 
3376 rajveer 721 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 722 
  """
723 
  service
724 
  """
725 
  def __init__(self, iprot, oprot=None):
3376 rajveer 726 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 727 
 
559 chandransh 728 
  def createAnonymousUser(self, jsessionId):
94 ashish 729 
    """
730 
    Parameters:
559 chandransh 731 
     - jsessionId
94 ashish 732 
    """
559 chandransh 733 
    self.send_createAnonymousUser(jsessionId)
734 
    return self.recv_createAnonymousUser()
94 ashish 735 
 
559 chandransh 736 
  def send_createAnonymousUser(self, jsessionId):
737 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
738 
    args = createAnonymousUser_args()
739 
    args.jsessionId = jsessionId
94 ashish 740 
    args.write(self._oprot)
741 
    self._oprot.writeMessageEnd()
742 
    self._oprot.trans.flush()
743 
 
559 chandransh 744 
  def recv_createAnonymousUser(self, ):
94 ashish 745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
746 
    if mtype == TMessageType.EXCEPTION:
747 
      x = TApplicationException()
748 
      x.read(self._iprot)
749 
      self._iprot.readMessageEnd()
750 
      raise x
559 chandransh 751 
    result = createAnonymousUser_result()
94 ashish 752 
    result.read(self._iprot)
753 
    self._iprot.readMessageEnd()
3431 rajveer 754 
    if result.success is not None:
94 ashish 755 
      return result.success
3431 rajveer 756 
    if result.ucex is not None:
559 chandransh 757 
      raise result.ucex
758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 759 
 
559 chandransh 760 
  def getUserById(self, userId):
94 ashish 761 
    """
762 
    Parameters:
763 
     - userId
764 
    """
559 chandransh 765 
    self.send_getUserById(userId)
766 
    return self.recv_getUserById()
94 ashish 767 
 
559 chandransh 768 
  def send_getUserById(self, userId):
769 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
770 
    args = getUserById_args()
94 ashish 771 
    args.userId = userId
772 
    args.write(self._oprot)
773 
    self._oprot.writeMessageEnd()
774 
    self._oprot.trans.flush()
775 
 
559 chandransh 776 
  def recv_getUserById(self, ):
94 ashish 777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
778 
    if mtype == TMessageType.EXCEPTION:
779 
      x = TApplicationException()
780 
      x.read(self._iprot)
781 
      self._iprot.readMessageEnd()
782 
      raise x
559 chandransh 783 
    result = getUserById_result()
94 ashish 784 
    result.read(self._iprot)
785 
    self._iprot.readMessageEnd()
3431 rajveer 786 
    if result.success is not None:
94 ashish 787 
      return result.success
3431 rajveer 788 
    if result.ucex is not None:
559 chandransh 789 
      raise result.ucex
790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 791 
 
5326 rajveer 792 
  def getUserByCartId(self, cartId):
793 
    """
794 
    Parameters:
795 
     - cartId
796 
    """
797 
    self.send_getUserByCartId(cartId)
798 
    return self.recv_getUserByCartId()
799 
 
800 
  def send_getUserByCartId(self, cartId):
801 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
802 
    args = getUserByCartId_args()
803 
    args.cartId = cartId
804 
    args.write(self._oprot)
805 
    self._oprot.writeMessageEnd()
806 
    self._oprot.trans.flush()
807 
 
808 
  def recv_getUserByCartId(self, ):
809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
810 
    if mtype == TMessageType.EXCEPTION:
811 
      x = TApplicationException()
812 
      x.read(self._iprot)
813 
      self._iprot.readMessageEnd()
814 
      raise x
815 
    result = getUserByCartId_result()
816 
    result.read(self._iprot)
817 
    self._iprot.readMessageEnd()
818 
    if result.success is not None:
819 
      return result.success
820 
    if result.ucex is not None:
821 
      raise result.ucex
822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
823 
 
1491 vikas 824 
  def getUserByEmail(self, email):
825 
    """
826 
    Parameters:
827 
     - email
828 
    """
829 
    self.send_getUserByEmail(email)
830 
    return self.recv_getUserByEmail()
831 
 
832 
  def send_getUserByEmail(self, email):
833 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
834 
    args = getUserByEmail_args()
835 
    args.email = email
836 
    args.write(self._oprot)
837 
    self._oprot.writeMessageEnd()
838 
    self._oprot.trans.flush()
839 
 
840 
  def recv_getUserByEmail(self, ):
841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
842 
    if mtype == TMessageType.EXCEPTION:
843 
      x = TApplicationException()
844 
      x.read(self._iprot)
845 
      self._iprot.readMessageEnd()
846 
      raise x
847 
    result = getUserByEmail_result()
848 
    result.read(self._iprot)
849 
    self._iprot.readMessageEnd()
3431 rajveer 850 
    if result.success is not None:
1491 vikas 851 
      return result.success
3431 rajveer 852 
    if result.ucex is not None:
1491 vikas 853 
      raise result.ucex
854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
855 
 
3032 mandeep.dh 856 
  def getUserByMobileNumber(self, mobileNumber):
857 
    """
858 
    Parameters:
859 
     - mobileNumber
860 
    """
861 
    self.send_getUserByMobileNumber(mobileNumber)
862 
    return self.recv_getUserByMobileNumber()
863 
 
864 
  def send_getUserByMobileNumber(self, mobileNumber):
865 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
866 
    args = getUserByMobileNumber_args()
867 
    args.mobileNumber = mobileNumber
868 
    args.write(self._oprot)
869 
    self._oprot.writeMessageEnd()
870 
    self._oprot.trans.flush()
871 
 
872 
  def recv_getUserByMobileNumber(self, ):
873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
874 
    if mtype == TMessageType.EXCEPTION:
875 
      x = TApplicationException()
876 
      x.read(self._iprot)
877 
      self._iprot.readMessageEnd()
878 
      raise x
879 
    result = getUserByMobileNumber_result()
880 
    result.read(self._iprot)
881 
    self._iprot.readMessageEnd()
3431 rajveer 882 
    if result.success is not None:
3032 mandeep.dh 883 
      return result.success
3431 rajveer 884 
    if result.ucex is not None:
3032 mandeep.dh 885 
      raise result.ucex
886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
887 
 
559 chandransh 888 
  def createUser(self, user):
94 ashish 889 
    """
890 
    Parameters:
559 chandransh 891 
     - user
94 ashish 892 
    """
559 chandransh 893 
    self.send_createUser(user)
894 
    return self.recv_createUser()
94 ashish 895 
 
559 chandransh 896 
  def send_createUser(self, user):
897 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
898 
    args = createUser_args()
899 
    args.user = user
94 ashish 900 
    args.write(self._oprot)
901 
    self._oprot.writeMessageEnd()
902 
    self._oprot.trans.flush()
903 
 
559 chandransh 904 
  def recv_createUser(self, ):
94 ashish 905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
906 
    if mtype == TMessageType.EXCEPTION:
907 
      x = TApplicationException()
908 
      x.read(self._iprot)
909 
      self._iprot.readMessageEnd()
910 
      raise x
559 chandransh 911 
    result = createUser_result()
94 ashish 912 
    result.read(self._iprot)
913 
    self._iprot.readMessageEnd()
3431 rajveer 914 
    if result.success is not None:
94 ashish 915 
      return result.success
3431 rajveer 916 
    if result.ucex is not None:
559 chandransh 917 
      raise result.ucex
918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 919 
 
559 chandransh 920 
  def updateUser(self, user):
94 ashish 921 
    """
922 
    Parameters:
559 chandransh 923 
     - user
94 ashish 924 
    """
559 chandransh 925 
    self.send_updateUser(user)
926 
    return self.recv_updateUser()
94 ashish 927 
 
559 chandransh 928 
  def send_updateUser(self, user):
929 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
930 
    args = updateUser_args()
931 
    args.user = user
94 ashish 932 
    args.write(self._oprot)
933 
    self._oprot.writeMessageEnd()
934 
    self._oprot.trans.flush()
935 
 
559 chandransh 936 
  def recv_updateUser(self, ):
94 ashish 937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
938 
    if mtype == TMessageType.EXCEPTION:
939 
      x = TApplicationException()
940 
      x.read(self._iprot)
941 
      self._iprot.readMessageEnd()
942 
      raise x
559 chandransh 943 
    result = updateUser_result()
94 ashish 944 
    result.read(self._iprot)
945 
    self._iprot.readMessageEnd()
3431 rajveer 946 
    if result.success is not None:
94 ashish 947 
      return result.success
3431 rajveer 948 
    if result.ucex is not None:
559 chandransh 949 
      raise result.ucex
950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 951 
 
559 chandransh 952 
  def authenticateUser(self, email, password):
94 ashish 953 
    """
954 
    Parameters:
955 
     - email
956 
     - password
957 
    """
559 chandransh 958 
    self.send_authenticateUser(email, password)
122 ashish 959 
    return self.recv_authenticateUser()
960 
 
559 chandransh 961 
  def send_authenticateUser(self, email, password):
122 ashish 962 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
963 
    args = authenticateUser_args()
559 chandransh 964 
    args.email = email
122 ashish 965 
    args.password = password
966 
    args.write(self._oprot)
967 
    self._oprot.writeMessageEnd()
968 
    self._oprot.trans.flush()
969 
 
970 
  def recv_authenticateUser(self, ):
971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
972 
    if mtype == TMessageType.EXCEPTION:
973 
      x = TApplicationException()
974 
      x.read(self._iprot)
975 
      self._iprot.readMessageEnd()
976 
      raise x
977 
    result = authenticateUser_result()
978 
    result.read(self._iprot)
979 
    self._iprot.readMessageEnd()
3431 rajveer 980 
    if result.success is not None:
122 ashish 981 
      return result.success
3431 rajveer 982 
    if result.auex is not None:
559 chandransh 983 
      raise result.auex
122 ashish 984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
985 
 
94 ashish 986 
  def userExists(self, email):
987 
    """
988 
    Parameters:
989 
     - email
990 
    """
991 
    self.send_userExists(email)
992 
    return self.recv_userExists()
993 
 
994 
  def send_userExists(self, email):
995 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
996 
    args = userExists_args()
997 
    args.email = email
998 
    args.write(self._oprot)
999 
    self._oprot.writeMessageEnd()
1000 
    self._oprot.trans.flush()
1001 
 
1002 
  def recv_userExists(self, ):
1003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1004 
    if mtype == TMessageType.EXCEPTION:
1005 
      x = TApplicationException()
1006 
      x.read(self._iprot)
1007 
      self._iprot.readMessageEnd()
1008 
      raise x
1009 
    result = userExists_result()
1010 
    result.read(self._iprot)
1011 
    self._iprot.readMessageEnd()
3431 rajveer 1012 
    if result.success is not None:
94 ashish 1013 
      return result.success
3431 rajveer 1014 
    if result.ucx is not None:
94 ashish 1015 
      raise result.ucx
1016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1017 
 
567 rajveer 1018 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1019 
    """
1020 
    Parameters:
1021 
     - userId
1022 
     - address
513 rajveer 1023 
     - setDefault
94 ashish 1024 
    """
567 rajveer 1025 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1026 
    return self.recv_addAddressForUser()
1027 
 
567 rajveer 1028 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1029 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1030 
    args = addAddressForUser_args()
559 chandransh 1031 
    args.userId = userId
94 ashish 1032 
    args.address = address
513 rajveer 1033 
    args.setDefault = setDefault
94 ashish 1034 
    args.write(self._oprot)
1035 
    self._oprot.writeMessageEnd()
1036 
    self._oprot.trans.flush()
1037 
 
1038 
  def recv_addAddressForUser(self, ):
1039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1040 
    if mtype == TMessageType.EXCEPTION:
1041 
      x = TApplicationException()
1042 
      x.read(self._iprot)
1043 
      self._iprot.readMessageEnd()
1044 
      raise x
1045 
    result = addAddressForUser_result()
1046 
    result.read(self._iprot)
1047 
    self._iprot.readMessageEnd()
3431 rajveer 1048 
    if result.success is not None:
94 ashish 1049 
      return result.success
3431 rajveer 1050 
    if result.ucx is not None:
94 ashish 1051 
      raise result.ucx
1052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1053 
 
1054 
  def removeAddressForUser(self, userid, addressId):
1055 
    """
1056 
    Parameters:
1057 
     - userid
1058 
     - addressId
1059 
    """
1060 
    self.send_removeAddressForUser(userid, addressId)
1061 
    return self.recv_removeAddressForUser()
1062 
 
1063 
  def send_removeAddressForUser(self, userid, addressId):
1064 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1065 
    args = removeAddressForUser_args()
1066 
    args.userid = userid
1067 
    args.addressId = addressId
1068 
    args.write(self._oprot)
1069 
    self._oprot.writeMessageEnd()
1070 
    self._oprot.trans.flush()
1071 
 
1072 
  def recv_removeAddressForUser(self, ):
1073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1074 
    if mtype == TMessageType.EXCEPTION:
1075 
      x = TApplicationException()
1076 
      x.read(self._iprot)
1077 
      self._iprot.readMessageEnd()
1078 
      raise x
1079 
    result = removeAddressForUser_result()
1080 
    result.read(self._iprot)
1081 
    self._iprot.readMessageEnd()
3431 rajveer 1082 
    if result.success is not None:
94 ashish 1083 
      return result.success
3431 rajveer 1084 
    if result.ucx is not None:
94 ashish 1085 
      raise result.ucx
1086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1087 
 
1088 
  def setUserAsLoggedIn(self, userId, timestamp):
1089 
    """
1090 
    Parameters:
1091 
     - userId
1092 
     - timestamp
1093 
    """
1094 
    self.send_setUserAsLoggedIn(userId, timestamp)
1095 
    return self.recv_setUserAsLoggedIn()
1096 
 
1097 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1098 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1099 
    args = setUserAsLoggedIn_args()
1100 
    args.userId = userId
1101 
    args.timestamp = timestamp
1102 
    args.write(self._oprot)
1103 
    self._oprot.writeMessageEnd()
1104 
    self._oprot.trans.flush()
1105 
 
1106 
  def recv_setUserAsLoggedIn(self, ):
1107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1108 
    if mtype == TMessageType.EXCEPTION:
1109 
      x = TApplicationException()
1110 
      x.read(self._iprot)
1111 
      self._iprot.readMessageEnd()
1112 
      raise x
1113 
    result = setUserAsLoggedIn_result()
1114 
    result.read(self._iprot)
1115 
    self._iprot.readMessageEnd()
3431 rajveer 1116 
    if result.success is not None:
94 ashish 1117 
      return result.success
3431 rajveer 1118 
    if result.ucx is not None:
94 ashish 1119 
      raise result.ucx
1120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1121 
 
1122 
  def setUserAsLoggedOut(self, userid, timestamp):
1123 
    """
1124 
    Parameters:
1125 
     - userid
1126 
     - timestamp
1127 
    """
1128 
    self.send_setUserAsLoggedOut(userid, timestamp)
1129 
    return self.recv_setUserAsLoggedOut()
1130 
 
1131 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1132 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1133 
    args = setUserAsLoggedOut_args()
1134 
    args.userid = userid
1135 
    args.timestamp = timestamp
1136 
    args.write(self._oprot)
1137 
    self._oprot.writeMessageEnd()
1138 
    self._oprot.trans.flush()
1139 
 
1140 
  def recv_setUserAsLoggedOut(self, ):
1141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1142 
    if mtype == TMessageType.EXCEPTION:
1143 
      x = TApplicationException()
1144 
      x.read(self._iprot)
1145 
      self._iprot.readMessageEnd()
1146 
      raise x
1147 
    result = setUserAsLoggedOut_result()
1148 
    result.read(self._iprot)
1149 
    self._iprot.readMessageEnd()
3431 rajveer 1150 
    if result.success is not None:
94 ashish 1151 
      return result.success
3431 rajveer 1152 
    if result.ucx is not None:
94 ashish 1153 
      raise result.ucx
1154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1155 
 
504 rajveer 1156 
  def setDefaultAddress(self, userid, addressId):
1157 
    """
1158 
    Parameters:
1159 
     - userid
1160 
     - addressId
1161 
    """
1162 
    self.send_setDefaultAddress(userid, addressId)
1163 
    return self.recv_setDefaultAddress()
1164 
 
1165 
  def send_setDefaultAddress(self, userid, addressId):
1166 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1167 
    args = setDefaultAddress_args()
1168 
    args.userid = userid
1169 
    args.addressId = addressId
1170 
    args.write(self._oprot)
1171 
    self._oprot.writeMessageEnd()
1172 
    self._oprot.trans.flush()
1173 
 
1174 
  def recv_setDefaultAddress(self, ):
1175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1176 
    if mtype == TMessageType.EXCEPTION:
1177 
      x = TApplicationException()
1178 
      x.read(self._iprot)
1179 
      self._iprot.readMessageEnd()
1180 
      raise x
1181 
    result = setDefaultAddress_result()
1182 
    result.read(self._iprot)
1183 
    self._iprot.readMessageEnd()
3431 rajveer 1184 
    if result.success is not None:
504 rajveer 1185 
      return result.success
3431 rajveer 1186 
    if result.ucx is not None:
504 rajveer 1187 
      raise result.ucx
1188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1189 
 
594 rajveer 1190 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1191 
    """
1192 
    Parameters:
1193 
     - userid
594 rajveer 1194 
     - oldPassword
1195 
     - newPassword
94 ashish 1196 
    """
594 rajveer 1197 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1198 
    return self.recv_updatePassword()
1199 
 
594 rajveer 1200 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1201 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1202 
    args = updatePassword_args()
1203 
    args.userid = userid
594 rajveer 1204 
    args.oldPassword = oldPassword
1205 
    args.newPassword = newPassword
94 ashish 1206 
    args.write(self._oprot)
1207 
    self._oprot.writeMessageEnd()
1208 
    self._oprot.trans.flush()
1209 
 
1210 
  def recv_updatePassword(self, ):
1211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1212 
    if mtype == TMessageType.EXCEPTION:
1213 
      x = TApplicationException()
1214 
      x.read(self._iprot)
1215 
      self._iprot.readMessageEnd()
1216 
      raise x
1217 
    result = updatePassword_result()
1218 
    result.read(self._iprot)
1219 
    self._iprot.readMessageEnd()
3431 rajveer 1220 
    if result.success is not None:
94 ashish 1221 
      return result.success
3431 rajveer 1222 
    if result.ucx is not None:
94 ashish 1223 
      raise result.ucx
1224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1225 
 
884 rajveer 1226 
  def forgotPassword(self, email, newPassword):
581 rajveer 1227 
    """
1228 
    Parameters:
1229 
     - email
884 rajveer 1230 
     - newPassword
581 rajveer 1231 
    """
884 rajveer 1232 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1233 
    return self.recv_forgotPassword()
1234 
 
884 rajveer 1235 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1236 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1237 
    args = forgotPassword_args()
1238 
    args.email = email
884 rajveer 1239 
    args.newPassword = newPassword
581 rajveer 1240 
    args.write(self._oprot)
1241 
    self._oprot.writeMessageEnd()
1242 
    self._oprot.trans.flush()
1243 
 
1244 
  def recv_forgotPassword(self, ):
1245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1246 
    if mtype == TMessageType.EXCEPTION:
1247 
      x = TApplicationException()
1248 
      x.read(self._iprot)
1249 
      self._iprot.readMessageEnd()
1250 
      raise x
1251 
    result = forgotPassword_result()
1252 
    result.read(self._iprot)
1253 
    self._iprot.readMessageEnd()
3431 rajveer 1254 
    if result.success is not None:
581 rajveer 1255 
      return result.success
3431 rajveer 1256 
    if result.ucx is not None:
581 rajveer 1257 
      raise result.ucx
1258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1259 
 
594 rajveer 1260 
  def getAllAddressesForUser(self, userId):
1261 
    """
1262 
    Parameters:
1263 
     - userId
1264 
    """
1265 
    self.send_getAllAddressesForUser(userId)
1266 
    return self.recv_getAllAddressesForUser()
1267 
 
1268 
  def send_getAllAddressesForUser(self, userId):
1269 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1270 
    args = getAllAddressesForUser_args()
1271 
    args.userId = userId
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_getAllAddressesForUser(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = getAllAddressesForUser_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
3431 rajveer 1286 
    if result.success is not None:
594 rajveer 1287 
      return result.success
3431 rajveer 1288 
    if result.ucx is not None:
594 rajveer 1289 
      raise result.ucx
1290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1291 
 
1894 vikas 1292 
  def getAddressById(self, addressId):
1293 
    """
1294 
    Parameters:
1295 
     - addressId
1296 
    """
1297 
    self.send_getAddressById(addressId)
1298 
    return self.recv_getAddressById()
1299 
 
1300 
  def send_getAddressById(self, addressId):
1301 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1302 
    args = getAddressById_args()
1303 
    args.addressId = addressId
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getAddressById(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getAddressById_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
3431 rajveer 1318 
    if result.success is not None:
1894 vikas 1319 
      return result.success
3431 rajveer 1320 
    if result.ucx is not None:
1894 vikas 1321 
      raise result.ucx
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1323 
 
594 rajveer 1324 
  def getDefaultAddressId(self, userId):
1325 
    """
1326 
    Parameters:
1327 
     - userId
1328 
    """
1329 
    self.send_getDefaultAddressId(userId)
1330 
    return self.recv_getDefaultAddressId()
1331 
 
1332 
  def send_getDefaultAddressId(self, userId):
1333 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1334 
    args = getDefaultAddressId_args()
1335 
    args.userId = userId
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getDefaultAddressId(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getDefaultAddressId_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
3431 rajveer 1350 
    if result.success is not None:
594 rajveer 1351 
      return result.success
3431 rajveer 1352 
    if result.ucx is not None:
594 rajveer 1353 
      raise result.ucx
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1355 
 
785 rajveer 1356 
  def getDefaultPincode(self, userId):
1357 
    """
1358 
    Parameters:
1359 
     - userId
1360 
    """
1361 
    self.send_getDefaultPincode(userId)
1362 
    return self.recv_getDefaultPincode()
1363 
 
1364 
  def send_getDefaultPincode(self, userId):
1365 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1366 
    args = getDefaultPincode_args()
1367 
    args.userId = userId
1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
1372 
  def recv_getDefaultPincode(self, ):
1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
1379 
    result = getDefaultPincode_result()
1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
3431 rajveer 1382 
    if result.success is not None:
785 rajveer 1383 
      return result.success
3431 rajveer 1384 
    if result.ucx is not None:
785 rajveer 1385 
      raise result.ucx
1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1387 
 
1274 varun.gupt 1388 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1389 
    """
1390 
    Parameters:
1391 
     - userId
1392 
     - replyTo
1393 
     - communicationType
1394 
     - orderId
1395 
     - airwaybillNo
1396 
     - productName
1397 
     - subject
1398 
     - message
1399 
    """
1400 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1401 
    return self.recv_saveUserCommunication()
1402 
 
1403 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1404 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1405 
    args = saveUserCommunication_args()
1406 
    args.userId = userId
1407 
    args.replyTo = replyTo
1408 
    args.communicationType = communicationType
1409 
    args.orderId = orderId
1410 
    args.airwaybillNo = airwaybillNo
1411 
    args.productName = productName
1412 
    args.subject = subject
1413 
    args.message = message
1414 
    args.write(self._oprot)
1415 
    self._oprot.writeMessageEnd()
1416 
    self._oprot.trans.flush()
1417 
 
1418 
  def recv_saveUserCommunication(self, ):
1419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1420 
    if mtype == TMessageType.EXCEPTION:
1421 
      x = TApplicationException()
1422 
      x.read(self._iprot)
1423 
      self._iprot.readMessageEnd()
1424 
      raise x
1425 
    result = saveUserCommunication_result()
1426 
    result.read(self._iprot)
1427 
    self._iprot.readMessageEnd()
3431 rajveer 1428 
    if result.success is not None:
1274 varun.gupt 1429 
      return result.success
3431 rajveer 1430 
    if result.ucx is not None:
1274 varun.gupt 1431 
      raise result.ucx
1432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1433 
 
1590 varun.gupt 1434 
  def getUserCommunicationById(self, id):
1435 
    """
1436 
    Parameters:
1437 
     - id
1438 
    """
1439 
    self.send_getUserCommunicationById(id)
1440 
    return self.recv_getUserCommunicationById()
1441 
 
1442 
  def send_getUserCommunicationById(self, id):
1443 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1444 
    args = getUserCommunicationById_args()
1445 
    args.id = id
1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_getUserCommunicationById(self, ):
1451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1452 
    if mtype == TMessageType.EXCEPTION:
1453 
      x = TApplicationException()
1454 
      x.read(self._iprot)
1455 
      self._iprot.readMessageEnd()
1456 
      raise x
1457 
    result = getUserCommunicationById_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
3431 rajveer 1460 
    if result.success is not None:
1590 varun.gupt 1461 
      return result.success
3431 rajveer 1462 
    if result.ucx is not None:
1590 varun.gupt 1463 
      raise result.ucx
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1465 
 
1466 
  def getUserCommunicationByUser(self, userId):
1467 
    """
1468 
    Parameters:
1469 
     - userId
1470 
    """
1471 
    self.send_getUserCommunicationByUser(userId)
1472 
    return self.recv_getUserCommunicationByUser()
1473 
 
1474 
  def send_getUserCommunicationByUser(self, userId):
1475 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1476 
    args = getUserCommunicationByUser_args()
1477 
    args.userId = userId
1478 
    args.write(self._oprot)
1479 
    self._oprot.writeMessageEnd()
1480 
    self._oprot.trans.flush()
1481 
 
1482 
  def recv_getUserCommunicationByUser(self, ):
1483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1484 
    if mtype == TMessageType.EXCEPTION:
1485 
      x = TApplicationException()
1486 
      x.read(self._iprot)
1487 
      self._iprot.readMessageEnd()
1488 
      raise x
1489 
    result = getUserCommunicationByUser_result()
1490 
    result.read(self._iprot)
1491 
    self._iprot.readMessageEnd()
3431 rajveer 1492 
    if result.success is not None:
1590 varun.gupt 1493 
      return result.success
3431 rajveer 1494 
    if result.ucx is not None:
1590 varun.gupt 1495 
      raise result.ucx
1496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1497 
 
1498 
  def getAllUserCommunications(self, ):
1499 
    self.send_getAllUserCommunications()
1500 
    return self.recv_getAllUserCommunications()
1501 
 
1502 
  def send_getAllUserCommunications(self, ):
1503 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1504 
    args = getAllUserCommunications_args()
1505 
    args.write(self._oprot)
1506 
    self._oprot.writeMessageEnd()
1507 
    self._oprot.trans.flush()
1508 
 
1509 
  def recv_getAllUserCommunications(self, ):
1510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1511 
    if mtype == TMessageType.EXCEPTION:
1512 
      x = TApplicationException()
1513 
      x.read(self._iprot)
1514 
      self._iprot.readMessageEnd()
1515 
      raise x
1516 
    result = getAllUserCommunications_result()
1517 
    result.read(self._iprot)
1518 
    self._iprot.readMessageEnd()
3431 rajveer 1519 
    if result.success is not None:
1590 varun.gupt 1520 
      return result.success
3431 rajveer 1521 
    if result.ucx is not None:
1590 varun.gupt 1522 
      raise result.ucx
1523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1524 
 
5407 amar.kumar 1525 
  def removeUserCommunication(self, id):
1526 
    """
1527 
    Parameters:
1528 
     - id
1529 
    """
1530 
    self.send_removeUserCommunication(id)
1531 
    self.recv_removeUserCommunication()
1532 
 
1533 
  def send_removeUserCommunication(self, id):
1534 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1535 
    args = removeUserCommunication_args()
1536 
    args.id = id
1537 
    args.write(self._oprot)
1538 
    self._oprot.writeMessageEnd()
1539 
    self._oprot.trans.flush()
1540 
 
1541 
  def recv_removeUserCommunication(self, ):
1542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1543 
    if mtype == TMessageType.EXCEPTION:
1544 
      x = TApplicationException()
1545 
      x.read(self._iprot)
1546 
      self._iprot.readMessageEnd()
1547 
      raise x
1548 
    result = removeUserCommunication_result()
1549 
    result.read(self._iprot)
1550 
    self._iprot.readMessageEnd()
1551 
    if result.ucx is not None:
1552 
      raise result.ucx
1553 
    return
1554 
 
1859 vikas 1555 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1556 
    """
1557 
    Parameters:
1558 
     - name
1859 vikas 1559 
     - addedOn
1845 vikas 1560 
    """
1859 vikas 1561 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1562 
    return self.recv_createMasterAffiliate()
1563 
 
1859 vikas 1564 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1565 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1566 
    args = createMasterAffiliate_args()
1567 
    args.name = name
1859 vikas 1568 
    args.addedOn = addedOn
1845 vikas 1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_createMasterAffiliate(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = createMasterAffiliate_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
3431 rajveer 1583 
    if result.success is not None:
1845 vikas 1584 
      return result.success
3431 rajveer 1585 
    if result.utx is not None:
1845 vikas 1586 
      raise result.utx
1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1588 
 
1899 vikas 1589 
  def getAllMasterAffiliates(self, ):
1590 
    self.send_getAllMasterAffiliates()
1591 
    return self.recv_getAllMasterAffiliates()
1592 
 
1593 
  def send_getAllMasterAffiliates(self, ):
1594 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1595 
    args = getAllMasterAffiliates_args()
1596 
    args.write(self._oprot)
1597 
    self._oprot.writeMessageEnd()
1598 
    self._oprot.trans.flush()
1599 
 
1600 
  def recv_getAllMasterAffiliates(self, ):
1601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1602 
    if mtype == TMessageType.EXCEPTION:
1603 
      x = TApplicationException()
1604 
      x.read(self._iprot)
1605 
      self._iprot.readMessageEnd()
1606 
      raise x
1607 
    result = getAllMasterAffiliates_result()
1608 
    result.read(self._iprot)
1609 
    self._iprot.readMessageEnd()
3431 rajveer 1610 
    if result.success is not None:
1899 vikas 1611 
      return result.success
3431 rajveer 1612 
    if result.utx is not None:
1899 vikas 1613 
      raise result.utx
1614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1615 
 
1845 vikas 1616 
  def getMasterAffiliateById(self, id):
1617 
    """
1618 
    Parameters:
1619 
     - id
1620 
    """
1621 
    self.send_getMasterAffiliateById(id)
1622 
    return self.recv_getMasterAffiliateById()
1623 
 
1624 
  def send_getMasterAffiliateById(self, id):
1625 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1626 
    args = getMasterAffiliateById_args()
1627 
    args.id = id
1628 
    args.write(self._oprot)
1629 
    self._oprot.writeMessageEnd()
1630 
    self._oprot.trans.flush()
1631 
 
1632 
  def recv_getMasterAffiliateById(self, ):
1633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1634 
    if mtype == TMessageType.EXCEPTION:
1635 
      x = TApplicationException()
1636 
      x.read(self._iprot)
1637 
      self._iprot.readMessageEnd()
1638 
      raise x
1639 
    result = getMasterAffiliateById_result()
1640 
    result.read(self._iprot)
1641 
    self._iprot.readMessageEnd()
3431 rajveer 1642 
    if result.success is not None:
1845 vikas 1643 
      return result.success
3431 rajveer 1644 
    if result.utx is not None:
1845 vikas 1645 
      raise result.utx
1646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1647 
 
1648 
  def getMasterAffiliateByName(self, name):
1649 
    """
1650 
    Parameters:
1651 
     - name
1652 
    """
1653 
    self.send_getMasterAffiliateByName(name)
1654 
    return self.recv_getMasterAffiliateByName()
1655 
 
1656 
  def send_getMasterAffiliateByName(self, name):
1657 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1658 
    args = getMasterAffiliateByName_args()
1659 
    args.name = name
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getMasterAffiliateByName(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getMasterAffiliateByName_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
3431 rajveer 1674 
    if result.success is not None:
1845 vikas 1675 
      return result.success
3431 rajveer 1676 
    if result.utx is not None:
1845 vikas 1677 
      raise result.utx
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1679 
 
1859 vikas 1680 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1681 
    """
1682 
    Parameters:
1683 
     - name
1684 
     - url
1685 
     - masterAffiliateId
1859 vikas 1686 
     - addedOn
1845 vikas 1687 
    """
1859 vikas 1688 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1689 
    return self.recv_createAffiliate()
1690 
 
1859 vikas 1691 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1692 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1693 
    args = createAffiliate_args()
1694 
    args.name = name
1695 
    args.url = url
1696 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1697 
    args.addedOn = addedOn
1845 vikas 1698 
    args.write(self._oprot)
1699 
    self._oprot.writeMessageEnd()
1700 
    self._oprot.trans.flush()
1701 
 
1702 
  def recv_createAffiliate(self, ):
1703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1704 
    if mtype == TMessageType.EXCEPTION:
1705 
      x = TApplicationException()
1706 
      x.read(self._iprot)
1707 
      self._iprot.readMessageEnd()
1708 
      raise x
1709 
    result = createAffiliate_result()
1710 
    result.read(self._iprot)
1711 
    self._iprot.readMessageEnd()
3431 rajveer 1712 
    if result.success is not None:
1845 vikas 1713 
      return result.success
3431 rajveer 1714 
    if result.utx is not None:
1845 vikas 1715 
      raise result.utx
1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1717 
 
1718 
  def getAffiliateById(self, id):
1719 
    """
1720 
    Parameters:
1721 
     - id
1722 
    """
1723 
    self.send_getAffiliateById(id)
1724 
    return self.recv_getAffiliateById()
1725 
 
1726 
  def send_getAffiliateById(self, id):
1727 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1728 
    args = getAffiliateById_args()
1729 
    args.id = id
1730 
    args.write(self._oprot)
1731 
    self._oprot.writeMessageEnd()
1732 
    self._oprot.trans.flush()
1733 
 
1734 
  def recv_getAffiliateById(self, ):
1735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1736 
    if mtype == TMessageType.EXCEPTION:
1737 
      x = TApplicationException()
1738 
      x.read(self._iprot)
1739 
      self._iprot.readMessageEnd()
1740 
      raise x
1741 
    result = getAffiliateById_result()
1742 
    result.read(self._iprot)
1743 
    self._iprot.readMessageEnd()
3431 rajveer 1744 
    if result.success is not None:
1845 vikas 1745 
      return result.success
3431 rajveer 1746 
    if result.utx is not None:
1845 vikas 1747 
      raise result.utx
1748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1749 
 
1750 
  def getAffiliateByName(self, name):
1751 
    """
1752 
    Parameters:
1753 
     - name
1754 
    """
1755 
    self.send_getAffiliateByName(name)
1756 
    return self.recv_getAffiliateByName()
1757 
 
1758 
  def send_getAffiliateByName(self, name):
1759 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1760 
    args = getAffiliateByName_args()
1761 
    args.name = name
1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
1766 
  def recv_getAffiliateByName(self, ):
1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
1773 
    result = getAffiliateByName_result()
1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
3431 rajveer 1776 
    if result.success is not None:
1845 vikas 1777 
      return result.success
3431 rajveer 1778 
    if result.utx is not None:
1845 vikas 1779 
      raise result.utx
1780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1781 
 
1996 vikas 1782 
  def getTrackerById(self, id):
1845 vikas 1783 
    """
1784 
    Parameters:
1785 
     - id
1786 
    """
1996 vikas 1787 
    self.send_getTrackerById(id)
1845 vikas 1788 
    return self.recv_getTrackerById()
1789 
 
1996 vikas 1790 
  def send_getTrackerById(self, id):
1845 vikas 1791 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1792 
    args = getTrackerById_args()
1996 vikas 1793 
    args.id = id
1845 vikas 1794 
    args.write(self._oprot)
1795 
    self._oprot.writeMessageEnd()
1796 
    self._oprot.trans.flush()
1797 
 
1798 
  def recv_getTrackerById(self, ):
1799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1800 
    if mtype == TMessageType.EXCEPTION:
1801 
      x = TApplicationException()
1802 
      x.read(self._iprot)
1803 
      self._iprot.readMessageEnd()
1804 
      raise x
1805 
    result = getTrackerById_result()
1806 
    result.read(self._iprot)
1807 
    self._iprot.readMessageEnd()
3431 rajveer 1808 
    if result.success is not None:
1845 vikas 1809 
      return result.success
3431 rajveer 1810 
    if result.utx is not None:
1845 vikas 1811 
      raise result.utx
1812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1813 
 
1996 vikas 1814 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1815 
    """
1816 
    Parameters:
1996 vikas 1817 
     - id
1845 vikas 1818 
    """
1996 vikas 1819 
    self.send_getAffiliatesByMasterAffiliate(id)
1820 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1821 
 
1996 vikas 1822 
  def send_getAffiliatesByMasterAffiliate(self, id):
1823 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1824 
    args = getAffiliatesByMasterAffiliate_args()
1825 
    args.id = id
1845 vikas 1826 
    args.write(self._oprot)
1827 
    self._oprot.writeMessageEnd()
1828 
    self._oprot.trans.flush()
1829 
 
1996 vikas 1830 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1832 
    if mtype == TMessageType.EXCEPTION:
1833 
      x = TApplicationException()
1834 
      x.read(self._iprot)
1835 
      self._iprot.readMessageEnd()
1836 
      raise x
1996 vikas 1837 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1838 
    result.read(self._iprot)
1839 
    self._iprot.readMessageEnd()
3431 rajveer 1840 
    if result.success is not None:
1845 vikas 1841 
      return result.success
3431 rajveer 1842 
    if result.utx is not None:
1845 vikas 1843 
      raise result.utx
1996 vikas 1844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1845 
 
1996 vikas 1846 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1847 
    """
1848 
    Parameters:
1996 vikas 1849 
     - affiliateId
1845 vikas 1850 
     - userId
1851 
     - event
1852 
     - url
1853 
     - data
1859 vikas 1854 
     - addedOn
1845 vikas 1855 
    """
1996 vikas 1856 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1857 
    return self.recv_addTrackLog()
1858 
 
1996 vikas 1859 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1860 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1861 
    args = addTrackLog_args()
1996 vikas 1862 
    args.affiliateId = affiliateId
1845 vikas 1863 
    args.userId = userId
1864 
    args.event = event
1865 
    args.url = url
1866 
    args.data = data
1859 vikas 1867 
    args.addedOn = addedOn
1845 vikas 1868 
    args.write(self._oprot)
1869 
    self._oprot.writeMessageEnd()
1870 
    self._oprot.trans.flush()
1871 
 
1872 
  def recv_addTrackLog(self, ):
1873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1874 
    if mtype == TMessageType.EXCEPTION:
1875 
      x = TApplicationException()
1876 
      x.read(self._iprot)
1877 
      self._iprot.readMessageEnd()
1878 
      raise x
1879 
    result = addTrackLog_result()
1880 
    result.read(self._iprot)
1881 
    self._iprot.readMessageEnd()
3431 rajveer 1882 
    if result.success is not None:
1845 vikas 1883 
      return result.success
3431 rajveer 1884 
    if result.utx is not None:
1845 vikas 1885 
      raise result.utx
1886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1887 
 
1888 
  def getTrackLogById(self, id):
1889 
    """
1890 
    Parameters:
1891 
     - id
1892 
    """
1893 
    self.send_getTrackLogById(id)
1894 
    return self.recv_getTrackLogById()
1895 
 
1896 
  def send_getTrackLogById(self, id):
1897 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1898 
    args = getTrackLogById_args()
1899 
    args.id = id
1900 
    args.write(self._oprot)
1901 
    self._oprot.writeMessageEnd()
1902 
    self._oprot.trans.flush()
1903 
 
1904 
  def recv_getTrackLogById(self, ):
1905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1906 
    if mtype == TMessageType.EXCEPTION:
1907 
      x = TApplicationException()
1908 
      x.read(self._iprot)
1909 
      self._iprot.readMessageEnd()
1910 
      raise x
1911 
    result = getTrackLogById_result()
1912 
    result.read(self._iprot)
1913 
    self._iprot.readMessageEnd()
3431 rajveer 1914 
    if result.success is not None:
1845 vikas 1915 
      return result.success
3431 rajveer 1916 
    if result.utx is not None:
1845 vikas 1917 
      raise result.utx
1918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1919 
 
3293 vikas 1920 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1921 
    """
1922 
    Parameters:
1996 vikas 1923 
     - affiliateId
3293 vikas 1924 
     - startDate
1925 
     - endDate
1845 vikas 1926 
    """
3293 vikas 1927 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1928 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1929 
 
3293 vikas 1930 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1931 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1932 
    args = getTrackLogsByAffiliate_args()
1933 
    args.affiliateId = affiliateId
3293 vikas 1934 
    args.startDate = startDate
1935 
    args.endDate = endDate
1845 vikas 1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
1996 vikas 1940 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1942 
    if mtype == TMessageType.EXCEPTION:
1943 
      x = TApplicationException()
1944 
      x.read(self._iprot)
1945 
      self._iprot.readMessageEnd()
1946 
      raise x
1996 vikas 1947 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1948 
    result.read(self._iprot)
1949 
    self._iprot.readMessageEnd()
3431 rajveer 1950 
    if result.success is not None:
1845 vikas 1951 
      return result.success
3431 rajveer 1952 
    if result.utx is not None:
1845 vikas 1953 
      raise result.utx
1996 vikas 1954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1955 
 
1956 
  def getTrackLogsByUser(self, userId):
1957 
    """
1958 
    Parameters:
1959 
     - userId
1960 
    """
1961 
    self.send_getTrackLogsByUser(userId)
1962 
    return self.recv_getTrackLogsByUser()
1963 
 
1964 
  def send_getTrackLogsByUser(self, userId):
1965 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1966 
    args = getTrackLogsByUser_args()
1967 
    args.userId = userId
1968 
    args.write(self._oprot)
1969 
    self._oprot.writeMessageEnd()
1970 
    self._oprot.trans.flush()
1971 
 
1972 
  def recv_getTrackLogsByUser(self, ):
1973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1974 
    if mtype == TMessageType.EXCEPTION:
1975 
      x = TApplicationException()
1976 
      x.read(self._iprot)
1977 
      self._iprot.readMessageEnd()
1978 
      raise x
1979 
    result = getTrackLogsByUser_result()
1980 
    result.read(self._iprot)
1981 
    self._iprot.readMessageEnd()
3431 rajveer 1982 
    if result.success is not None:
1845 vikas 1983 
      return result.success
3431 rajveer 1984 
    if result.utx is not None:
1845 vikas 1985 
      raise result.utx
1986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1987 
 
1996 vikas 1988 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1989 
    """
1990 
    Parameters:
1991 
     - userId
1992 
     - event
1993 
     - url
1994 
    """
1996 vikas 1995 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1996 
    return self.recv_getTrackLogs()
1997 
 
1996 vikas 1998 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1999 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2000 
    args = getTrackLogs_args()
2001 
    args.userId = userId
2002 
    args.event = event
2003 
    args.url = url
2004 
    args.write(self._oprot)
2005 
    self._oprot.writeMessageEnd()
2006 
    self._oprot.trans.flush()
2007 
 
2008 
  def recv_getTrackLogs(self, ):
2009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2010 
    if mtype == TMessageType.EXCEPTION:
2011 
      x = TApplicationException()
2012 
      x.read(self._iprot)
2013 
      self._iprot.readMessageEnd()
2014 
      raise x
2015 
    result = getTrackLogs_result()
2016 
    result.read(self._iprot)
2017 
    self._iprot.readMessageEnd()
3431 rajveer 2018 
    if result.success is not None:
1845 vikas 2019 
      return result.success
3431 rajveer 2020 
    if result.utx is not None:
1845 vikas 2021 
      raise result.utx
2022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2023 
 
559 chandransh 2024 
  def getCurrentCart(self, userId):
94 ashish 2025 
    """
2026 
    Parameters:
559 chandransh 2027 
     - userId
94 ashish 2028 
    """
559 chandransh 2029 
    self.send_getCurrentCart(userId)
2030 
    return self.recv_getCurrentCart()
94 ashish 2031 
 
559 chandransh 2032 
  def send_getCurrentCart(self, userId):
2033 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2034 
    args = getCurrentCart_args()
2035 
    args.userId = userId
94 ashish 2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
559 chandransh 2040 
  def recv_getCurrentCart(self, ):
94 ashish 2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
559 chandransh 2047 
    result = getCurrentCart_result()
94 ashish 2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.success is not None:
94 ashish 2051 
      return result.success
3431 rajveer 2052 
    if result.scx is not None:
559 chandransh 2053 
      raise result.scx
2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2055 
 
559 chandransh 2056 
  def getCart(self, cartId):
94 ashish 2057 
    """
2058 
    Parameters:
559 chandransh 2059 
     - cartId
94 ashish 2060 
    """
559 chandransh 2061 
    self.send_getCart(cartId)
2062 
    return self.recv_getCart()
94 ashish 2063 
 
559 chandransh 2064 
  def send_getCart(self, cartId):
2065 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2066 
    args = getCart_args()
2067 
    args.cartId = cartId
94 ashish 2068 
    args.write(self._oprot)
2069 
    self._oprot.writeMessageEnd()
2070 
    self._oprot.trans.flush()
2071 
 
559 chandransh 2072 
  def recv_getCart(self, ):
94 ashish 2073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2074 
    if mtype == TMessageType.EXCEPTION:
2075 
      x = TApplicationException()
2076 
      x.read(self._iprot)
2077 
      self._iprot.readMessageEnd()
2078 
      raise x
559 chandransh 2079 
    result = getCart_result()
94 ashish 2080 
    result.read(self._iprot)
2081 
    self._iprot.readMessageEnd()
3431 rajveer 2082 
    if result.success is not None:
94 ashish 2083 
      return result.success
3431 rajveer 2084 
    if result.scx is not None:
559 chandransh 2085 
      raise result.scx
2086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2087 
 
559 chandransh 2088 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2089 
    """
2090 
    Parameters:
559 chandransh 2091 
     - from_time
2092 
     - to_time
2093 
     - status
94 ashish 2094 
    """
559 chandransh 2095 
    self.send_getCartsByTime(from_time, to_time, status)
2096 
    return self.recv_getCartsByTime()
94 ashish 2097 
 
559 chandransh 2098 
  def send_getCartsByTime(self, from_time, to_time, status):
2099 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2100 
    args = getCartsByTime_args()
2101 
    args.from_time = from_time
2102 
    args.to_time = to_time
2103 
    args.status = status
94 ashish 2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
559 chandransh 2108 
  def recv_getCartsByTime(self, ):
94 ashish 2109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2110 
    if mtype == TMessageType.EXCEPTION:
2111 
      x = TApplicationException()
2112 
      x.read(self._iprot)
2113 
      self._iprot.readMessageEnd()
2114 
      raise x
559 chandransh 2115 
    result = getCartsByTime_result()
94 ashish 2116 
    result.read(self._iprot)
2117 
    self._iprot.readMessageEnd()
3431 rajveer 2118 
    if result.success is not None:
94 ashish 2119 
      return result.success
3431 rajveer 2120 
    if result.scx is not None:
559 chandransh 2121 
      raise result.scx
2122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2123 
 
3557 rajveer 2124 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2125 
    """
2126 
    Parameters:
2127 
     - cartId
2128 
     - itemId
2129 
     - quantity
3557 rajveer 2130 
     - sourceId
559 chandransh 2131 
    """
3557 rajveer 2132 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2133 
    return self.recv_addItemToCart()
559 chandransh 2134 
 
3557 rajveer 2135 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2136 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2137 
    args = addItemToCart_args()
2138 
    args.cartId = cartId
2139 
    args.itemId = itemId
2140 
    args.quantity = quantity
3557 rajveer 2141 
    args.sourceId = sourceId
559 chandransh 2142 
    args.write(self._oprot)
2143 
    self._oprot.writeMessageEnd()
2144 
    self._oprot.trans.flush()
2145 
 
2146 
  def recv_addItemToCart(self, ):
2147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2148 
    if mtype == TMessageType.EXCEPTION:
2149 
      x = TApplicationException()
2150 
      x.read(self._iprot)
2151 
      self._iprot.readMessageEnd()
2152 
      raise x
2153 
    result = addItemToCart_result()
2154 
    result.read(self._iprot)
2155 
    self._iprot.readMessageEnd()
3431 rajveer 2156 
    if result.success is not None:
2035 rajveer 2157 
      return result.success
3431 rajveer 2158 
    if result.scx is not None:
559 chandransh 2159 
      raise result.scx
2035 rajveer 2160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2161 
 
2162 
  def deleteItemFromCart(self, cartId, itemId):
2163 
    """
2164 
    Parameters:
2165 
     - cartId
2166 
     - itemId
2167 
    """
2168 
    self.send_deleteItemFromCart(cartId, itemId)
2169 
    self.recv_deleteItemFromCart()
2170 
 
2171 
  def send_deleteItemFromCart(self, cartId, itemId):
2172 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2173 
    args = deleteItemFromCart_args()
2174 
    args.cartId = cartId
2175 
    args.itemId = itemId
2176 
    args.write(self._oprot)
2177 
    self._oprot.writeMessageEnd()
2178 
    self._oprot.trans.flush()
2179 
 
2180 
  def recv_deleteItemFromCart(self, ):
2181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2182 
    if mtype == TMessageType.EXCEPTION:
2183 
      x = TApplicationException()
2184 
      x.read(self._iprot)
2185 
      self._iprot.readMessageEnd()
2186 
      raise x
2187 
    result = deleteItemFromCart_result()
2188 
    result.read(self._iprot)
2189 
    self._iprot.readMessageEnd()
3431 rajveer 2190 
    if result.scx is not None:
559 chandransh 2191 
      raise result.scx
2192 
    return
2193 
 
2194 
  def addAddressToCart(self, cartId, addressId):
2195 
    """
2196 
    Parameters:
2197 
     - cartId
2198 
     - addressId
2199 
    """
2200 
    self.send_addAddressToCart(cartId, addressId)
2201 
    self.recv_addAddressToCart()
2202 
 
2203 
  def send_addAddressToCart(self, cartId, addressId):
2204 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2205 
    args = addAddressToCart_args()
2206 
    args.cartId = cartId
2207 
    args.addressId = addressId
2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
2212 
  def recv_addAddressToCart(self, ):
2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
2219 
    result = addAddressToCart_result()
2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
3431 rajveer 2222 
    if result.scx is not None:
575 chandransh 2223 
      raise result.scx
559 chandransh 2224 
    return
2225 
 
5553 rajveer 2226 
  def addStoreToCart(self, cartId, storeId):
2227 
    """
2228 
    Parameters:
2229 
     - cartId
2230 
     - storeId
2231 
    """
2232 
    self.send_addStoreToCart(cartId, storeId)
2233 
    self.recv_addStoreToCart()
2234 
 
2235 
  def send_addStoreToCart(self, cartId, storeId):
2236 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2237 
    args = addStoreToCart_args()
2238 
    args.cartId = cartId
2239 
    args.storeId = storeId
2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
2244 
  def recv_addStoreToCart(self, ):
2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
2251 
    result = addStoreToCart_result()
2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
2254 
    if result.scx is not None:
2255 
      raise result.scx
2256 
    return
2257 
 
6922 anupam.sin 2258 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2259 
    """
2260 
    Parameters:
6922 anupam.sin 2261 
     - cart
1976 varun.gupt 2262 
     - couponCode
2263 
    """
6922 anupam.sin 2264 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2265 
    self.recv_applyCouponToCart()
2266 
 
6922 anupam.sin 2267 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2268 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2269 
    args = applyCouponToCart_args()
6922 anupam.sin 2270 
    args.cart = cart
1976 varun.gupt 2271 
    args.couponCode = couponCode
2272 
    args.write(self._oprot)
2273 
    self._oprot.writeMessageEnd()
2274 
    self._oprot.trans.flush()
2275 
 
2276 
  def recv_applyCouponToCart(self, ):
2277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2278 
    if mtype == TMessageType.EXCEPTION:
2279 
      x = TApplicationException()
2280 
      x.read(self._iprot)
2281 
      self._iprot.readMessageEnd()
2282 
      raise x
2283 
    result = applyCouponToCart_result()
2284 
    result.read(self._iprot)
2285 
    self._iprot.readMessageEnd()
3431 rajveer 2286 
    if result.scx is not None:
1976 varun.gupt 2287 
      raise result.scx
2288 
    return
2289 
 
2290 
  def removeCoupon(self, cartId):
2291 
    """
2292 
    Parameters:
2293 
     - cartId
2294 
    """
2295 
    self.send_removeCoupon(cartId)
2296 
    self.recv_removeCoupon()
2297 
 
2298 
  def send_removeCoupon(self, cartId):
2299 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2300 
    args = removeCoupon_args()
2301 
    args.cartId = cartId
2302 
    args.write(self._oprot)
2303 
    self._oprot.writeMessageEnd()
2304 
    self._oprot.trans.flush()
2305 
 
2306 
  def recv_removeCoupon(self, ):
2307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2308 
    if mtype == TMessageType.EXCEPTION:
2309 
      x = TApplicationException()
2310 
      x.read(self._iprot)
2311 
      self._iprot.readMessageEnd()
2312 
      raise x
2313 
    result = removeCoupon_result()
2314 
    result.read(self._iprot)
2315 
    self._iprot.readMessageEnd()
3431 rajveer 2316 
    if result.scx is not None:
1976 varun.gupt 2317 
      raise result.scx
2318 
    return
2319 
 
3554 varun.gupt 2320 
  def deleteDiscountsFromCart(self, cartId):
2321 
    """
2322 
    Deletes all the discounts associated with the cart
2323 
 
2324 
    Parameters:
2325 
     - cartId
2326 
    """
2327 
    self.send_deleteDiscountsFromCart(cartId)
2328 
    self.recv_deleteDiscountsFromCart()
2329 
 
2330 
  def send_deleteDiscountsFromCart(self, cartId):
2331 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2332 
    args = deleteDiscountsFromCart_args()
2333 
    args.cartId = cartId
2334 
    args.write(self._oprot)
2335 
    self._oprot.writeMessageEnd()
2336 
    self._oprot.trans.flush()
2337 
 
2338 
  def recv_deleteDiscountsFromCart(self, ):
2339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2340 
    if mtype == TMessageType.EXCEPTION:
2341 
      x = TApplicationException()
2342 
      x.read(self._iprot)
2343 
      self._iprot.readMessageEnd()
2344 
      raise x
2345 
    result = deleteDiscountsFromCart_result()
2346 
    result.read(self._iprot)
2347 
    self._iprot.readMessageEnd()
2348 
    if result.scx is not None:
2349 
      raise result.scx
2350 
    return
2351 
 
2352 
  def saveDiscounts(self, discounts):
2353 
    """
2354 
    Accepts a list of thrift objects of Discount type and saves them
2355 
 
2356 
    Parameters:
2357 
     - discounts
2358 
    """
2359 
    self.send_saveDiscounts(discounts)
2360 
    self.recv_saveDiscounts()
2361 
 
2362 
  def send_saveDiscounts(self, discounts):
2363 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2364 
    args = saveDiscounts_args()
2365 
    args.discounts = discounts
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_saveDiscounts(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = saveDiscounts_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
2380 
    if result.scx is not None:
2381 
      raise result.scx
2382 
    return
2383 
 
11526 amit.gupta 2384 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2385 
    """
690 chandransh 2386 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2387 
 
559 chandransh 2388 
    Parameters:
2389 
     - cartId
2815 vikas 2390 
     - sessionSource
2391 
     - sessionStartTime
3858 vikas 2392 
     - firstSource
2393 
     - firstSourceTime
5326 rajveer 2394 
     - userId
6389 rajveer 2395 
     - schemeId
11526 amit.gupta 2396 
     - orderSource
559 chandransh 2397 
    """
11526 amit.gupta 2398 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2399 
    return self.recv_createOrders()
559 chandransh 2400 
 
11526 amit.gupta 2401 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2402 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2403 
    args = createOrders_args()
559 chandransh 2404 
    args.cartId = cartId
2815 vikas 2405 
    args.sessionSource = sessionSource
2406 
    args.sessionStartTime = sessionStartTime
3858 vikas 2407 
    args.firstSource = firstSource
2408 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2409 
    args.userId = userId
6389 rajveer 2410 
    args.schemeId = schemeId
11526 amit.gupta 2411 
    args.orderSource = orderSource
559 chandransh 2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
690 chandransh 2416 
  def recv_createOrders(self, ):
559 chandransh 2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
690 chandransh 2423 
    result = createOrders_result()
559 chandransh 2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
3431 rajveer 2426 
    if result.success is not None:
130 ashish 2427 
      return result.success
3431 rajveer 2428 
    if result.scx is not None:
559 chandransh 2429 
      raise result.scx
690 chandransh 2430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2431 
 
3557 rajveer 2432 
  def validateCart(self, cartId, sourceId):
130 ashish 2433 
    """
690 chandransh 2434 
    Validates that:
2435 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2436 
    2. All of the lines in the cart are active items.
690 chandransh 2437 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2438 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2439 
 
130 ashish 2440 
    Parameters:
559 chandransh 2441 
     - cartId
3557 rajveer 2442 
     - sourceId
130 ashish 2443 
    """
3557 rajveer 2444 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2445 
    return self.recv_validateCart()
130 ashish 2446 
 
3557 rajveer 2447 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2448 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2449 
    args = validateCart_args()
2450 
    args.cartId = cartId
3557 rajveer 2451 
    args.sourceId = sourceId
130 ashish 2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
559 chandransh 2456 
  def recv_validateCart(self, ):
130 ashish 2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
559 chandransh 2463 
    result = validateCart_result()
130 ashish 2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
3431 rajveer 2466 
    if result.success is not None:
130 ashish 2467 
      return result.success
3431 rajveer 2468 
    if result.scex is not None:
575 chandransh 2469 
      raise result.scex
559 chandransh 2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2471 
 
11980 amit.gupta 2472 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2473 
    """
2474 
    Validates that:
2475 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2476 
    2. All of the lines in the cart are active items.
2477 
    3. The estimate for any of the lines in cart doesn't change.
2478 
    If all three are true, returns empty string; else returns appropriate message.
2479 
 
2480 
    Parameters:
2481 
     - cartId
2482 
     - sourceId
2483 
     - dealCoupon
2484 
    """
2485 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2486 
    return self.recv_validateCartWithDealerCoupon()
2487 
 
2488 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2489 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2490 
    args = validateCartWithDealerCoupon_args()
2491 
    args.cartId = cartId
2492 
    args.sourceId = sourceId
2493 
    args.dealCoupon = dealCoupon
2494 
    args.write(self._oprot)
2495 
    self._oprot.writeMessageEnd()
2496 
    self._oprot.trans.flush()
2497 
 
2498 
  def recv_validateCartWithDealerCoupon(self, ):
2499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2500 
    if mtype == TMessageType.EXCEPTION:
2501 
      x = TApplicationException()
2502 
      x.read(self._iprot)
2503 
      self._iprot.readMessageEnd()
2504 
      raise x
2505 
    result = validateCartWithDealerCoupon_result()
2506 
    result.read(self._iprot)
2507 
    self._iprot.readMessageEnd()
2508 
    if result.success is not None:
2509 
      return result.success
2510 
    if result.scex is not None:
2511 
      raise result.scex
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2513 
 
690 chandransh 2514 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2515 
    """
690 chandransh 2516 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2517 
 
575 chandransh 2518 
    Parameters:
690 chandransh 2519 
     - fromCartId
2520 
     - toCartId
2521 
    """
2522 
    self.send_mergeCart(fromCartId, toCartId)
2523 
    self.recv_mergeCart()
2524 
 
2525 
  def send_mergeCart(self, fromCartId, toCartId):
2526 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2527 
    args = mergeCart_args()
2528 
    args.fromCartId = fromCartId
2529 
    args.toCartId = toCartId
2530 
    args.write(self._oprot)
2531 
    self._oprot.writeMessageEnd()
2532 
    self._oprot.trans.flush()
2533 
 
2534 
  def recv_mergeCart(self, ):
2535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2536 
    if mtype == TMessageType.EXCEPTION:
2537 
      x = TApplicationException()
2538 
      x.read(self._iprot)
2539 
      self._iprot.readMessageEnd()
2540 
      raise x
2541 
    result = mergeCart_result()
2542 
    result.read(self._iprot)
2543 
    self._iprot.readMessageEnd()
2544 
    return
2545 
 
2546 
  def checkOut(self, cartId):
2547 
    """
2548 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2549 
 
690 chandransh 2550 
    Parameters:
575 chandransh 2551 
     - cartId
2552 
    """
690 chandransh 2553 
    self.send_checkOut(cartId)
2554 
    return self.recv_checkOut()
575 chandransh 2555 
 
690 chandransh 2556 
  def send_checkOut(self, cartId):
2557 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2558 
    args = checkOut_args()
575 chandransh 2559 
    args.cartId = cartId
2560 
    args.write(self._oprot)
2561 
    self._oprot.writeMessageEnd()
2562 
    self._oprot.trans.flush()
2563 
 
690 chandransh 2564 
  def recv_checkOut(self, ):
575 chandransh 2565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2566 
    if mtype == TMessageType.EXCEPTION:
2567 
      x = TApplicationException()
2568 
      x.read(self._iprot)
2569 
      self._iprot.readMessageEnd()
2570 
      raise x
690 chandransh 2571 
    result = checkOut_result()
575 chandransh 2572 
    result.read(self._iprot)
2573 
    self._iprot.readMessageEnd()
3431 rajveer 2574 
    if result.success is not None:
575 chandransh 2575 
      return result.success
3431 rajveer 2576 
    if result.scex is not None:
575 chandransh 2577 
      raise result.scex
690 chandransh 2578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2579 
 
690 chandransh 2580 
  def resetCart(self, cartId, items):
559 chandransh 2581 
    """
690 chandransh 2582 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2583 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2584 
 
559 chandransh 2585 
    Parameters:
690 chandransh 2586 
     - cartId
2587 
     - items
559 chandransh 2588 
    """
690 chandransh 2589 
    self.send_resetCart(cartId, items)
2590 
    return self.recv_resetCart()
130 ashish 2591 
 
690 chandransh 2592 
  def send_resetCart(self, cartId, items):
2593 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2594 
    args = resetCart_args()
2595 
    args.cartId = cartId
2596 
    args.items = items
559 chandransh 2597 
    args.write(self._oprot)
2598 
    self._oprot.writeMessageEnd()
2599 
    self._oprot.trans.flush()
2600 
 
690 chandransh 2601 
  def recv_resetCart(self, ):
559 chandransh 2602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2603 
    if mtype == TMessageType.EXCEPTION:
2604 
      x = TApplicationException()
2605 
      x.read(self._iprot)
2606 
      self._iprot.readMessageEnd()
2607 
      raise x
690 chandransh 2608 
    result = resetCart_result()
559 chandransh 2609 
    result.read(self._iprot)
2610 
    self._iprot.readMessageEnd()
3431 rajveer 2611 
    if result.success is not None:
690 chandransh 2612 
      return result.success
3431 rajveer 2613 
    if result.scex is not None:
690 chandransh 2614 
      raise result.scex
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2616 
 
2981 rajveer 2617 
  def getUserCount(self, userType):
559 chandransh 2618 
    """
2981 rajveer 2619 
    Returns number of registered users.
2620 
    If userType = null, then it returns count of all users, including anonymous
2621 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2622 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2623 
 
559 chandransh 2624 
    Parameters:
2981 rajveer 2625 
     - userType
559 chandransh 2626 
    """
2981 rajveer 2627 
    self.send_getUserCount(userType)
2628 
    return self.recv_getUserCount()
559 chandransh 2629 
 
2981 rajveer 2630 
  def send_getUserCount(self, userType):
2631 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2632 
    args = getUserCount_args()
2633 
    args.userType = userType
559 chandransh 2634 
    args.write(self._oprot)
2635 
    self._oprot.writeMessageEnd()
2636 
    self._oprot.trans.flush()
2637 
 
2981 rajveer 2638 
  def recv_getUserCount(self, ):
559 chandransh 2639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2640 
    if mtype == TMessageType.EXCEPTION:
2641 
      x = TApplicationException()
2642 
      x.read(self._iprot)
2643 
      self._iprot.readMessageEnd()
2644 
      raise x
2981 rajveer 2645 
    result = getUserCount_result()
559 chandransh 2646 
    result.read(self._iprot)
2647 
    self._iprot.readMessageEnd()
3431 rajveer 2648 
    if result.success is not None:
559 chandransh 2649 
      return result.success
2981 rajveer 2650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2651 
 
2981 rajveer 2652 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2653 
    """
2981 rajveer 2654 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2655 
    If any of startDate or endDate is -1, then that filter is ignored.
2656 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2657 
 
2658 
 
559 chandransh 2659 
    Parameters:
2981 rajveer 2660 
     - userType
2661 
     - startDate
2662 
     - endDate
559 chandransh 2663 
    """
2981 rajveer 2664 
    self.send_getAllUsers(userType, startDate, endDate)
2665 
    return self.recv_getAllUsers()
559 chandransh 2666 
 
2981 rajveer 2667 
  def send_getAllUsers(self, userType, startDate, endDate):
2668 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2669 
    args = getAllUsers_args()
2670 
    args.userType = userType
2671 
    args.startDate = startDate
2672 
    args.endDate = endDate
559 chandransh 2673 
    args.write(self._oprot)
2674 
    self._oprot.writeMessageEnd()
2675 
    self._oprot.trans.flush()
2676 
 
2981 rajveer 2677 
  def recv_getAllUsers(self, ):
559 chandransh 2678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2679 
    if mtype == TMessageType.EXCEPTION:
2680 
      x = TApplicationException()
2681 
      x.read(self._iprot)
2682 
      self._iprot.readMessageEnd()
2683 
      raise x
2981 rajveer 2684 
    result = getAllUsers_result()
559 chandransh 2685 
    result.read(self._iprot)
2686 
    self._iprot.readMessageEnd()
3431 rajveer 2687 
    if result.success is not None:
559 chandransh 2688 
      return result.success
2981 rajveer 2689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2690 
 
2981 rajveer 2691 
  def getMyResearchItems(self, userId):
559 chandransh 2692 
    """
2981 rajveer 2693 
    Returns list of item ids in myresearch for the user
3431 rajveer 2694 
 
559 chandransh 2695 
    Parameters:
772 rajveer 2696 
     - userId
559 chandransh 2697 
    """
2981 rajveer 2698 
    self.send_getMyResearchItems(userId)
2699 
    return self.recv_getMyResearchItems()
559 chandransh 2700 
 
2981 rajveer 2701 
  def send_getMyResearchItems(self, userId):
2702 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2703 
    args = getMyResearchItems_args()
772 rajveer 2704 
    args.userId = userId
559 chandransh 2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
2981 rajveer 2709 
  def recv_getMyResearchItems(self, ):
559 chandransh 2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
2981 rajveer 2716 
    result = getMyResearchItems_result()
559 chandransh 2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
3431 rajveer 2719 
    if result.success is not None:
559 chandransh 2720 
      return result.success
3431 rajveer 2721 
    if result.scx is not None:
559 chandransh 2722 
      raise result.scx
2981 rajveer 2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2724 
 
2981 rajveer 2725 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2726 
    """
2981 rajveer 2727 
    add item to my research for a user
3431 rajveer 2728 
 
559 chandransh 2729 
    Parameters:
2981 rajveer 2730 
     - userId
2731 
     - itemId
559 chandransh 2732 
    """
2981 rajveer 2733 
    self.send_updateMyResearch(userId, itemId)
2734 
    return self.recv_updateMyResearch()
559 chandransh 2735 
 
2981 rajveer 2736 
  def send_updateMyResearch(self, userId, itemId):
2737 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2738 
    args = updateMyResearch_args()
2739 
    args.userId = userId
2740 
    args.itemId = itemId
559 chandransh 2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
2981 rajveer 2745 
  def recv_updateMyResearch(self, ):
559 chandransh 2746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2747 
    if mtype == TMessageType.EXCEPTION:
2748 
      x = TApplicationException()
2749 
      x.read(self._iprot)
2750 
      self._iprot.readMessageEnd()
2751 
      raise x
2981 rajveer 2752 
    result = updateMyResearch_result()
559 chandransh 2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
3431 rajveer 2755 
    if result.success is not None:
2981 rajveer 2756 
      return result.success
3431 rajveer 2757 
    if result.scx is not None:
2981 rajveer 2758 
      raise result.scx
2759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2760 
 
2981 rajveer 2761 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2762 
    """
2981 rajveer 2763 
    delete item from my research for a user
3431 rajveer 2764 
 
1596 ankur.sing 2765 
    Parameters:
2981 rajveer 2766 
     - userId
2767 
     - itemId
1596 ankur.sing 2768 
    """
2981 rajveer 2769 
    self.send_deleteItemFromMyResearch(userId, itemId)
2770 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2771 
 
2981 rajveer 2772 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2773 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2774 
    args = deleteItemFromMyResearch_args()
2775 
    args.userId = userId
2776 
    args.itemId = itemId
1596 ankur.sing 2777 
    args.write(self._oprot)
2778 
    self._oprot.writeMessageEnd()
2779 
    self._oprot.trans.flush()
2780 
 
2981 rajveer 2781 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2783 
    if mtype == TMessageType.EXCEPTION:
2784 
      x = TApplicationException()
2785 
      x.read(self._iprot)
2786 
      self._iprot.readMessageEnd()
2787 
      raise x
2981 rajveer 2788 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2789 
    result.read(self._iprot)
2790 
    self._iprot.readMessageEnd()
3431 rajveer 2791 
    if result.scx is not None:
2981 rajveer 2792 
      raise result.scx
2793 
    return
1596 ankur.sing 2794 
 
2981 rajveer 2795 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2796 
    """
2981 rajveer 2797 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2798 
 
1673 ankur.sing 2799 
    Parameters:
2981 rajveer 2800 
     - userId
1673 ankur.sing 2801 
    """
2981 rajveer 2802 
    self.send_getBrowseHistoryItems(userId)
2803 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2804 
 
2981 rajveer 2805 
  def send_getBrowseHistoryItems(self, userId):
2806 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2807 
    args = getBrowseHistoryItems_args()
2808 
    args.userId = userId
1673 ankur.sing 2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2981 rajveer 2813 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2815 
    if mtype == TMessageType.EXCEPTION:
2816 
      x = TApplicationException()
2817 
      x.read(self._iprot)
2818 
      self._iprot.readMessageEnd()
2819 
      raise x
2981 rajveer 2820 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
3431 rajveer 2823 
    if result.success is not None:
1673 ankur.sing 2824 
      return result.success
3431 rajveer 2825 
    if result.scx is not None:
2981 rajveer 2826 
      raise result.scx
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2828 
 
2981 rajveer 2829 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2830 
    """
2981 rajveer 2831 
    add item to browse history for a user
3431 rajveer 2832 
 
2642 varun.gupt 2833 
    Parameters:
2981 rajveer 2834 
     - userId
2835 
     - itemId
2642 varun.gupt 2836 
    """
2981 rajveer 2837 
    self.send_updateBrowseHistory(userId, itemId)
2838 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2839 
 
2981 rajveer 2840 
  def send_updateBrowseHistory(self, userId, itemId):
2841 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2842 
    args = updateBrowseHistory_args()
2843 
    args.userId = userId
2844 
    args.itemId = itemId
2642 varun.gupt 2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2981 rajveer 2849 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2851 
    if mtype == TMessageType.EXCEPTION:
2852 
      x = TApplicationException()
2853 
      x.read(self._iprot)
2854 
      self._iprot.readMessageEnd()
2855 
      raise x
2981 rajveer 2856 
    result = updateBrowseHistory_result()
2642 varun.gupt 2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
2859 
    return
2860 
 
3385 varun.gupt 2861 
  def getCartsWithCouponCount(self, couponCode):
2862 
    """
2863 
    Returns count of Carts with given coupon applied
3431 rajveer 2864 
 
3385 varun.gupt 2865 
    Parameters:
2866 
     - couponCode
2867 
    """
2868 
    self.send_getCartsWithCouponCount(couponCode)
2869 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2870 
 
3385 varun.gupt 2871 
  def send_getCartsWithCouponCount(self, couponCode):
2872 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2873 
    args = getCartsWithCouponCount_args()
2874 
    args.couponCode = couponCode
2875 
    args.write(self._oprot)
2876 
    self._oprot.writeMessageEnd()
2877 
    self._oprot.trans.flush()
2878 
 
2879 
  def recv_getCartsWithCouponCount(self, ):
2880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2881 
    if mtype == TMessageType.EXCEPTION:
2882 
      x = TApplicationException()
2883 
      x.read(self._iprot)
2884 
      self._iprot.readMessageEnd()
2885 
      raise x
2886 
    result = getCartsWithCouponCount_result()
2887 
    result.read(self._iprot)
2888 
    self._iprot.readMessageEnd()
3431 rajveer 2889 
    if result.success is not None:
3385 varun.gupt 2890 
      return result.success
2891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2892 
 
3499 mandeep.dh 2893 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2894 
    """
2895 
    Updates COD trust level of a user
3385 varun.gupt 2896 
 
3499 mandeep.dh 2897 
    Parameters:
2898 
     - userId
2899 
     - trustLevelDelta
2900 
    """
2901 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2902 
 
2903 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2904 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2905 
    args = increaseTrustLevel_args()
2906 
    args.userId = userId
2907 
    args.trustLevelDelta = trustLevelDelta
2908 
    args.write(self._oprot)
2909 
    self._oprot.writeMessageEnd()
2910 
    self._oprot.trans.flush()
5407 amar.kumar 2911 
  def getTrustLevel(self, userId):
2912 
    """
2913 
    Get trust level of a user
2914 
 
2915 
    Parameters:
2916 
     - userId
2917 
    """
2918 
    self.send_getTrustLevel(userId)
2919 
    return self.recv_getTrustLevel()
2920 
 
2921 
  def send_getTrustLevel(self, userId):
2922 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2923 
    args = getTrustLevel_args()
2924 
    args.userId = userId
2925 
    args.write(self._oprot)
2926 
    self._oprot.writeMessageEnd()
2927 
    self._oprot.trans.flush()
2928 
 
2929 
  def recv_getTrustLevel(self, ):
2930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2931 
    if mtype == TMessageType.EXCEPTION:
2932 
      x = TApplicationException()
2933 
      x.read(self._iprot)
2934 
      self._iprot.readMessageEnd()
2935 
      raise x
2936 
    result = getTrustLevel_result()
2937 
    result.read(self._iprot)
2938 
    self._iprot.readMessageEnd()
2939 
    if result.success is not None:
2940 
      return result.success
2941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2942 
 
4668 varun.gupt 2943 
  def showCODOption(self, cartId, sourceId, pincode):
2944 
    """
2945 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2946 
 
4668 varun.gupt 2947 
    Parameters:
2948 
     - cartId
2949 
     - sourceId
2950 
     - pincode
2951 
    """
2952 
    self.send_showCODOption(cartId, sourceId, pincode)
2953 
    return self.recv_showCODOption()
2954 
 
2955 
  def send_showCODOption(self, cartId, sourceId, pincode):
2956 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2957 
    args = showCODOption_args()
2958 
    args.cartId = cartId
2959 
    args.sourceId = sourceId
2960 
    args.pincode = pincode
2961 
    args.write(self._oprot)
2962 
    self._oprot.writeMessageEnd()
2963 
    self._oprot.trans.flush()
2964 
 
2965 
  def recv_showCODOption(self, ):
2966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2967 
    if mtype == TMessageType.EXCEPTION:
2968 
      x = TApplicationException()
2969 
      x.read(self._iprot)
2970 
      self._iprot.readMessageEnd()
2971 
      raise x
2972 
    result = showCODOption_result()
2973 
    result.read(self._iprot)
2974 
    self._iprot.readMessageEnd()
2975 
    if result.success is not None:
2976 
      return result.success
2977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2978 
 
5623 anupam.sin 2979 
  def getUserEmails(self, startDate, endDate):
2980 
    """
2981 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2982 
 
5623 anupam.sin 2983 
    Parameters:
2984 
     - startDate
2985 
     - endDate
2986 
    """
2987 
    self.send_getUserEmails(startDate, endDate)
2988 
    return self.recv_getUserEmails()
2989 
 
2990 
  def send_getUserEmails(self, startDate, endDate):
2991 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
2992 
    args = getUserEmails_args()
2993 
    args.startDate = startDate
2994 
    args.endDate = endDate
2995 
    args.write(self._oprot)
2996 
    self._oprot.writeMessageEnd()
2997 
    self._oprot.trans.flush()
2998 
 
2999 
  def recv_getUserEmails(self, ):
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
3006 
    result = getUserEmails_result()
3007 
    result.read(self._iprot)
3008 
    self._iprot.readMessageEnd()
3009 
    if result.success is not None:
3010 
      return result.success
3011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3012 
 
9299 kshitij.so 3013 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3014 
    """
3015 
    Mark a cart lineitem as insured. Returns true/false.
3016 
 
3017 
    Parameters:
3018 
     - itemId
3019 
     - cartId
3020 
     - toInsure
9299 kshitij.so 3021 
     - insurerType
6903 anupam.sin 3022 
    """
9299 kshitij.so 3023 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3024 
    return self.recv_insureItem()
3025 
 
9299 kshitij.so 3026 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3027 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3028 
    args = insureItem_args()
3029 
    args.itemId = itemId
3030 
    args.cartId = cartId
3031 
    args.toInsure = toInsure
9299 kshitij.so 3032 
    args.insurerType = insurerType
6903 anupam.sin 3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_insureItem(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = insureItem_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3047 
    if result.success is not None:
3048 
      return result.success
3049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3050 
 
3051 
  def cancelInsurance(self, cartId):
3052 
    """
3053 
    Cancel insurance for all items in the cart
3054 
 
3055 
    Parameters:
3056 
     - cartId
3057 
    """
3058 
    self.send_cancelInsurance(cartId)
3059 
    return self.recv_cancelInsurance()
3060 
 
3061 
  def send_cancelInsurance(self, cartId):
3062 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3063 
    args = cancelInsurance_args()
3064 
    args.cartId = cartId
3065 
    args.write(self._oprot)
3066 
    self._oprot.writeMessageEnd()
3067 
    self._oprot.trans.flush()
3068 
 
3069 
  def recv_cancelInsurance(self, ):
3070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3071 
    if mtype == TMessageType.EXCEPTION:
3072 
      x = TApplicationException()
3073 
      x.read(self._iprot)
3074 
      self._iprot.readMessageEnd()
3075 
      raise x
3076 
    result = cancelInsurance_result()
3077 
    result.read(self._iprot)
3078 
    self._iprot.readMessageEnd()
3079 
    if result.success is not None:
3080 
      return result.success
3081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3082 
 
3083 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3084 
    """
3085 
    Stores insurance specific details like date of birth and guardianName
3086 
 
3087 
    Parameters:
3088 
     - addressId
3089 
     - dob
3090 
     - guardianName
3091 
    """
3092 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3093 
    return self.recv_storeInsuranceSpecificDetails()
3094 
 
3095 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3096 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3097 
    args = storeInsuranceSpecificDetails_args()
3098 
    args.addressId = addressId
3099 
    args.dob = dob
3100 
    args.guardianName = guardianName
3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_storeInsuranceSpecificDetails(self, ):
3106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3107 
    if mtype == TMessageType.EXCEPTION:
3108 
      x = TApplicationException()
3109 
      x.read(self._iprot)
3110 
      self._iprot.readMessageEnd()
3111 
      raise x
3112 
    result = storeInsuranceSpecificDetails_result()
3113 
    result.read(self._iprot)
3114 
    self._iprot.readMessageEnd()
3115 
    if result.success is not None:
3116 
      return result.success
3117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3118 
 
3119 
  def isInsuranceDetailPresent(self, addressId):
3120 
    """
3121 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3122 
 
3123 
    Parameters:
3124 
     - addressId
3125 
    """
3126 
    self.send_isInsuranceDetailPresent(addressId)
3127 
    return self.recv_isInsuranceDetailPresent()
3128 
 
3129 
  def send_isInsuranceDetailPresent(self, addressId):
3130 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3131 
    args = isInsuranceDetailPresent_args()
3132 
    args.addressId = addressId
3133 
    args.write(self._oprot)
3134 
    self._oprot.writeMessageEnd()
3135 
    self._oprot.trans.flush()
3136 
 
3137 
  def recv_isInsuranceDetailPresent(self, ):
3138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3139 
    if mtype == TMessageType.EXCEPTION:
3140 
      x = TApplicationException()
3141 
      x.read(self._iprot)
3142 
      self._iprot.readMessageEnd()
3143 
      raise x
3144 
    result = isInsuranceDetailPresent_result()
3145 
    result.read(self._iprot)
3146 
    self._iprot.readMessageEnd()
3147 
    if result.success is not None:
3148 
      return result.success
3149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3150 
 
9791 rajveer 3151 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3152 
    """
9791 rajveer 3153 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3154 
 
6821 amar.kumar 3155 
    Parameters:
3156 
     - startDate
3157 
     - endDate
3158 
    """
9791 rajveer 3159 
    self.send_getProductsAddedToCart(startDate, endDate)
3160 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3161 
 
9791 rajveer 3162 
  def send_getProductsAddedToCart(self, startDate, endDate):
3163 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3164 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3165 
    args.startDate = startDate
3166 
    args.endDate = endDate
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
9791 rajveer 3171 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
9791 rajveer 3178 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.success is not None:
3182 
      return result.success
9791 rajveer 3183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3184 
 
11980 amit.gupta 3185 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3186 
    """
3187 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3188 
 
11592 amit.gupta 3189 
    Parameters:
3190 
     - cartId
3191 
     - sourceId
11980 amit.gupta 3192 
     - dealerCoupon
11592 amit.gupta 3193 
    """
11980 amit.gupta 3194 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3195 
    return self.recv_validateCartPlus()
3196 
 
11980 amit.gupta 3197 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3198 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3199 
    args = validateCartPlus_args()
3200 
    args.cartId = cartId
3201 
    args.sourceId = sourceId
11980 amit.gupta 3202 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3203 
    args.write(self._oprot)
3204 
    self._oprot.writeMessageEnd()
3205 
    self._oprot.trans.flush()
3206 
 
3207 
  def recv_validateCartPlus(self, ):
3208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3209 
    if mtype == TMessageType.EXCEPTION:
3210 
      x = TApplicationException()
3211 
      x.read(self._iprot)
3212 
      self._iprot.readMessageEnd()
3213 
      raise x
3214 
    result = validateCartPlus_result()
3215 
    result.read(self._iprot)
3216 
    self._iprot.readMessageEnd()
3217 
    if result.success is not None:
3218 
      return result.success
3219 
    if result.scex is not None:
3220 
      raise result.scex
3221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3222 
 
11679 vikram.rag 3223 
  def isPrivateDealUser(self, userId):
3224 
    """
3225 
    Parameters:
3226 
     - userId
3227 
    """
3228 
    self.send_isPrivateDealUser(userId)
3229 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3230 
 
11679 vikram.rag 3231 
  def send_isPrivateDealUser(self, userId):
3232 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3233 
    args = isPrivateDealUser_args()
3234 
    args.userId = userId
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
3239 
  def recv_isPrivateDealUser(self, ):
3240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3241 
    if mtype == TMessageType.EXCEPTION:
3242 
      x = TApplicationException()
3243 
      x.read(self._iprot)
3244 
      self._iprot.readMessageEnd()
3245 
      raise x
3246 
    result = isPrivateDealUser_result()
3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
3249 
    if result.success is not None:
3250 
      return result.success
3251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3252 
 
11890 kshitij.so 3253 
  def addPrivateDealUser(self, userId):
3254 
    """
3255 
    Parameters:
3256 
     - userId
3257 
    """
3258 
    self.send_addPrivateDealUser(userId)
3259 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3260 
 
11890 kshitij.so 3261 
  def send_addPrivateDealUser(self, userId):
3262 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3263 
    args = addPrivateDealUser_args()
3264 
    args.userId = userId
3265 
    args.write(self._oprot)
3266 
    self._oprot.writeMessageEnd()
3267 
    self._oprot.trans.flush()
3268 
 
3269 
  def recv_addPrivateDealUser(self, ):
3270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3271 
    if mtype == TMessageType.EXCEPTION:
3272 
      x = TApplicationException()
3273 
      x.read(self._iprot)
3274 
      self._iprot.readMessageEnd()
3275 
      raise x
3276 
    result = addPrivateDealUser_result()
3277 
    result.read(self._iprot)
3278 
    self._iprot.readMessageEnd()
3279 
    if result.success is not None:
3280 
      return result.success
3281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3282 
 
3283 
  def changePrivateDealUserStatus(self, userId, isActive):
3284 
    """
3285 
    Parameters:
3286 
     - userId
3287 
     - isActive
3288 
    """
3289 
    self.send_changePrivateDealUserStatus(userId, isActive)
3290 
    return self.recv_changePrivateDealUserStatus()
3291 
 
3292 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3293 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3294 
    args = changePrivateDealUserStatus_args()
3295 
    args.userId = userId
3296 
    args.isActive = isActive
3297 
    args.write(self._oprot)
3298 
    self._oprot.writeMessageEnd()
3299 
    self._oprot.trans.flush()
3300 
 
3301 
  def recv_changePrivateDealUserStatus(self, ):
3302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3303 
    if mtype == TMessageType.EXCEPTION:
3304 
      x = TApplicationException()
3305 
      x.read(self._iprot)
3306 
      self._iprot.readMessageEnd()
3307 
      raise x
3308 
    result = changePrivateDealUserStatus_result()
3309 
    result.read(self._iprot)
3310 
    self._iprot.readMessageEnd()
3311 
    if result.success is not None:
3312 
      return result.success
3313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3314 
 
3315 
  def getPrivateDealUser(self, userId):
3316 
    """
3317 
    Parameters:
3318 
     - userId
3319 
    """
3320 
    self.send_getPrivateDealUser(userId)
3321 
    return self.recv_getPrivateDealUser()
3322 
 
3323 
  def send_getPrivateDealUser(self, userId):
3324 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3325 
    args = getPrivateDealUser_args()
3326 
    args.userId = userId
3327 
    args.write(self._oprot)
3328 
    self._oprot.writeMessageEnd()
3329 
    self._oprot.trans.flush()
3330 
 
3331 
  def recv_getPrivateDealUser(self, ):
3332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3333 
    if mtype == TMessageType.EXCEPTION:
3334 
      x = TApplicationException()
3335 
      x.read(self._iprot)
3336 
      self._iprot.readMessageEnd()
3337 
      raise x
3338 
    result = getPrivateDealUser_result()
3339 
    result.read(self._iprot)
3340 
    self._iprot.readMessageEnd()
3341 
    if result.success is not None:
3342 
      return result.success
3343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3344 
 
12696 amit.gupta 3345 
  def registerCounter(self, counter, userId):
3346 
    """
3347 
    Parameters:
3348 
     - counter
3349 
     - userId
3350 
    """
3351 
    self.send_registerCounter(counter, userId)
3352 
    return self.recv_registerCounter()
11890 kshitij.so 3353 
 
12696 amit.gupta 3354 
  def send_registerCounter(self, counter, userId):
3355 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3356 
    args = registerCounter_args()
3357 
    args.counter = counter
3358 
    args.userId = userId
3359 
    args.write(self._oprot)
3360 
    self._oprot.writeMessageEnd()
3361 
    self._oprot.trans.flush()
3362 
 
3363 
  def recv_registerCounter(self, ):
3364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3365 
    if mtype == TMessageType.EXCEPTION:
3366 
      x = TApplicationException()
3367 
      x.read(self._iprot)
3368 
      self._iprot.readMessageEnd()
3369 
      raise x
3370 
    result = registerCounter_result()
3371 
    result.read(self._iprot)
3372 
    self._iprot.readMessageEnd()
3373 
    if result.success is not None:
3374 
      return result.success
3375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3376 
 
12722 amit.gupta 3377 
  def searchCounter(self, type1, searchString):
3378 
    """
3379 
    Parameters:
3380 
     - type1
3381 
     - searchString
3382 
    """
3383 
    self.send_searchCounter(type1, searchString)
3384 
    return self.recv_searchCounter()
12696 amit.gupta 3385 
 
12722 amit.gupta 3386 
  def send_searchCounter(self, type1, searchString):
3387 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3388 
    args = searchCounter_args()
3389 
    args.type1 = type1
3390 
    args.searchString = searchString
3391 
    args.write(self._oprot)
3392 
    self._oprot.writeMessageEnd()
3393 
    self._oprot.trans.flush()
3394 
 
3395 
  def recv_searchCounter(self, ):
3396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3397 
    if mtype == TMessageType.EXCEPTION:
3398 
      x = TApplicationException()
3399 
      x.read(self._iprot)
3400 
      self._iprot.readMessageEnd()
3401 
      raise x
3402 
    result = searchCounter_result()
3403 
    result.read(self._iprot)
3404 
    self._iprot.readMessageEnd()
3405 
    if result.success is not None:
3406 
      return result.success
3407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3408 
 
3409 
  def getAllUsersByCounter(self, counterId):
3410 
    """
3411 
    Parameters:
3412 
     - counterId
3413 
    """
3414 
    self.send_getAllUsersByCounter(counterId)
3415 
    return self.recv_getAllUsersByCounter()
3416 
 
3417 
  def send_getAllUsersByCounter(self, counterId):
3418 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3419 
    args = getAllUsersByCounter_args()
3420 
    args.counterId = counterId
3421 
    args.write(self._oprot)
3422 
    self._oprot.writeMessageEnd()
3423 
    self._oprot.trans.flush()
3424 
 
3425 
  def recv_getAllUsersByCounter(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 = getAllUsersByCounter_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, "getAllUsersByCounter failed: unknown result");
3438 
 
3439 
 
3376 rajveer 3440 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3441 
  def __init__(self, handler):
3376 rajveer 3442 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3443 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3444 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3445 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3446 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3447 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3448 
    self._processMap["createUser"] = Processor.process_createUser
3449 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3450 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3451 
    self._processMap["userExists"] = Processor.process_userExists
3452 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3453 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3454 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3455 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3456 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3457 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3458 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3459 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3460 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3461 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3462 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3463 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3464 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3465 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3466 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3467 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3468 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3469 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3470 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3471 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3472 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3473 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3474 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3475 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3476 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3477 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3478 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3479 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3480 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3481 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3482 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3483 
    self._processMap["getCart"] = Processor.process_getCart
3484 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3485 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3486 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3487 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3488 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3489 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3490 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3491 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3492 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3493 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3494 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3495 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3496 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3497 
    self._processMap["checkOut"] = Processor.process_checkOut
3498 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3499 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3500 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3501 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3502 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3503 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3504 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3505 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3506 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3507 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3508 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3509 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3510 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3511 
    self._processMap["insureItem"] = Processor.process_insureItem
3512 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3513 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3514 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3515 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3516 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3517 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3518 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3519 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3520 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3521 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3522 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3523 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
94 ashish 3524 
 
3525 
  def process(self, iprot, oprot):
3526 
    (name, type, seqid) = iprot.readMessageBegin()
3527 
    if name not in self._processMap:
3528 
      iprot.skip(TType.STRUCT)
3529 
      iprot.readMessageEnd()
3530 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3531 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3532 
      x.write(oprot)
3533 
      oprot.writeMessageEnd()
3534 
      oprot.trans.flush()
3535 
      return
3536 
    else:
3537 
      self._processMap[name](self, seqid, iprot, oprot)
3538 
    return True
3539 
 
559 chandransh 3540 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3541 
    args = createAnonymousUser_args()
94 ashish 3542 
    args.read(iprot)
3543 
    iprot.readMessageEnd()
559 chandransh 3544 
    result = createAnonymousUser_result()
94 ashish 3545 
    try:
559 chandransh 3546 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3547 
    except UserContextException, ucex:
3548 
      result.ucex = ucex
3549 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3550 
    result.write(oprot)
3551 
    oprot.writeMessageEnd()
3552 
    oprot.trans.flush()
3553 
 
559 chandransh 3554 
  def process_getUserById(self, seqid, iprot, oprot):
3555 
    args = getUserById_args()
94 ashish 3556 
    args.read(iprot)
3557 
    iprot.readMessageEnd()
559 chandransh 3558 
    result = getUserById_result()
94 ashish 3559 
    try:
559 chandransh 3560 
      result.success = self._handler.getUserById(args.userId)
3561 
    except UserContextException, ucex:
3562 
      result.ucex = ucex
3563 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3564 
    result.write(oprot)
3565 
    oprot.writeMessageEnd()
3566 
    oprot.trans.flush()
3567 
 
5326 rajveer 3568 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3569 
    args = getUserByCartId_args()
3570 
    args.read(iprot)
3571 
    iprot.readMessageEnd()
3572 
    result = getUserByCartId_result()
3573 
    try:
3574 
      result.success = self._handler.getUserByCartId(args.cartId)
3575 
    except UserContextException, ucex:
3576 
      result.ucex = ucex
3577 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3578 
    result.write(oprot)
3579 
    oprot.writeMessageEnd()
3580 
    oprot.trans.flush()
3581 
 
1491 vikas 3582 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3583 
    args = getUserByEmail_args()
3584 
    args.read(iprot)
3585 
    iprot.readMessageEnd()
3586 
    result = getUserByEmail_result()
3587 
    try:
3588 
      result.success = self._handler.getUserByEmail(args.email)
3589 
    except UserContextException, ucex:
3590 
      result.ucex = ucex
3591 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3592 
    result.write(oprot)
3593 
    oprot.writeMessageEnd()
3594 
    oprot.trans.flush()
3595 
 
3032 mandeep.dh 3596 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3597 
    args = getUserByMobileNumber_args()
3598 
    args.read(iprot)
3599 
    iprot.readMessageEnd()
3600 
    result = getUserByMobileNumber_result()
3601 
    try:
3602 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3603 
    except UserContextException, ucex:
3604 
      result.ucex = ucex
3605 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3606 
    result.write(oprot)
3607 
    oprot.writeMessageEnd()
3608 
    oprot.trans.flush()
3609 
 
559 chandransh 3610 
  def process_createUser(self, seqid, iprot, oprot):
3611 
    args = createUser_args()
94 ashish 3612 
    args.read(iprot)
3613 
    iprot.readMessageEnd()
559 chandransh 3614 
    result = createUser_result()
94 ashish 3615 
    try:
559 chandransh 3616 
      result.success = self._handler.createUser(args.user)
3617 
    except UserContextException, ucex:
3618 
      result.ucex = ucex
3619 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3620 
    result.write(oprot)
3621 
    oprot.writeMessageEnd()
3622 
    oprot.trans.flush()
3623 
 
559 chandransh 3624 
  def process_updateUser(self, seqid, iprot, oprot):
3625 
    args = updateUser_args()
94 ashish 3626 
    args.read(iprot)
3627 
    iprot.readMessageEnd()
559 chandransh 3628 
    result = updateUser_result()
94 ashish 3629 
    try:
559 chandransh 3630 
      result.success = self._handler.updateUser(args.user)
3631 
    except UserContextException, ucex:
3632 
      result.ucex = ucex
3633 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3634 
    result.write(oprot)
3635 
    oprot.writeMessageEnd()
3636 
    oprot.trans.flush()
3637 
 
122 ashish 3638 
  def process_authenticateUser(self, seqid, iprot, oprot):
3639 
    args = authenticateUser_args()
3640 
    args.read(iprot)
3641 
    iprot.readMessageEnd()
3642 
    result = authenticateUser_result()
3643 
    try:
559 chandransh 3644 
      result.success = self._handler.authenticateUser(args.email, args.password)
3645 
    except AuthenticationException, auex:
3646 
      result.auex = auex
122 ashish 3647 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3648 
    result.write(oprot)
3649 
    oprot.writeMessageEnd()
3650 
    oprot.trans.flush()
3651 
 
94 ashish 3652 
  def process_userExists(self, seqid, iprot, oprot):
3653 
    args = userExists_args()
3654 
    args.read(iprot)
3655 
    iprot.readMessageEnd()
3656 
    result = userExists_result()
3657 
    try:
3658 
      result.success = self._handler.userExists(args.email)
3659 
    except UserContextException, ucx:
3660 
      result.ucx = ucx
3661 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3662 
    result.write(oprot)
3663 
    oprot.writeMessageEnd()
3664 
    oprot.trans.flush()
3665 
 
3666 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3667 
    args = addAddressForUser_args()
3668 
    args.read(iprot)
3669 
    iprot.readMessageEnd()
3670 
    result = addAddressForUser_result()
3671 
    try:
567 rajveer 3672 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3673 
    except UserContextException, ucx:
3674 
      result.ucx = ucx
3675 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3676 
    result.write(oprot)
3677 
    oprot.writeMessageEnd()
3678 
    oprot.trans.flush()
3679 
 
3680 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3681 
    args = removeAddressForUser_args()
3682 
    args.read(iprot)
3683 
    iprot.readMessageEnd()
3684 
    result = removeAddressForUser_result()
3685 
    try:
3686 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3687 
    except UserContextException, ucx:
3688 
      result.ucx = ucx
3689 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3690 
    result.write(oprot)
3691 
    oprot.writeMessageEnd()
3692 
    oprot.trans.flush()
3693 
 
3694 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3695 
    args = setUserAsLoggedIn_args()
3696 
    args.read(iprot)
3697 
    iprot.readMessageEnd()
3698 
    result = setUserAsLoggedIn_result()
3699 
    try:
3700 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3701 
    except UserContextException, ucx:
3702 
      result.ucx = ucx
3703 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3704 
    result.write(oprot)
3705 
    oprot.writeMessageEnd()
3706 
    oprot.trans.flush()
3707 
 
3708 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3709 
    args = setUserAsLoggedOut_args()
3710 
    args.read(iprot)
3711 
    iprot.readMessageEnd()
3712 
    result = setUserAsLoggedOut_result()
3713 
    try:
3714 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3715 
    except UserContextException, ucx:
3716 
      result.ucx = ucx
3717 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3718 
    result.write(oprot)
3719 
    oprot.writeMessageEnd()
3720 
    oprot.trans.flush()
3721 
 
504 rajveer 3722 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3723 
    args = setDefaultAddress_args()
3724 
    args.read(iprot)
3725 
    iprot.readMessageEnd()
3726 
    result = setDefaultAddress_result()
3727 
    try:
3728 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3729 
    except UserContextException, ucx:
3730 
      result.ucx = ucx
3731 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3732 
    result.write(oprot)
3733 
    oprot.writeMessageEnd()
3734 
    oprot.trans.flush()
3735 
 
94 ashish 3736 
  def process_updatePassword(self, seqid, iprot, oprot):
3737 
    args = updatePassword_args()
3738 
    args.read(iprot)
3739 
    iprot.readMessageEnd()
3740 
    result = updatePassword_result()
3741 
    try:
594 rajveer 3742 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3743 
    except UserContextException, ucx:
3744 
      result.ucx = ucx
3745 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3746 
    result.write(oprot)
3747 
    oprot.writeMessageEnd()
3748 
    oprot.trans.flush()
3749 
 
581 rajveer 3750 
  def process_forgotPassword(self, seqid, iprot, oprot):
3751 
    args = forgotPassword_args()
3752 
    args.read(iprot)
3753 
    iprot.readMessageEnd()
3754 
    result = forgotPassword_result()
3755 
    try:
884 rajveer 3756 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3757 
    except UserContextException, ucx:
3758 
      result.ucx = ucx
3759 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3760 
    result.write(oprot)
3761 
    oprot.writeMessageEnd()
3762 
    oprot.trans.flush()
3763 
 
594 rajveer 3764 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3765 
    args = getAllAddressesForUser_args()
3766 
    args.read(iprot)
3767 
    iprot.readMessageEnd()
3768 
    result = getAllAddressesForUser_result()
3769 
    try:
3770 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3771 
    except UserContextException, ucx:
3772 
      result.ucx = ucx
3773 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3774 
    result.write(oprot)
3775 
    oprot.writeMessageEnd()
3776 
    oprot.trans.flush()
3777 
 
1894 vikas 3778 
  def process_getAddressById(self, seqid, iprot, oprot):
3779 
    args = getAddressById_args()
3780 
    args.read(iprot)
3781 
    iprot.readMessageEnd()
3782 
    result = getAddressById_result()
3783 
    try:
3784 
      result.success = self._handler.getAddressById(args.addressId)
3785 
    except UserContextException, ucx:
3786 
      result.ucx = ucx
3787 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3788 
    result.write(oprot)
3789 
    oprot.writeMessageEnd()
3790 
    oprot.trans.flush()
3791 
 
594 rajveer 3792 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3793 
    args = getDefaultAddressId_args()
3794 
    args.read(iprot)
3795 
    iprot.readMessageEnd()
3796 
    result = getDefaultAddressId_result()
3797 
    try:
3798 
      result.success = self._handler.getDefaultAddressId(args.userId)
3799 
    except UserContextException, ucx:
3800 
      result.ucx = ucx
3801 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3802 
    result.write(oprot)
3803 
    oprot.writeMessageEnd()
3804 
    oprot.trans.flush()
3805 
 
785 rajveer 3806 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3807 
    args = getDefaultPincode_args()
3808 
    args.read(iprot)
3809 
    iprot.readMessageEnd()
3810 
    result = getDefaultPincode_result()
3811 
    try:
3812 
      result.success = self._handler.getDefaultPincode(args.userId)
3813 
    except UserContextException, ucx:
3814 
      result.ucx = ucx
3815 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3816 
    result.write(oprot)
3817 
    oprot.writeMessageEnd()
3818 
    oprot.trans.flush()
3819 
 
1274 varun.gupt 3820 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3821 
    args = saveUserCommunication_args()
3822 
    args.read(iprot)
3823 
    iprot.readMessageEnd()
3824 
    result = saveUserCommunication_result()
3825 
    try:
3826 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3827 
    except UserCommunicationException, ucx:
3828 
      result.ucx = ucx
3829 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3830 
    result.write(oprot)
3831 
    oprot.writeMessageEnd()
3832 
    oprot.trans.flush()
3833 
 
1590 varun.gupt 3834 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3835 
    args = getUserCommunicationById_args()
3836 
    args.read(iprot)
3837 
    iprot.readMessageEnd()
3838 
    result = getUserCommunicationById_result()
3839 
    try:
3840 
      result.success = self._handler.getUserCommunicationById(args.id)
3841 
    except UserCommunicationException, ucx:
3842 
      result.ucx = ucx
3843 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3844 
    result.write(oprot)
3845 
    oprot.writeMessageEnd()
3846 
    oprot.trans.flush()
3847 
 
3848 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3849 
    args = getUserCommunicationByUser_args()
3850 
    args.read(iprot)
3851 
    iprot.readMessageEnd()
3852 
    result = getUserCommunicationByUser_result()
3853 
    try:
3854 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3855 
    except UserCommunicationException, ucx:
3856 
      result.ucx = ucx
3857 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3858 
    result.write(oprot)
3859 
    oprot.writeMessageEnd()
3860 
    oprot.trans.flush()
3861 
 
3862 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3863 
    args = getAllUserCommunications_args()
3864 
    args.read(iprot)
3865 
    iprot.readMessageEnd()
3866 
    result = getAllUserCommunications_result()
3867 
    try:
3868 
      result.success = self._handler.getAllUserCommunications()
3869 
    except UserCommunicationException, ucx:
3870 
      result.ucx = ucx
3871 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3872 
    result.write(oprot)
3873 
    oprot.writeMessageEnd()
3874 
    oprot.trans.flush()
3875 
 
5407 amar.kumar 3876 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3877 
    args = removeUserCommunication_args()
3878 
    args.read(iprot)
3879 
    iprot.readMessageEnd()
3880 
    result = removeUserCommunication_result()
3881 
    try:
3882 
      self._handler.removeUserCommunication(args.id)
3883 
    except UserCommunicationException, ucx:
3884 
      result.ucx = ucx
3885 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3886 
    result.write(oprot)
3887 
    oprot.writeMessageEnd()
3888 
    oprot.trans.flush()
3889 
 
1845 vikas 3890 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3891 
    args = createMasterAffiliate_args()
3892 
    args.read(iprot)
3893 
    iprot.readMessageEnd()
3894 
    result = createMasterAffiliate_result()
3895 
    try:
1859 vikas 3896 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3897 
    except UserAffiliateException, utx:
1845 vikas 3898 
      result.utx = utx
3899 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3900 
    result.write(oprot)
3901 
    oprot.writeMessageEnd()
3902 
    oprot.trans.flush()
3903 
 
1899 vikas 3904 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3905 
    args = getAllMasterAffiliates_args()
3906 
    args.read(iprot)
3907 
    iprot.readMessageEnd()
3908 
    result = getAllMasterAffiliates_result()
3909 
    try:
3910 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3911 
    except UserAffiliateException, utx:
1899 vikas 3912 
      result.utx = utx
3913 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3914 
    result.write(oprot)
3915 
    oprot.writeMessageEnd()
3916 
    oprot.trans.flush()
3917 
 
1845 vikas 3918 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3919 
    args = getMasterAffiliateById_args()
3920 
    args.read(iprot)
3921 
    iprot.readMessageEnd()
3922 
    result = getMasterAffiliateById_result()
3923 
    try:
3924 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3925 
    except UserAffiliateException, utx:
1845 vikas 3926 
      result.utx = utx
3927 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3928 
    result.write(oprot)
3929 
    oprot.writeMessageEnd()
3930 
    oprot.trans.flush()
3931 
 
3932 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3933 
    args = getMasterAffiliateByName_args()
3934 
    args.read(iprot)
3935 
    iprot.readMessageEnd()
3936 
    result = getMasterAffiliateByName_result()
3937 
    try:
3938 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3939 
    except UserAffiliateException, utx:
1845 vikas 3940 
      result.utx = utx
3941 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3942 
    result.write(oprot)
3943 
    oprot.writeMessageEnd()
3944 
    oprot.trans.flush()
3945 
 
3946 
  def process_createAffiliate(self, seqid, iprot, oprot):
3947 
    args = createAffiliate_args()
3948 
    args.read(iprot)
3949 
    iprot.readMessageEnd()
3950 
    result = createAffiliate_result()
3951 
    try:
1859 vikas 3952 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3953 
    except UserAffiliateException, utx:
1845 vikas 3954 
      result.utx = utx
3955 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3956 
    result.write(oprot)
3957 
    oprot.writeMessageEnd()
3958 
    oprot.trans.flush()
3959 
 
3960 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3961 
    args = getAffiliateById_args()
3962 
    args.read(iprot)
3963 
    iprot.readMessageEnd()
3964 
    result = getAffiliateById_result()
3965 
    try:
3966 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3967 
    except UserAffiliateException, utx:
1845 vikas 3968 
      result.utx = utx
3969 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3970 
    result.write(oprot)
3971 
    oprot.writeMessageEnd()
3972 
    oprot.trans.flush()
3973 
 
3974 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3975 
    args = getAffiliateByName_args()
3976 
    args.read(iprot)
3977 
    iprot.readMessageEnd()
3978 
    result = getAffiliateByName_result()
3979 
    try:
3980 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3981 
    except UserAffiliateException, utx:
1845 vikas 3982 
      result.utx = utx
3983 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3984 
    result.write(oprot)
3985 
    oprot.writeMessageEnd()
3986 
    oprot.trans.flush()
3987 
 
3988 
  def process_getTrackerById(self, seqid, iprot, oprot):
3989 
    args = getTrackerById_args()
3990 
    args.read(iprot)
3991 
    iprot.readMessageEnd()
3992 
    result = getTrackerById_result()
3993 
    try:
1996 vikas 3994 
      result.success = self._handler.getTrackerById(args.id)
3995 
    except UserAffiliateException, utx:
1845 vikas 3996 
      result.utx = utx
3997 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3998 
    result.write(oprot)
3999 
    oprot.writeMessageEnd()
4000 
    oprot.trans.flush()
4001 
 
1996 vikas 4002 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4003 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4004 
    args.read(iprot)
4005 
    iprot.readMessageEnd()
1996 vikas 4006 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4007 
    try:
1996 vikas 4008 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4009 
    except UserAffiliateException, utx:
1845 vikas 4010 
      result.utx = utx
1996 vikas 4011 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4012 
    result.write(oprot)
4013 
    oprot.writeMessageEnd()
4014 
    oprot.trans.flush()
4015 
 
4016 
  def process_addTrackLog(self, seqid, iprot, oprot):
4017 
    args = addTrackLog_args()
4018 
    args.read(iprot)
4019 
    iprot.readMessageEnd()
4020 
    result = addTrackLog_result()
4021 
    try:
1996 vikas 4022 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4023 
    except UserAffiliateException, utx:
1845 vikas 4024 
      result.utx = utx
4025 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4026 
    result.write(oprot)
4027 
    oprot.writeMessageEnd()
4028 
    oprot.trans.flush()
4029 
 
4030 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4031 
    args = getTrackLogById_args()
4032 
    args.read(iprot)
4033 
    iprot.readMessageEnd()
4034 
    result = getTrackLogById_result()
4035 
    try:
4036 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4037 
    except UserAffiliateException, utx:
1845 vikas 4038 
      result.utx = utx
4039 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4040 
    result.write(oprot)
4041 
    oprot.writeMessageEnd()
4042 
    oprot.trans.flush()
4043 
 
1996 vikas 4044 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4045 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4046 
    args.read(iprot)
4047 
    iprot.readMessageEnd()
1996 vikas 4048 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4049 
    try:
3293 vikas 4050 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4051 
    except UserAffiliateException, utx:
1845 vikas 4052 
      result.utx = utx
1996 vikas 4053 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4054 
    result.write(oprot)
4055 
    oprot.writeMessageEnd()
4056 
    oprot.trans.flush()
4057 
 
4058 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4059 
    args = getTrackLogsByUser_args()
4060 
    args.read(iprot)
4061 
    iprot.readMessageEnd()
4062 
    result = getTrackLogsByUser_result()
4063 
    try:
4064 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4065 
    except UserAffiliateException, utx:
1845 vikas 4066 
      result.utx = utx
4067 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4068 
    result.write(oprot)
4069 
    oprot.writeMessageEnd()
4070 
    oprot.trans.flush()
4071 
 
4072 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4073 
    args = getTrackLogs_args()
4074 
    args.read(iprot)
4075 
    iprot.readMessageEnd()
4076 
    result = getTrackLogs_result()
4077 
    try:
1996 vikas 4078 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4079 
    except UserAffiliateException, utx:
1845 vikas 4080 
      result.utx = utx
4081 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4082 
    result.write(oprot)
4083 
    oprot.writeMessageEnd()
4084 
    oprot.trans.flush()
4085 
 
559 chandransh 4086 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4087 
    args = getCurrentCart_args()
94 ashish 4088 
    args.read(iprot)
4089 
    iprot.readMessageEnd()
559 chandransh 4090 
    result = getCurrentCart_result()
94 ashish 4091 
    try:
559 chandransh 4092 
      result.success = self._handler.getCurrentCart(args.userId)
4093 
    except ShoppingCartException, scx:
4094 
      result.scx = scx
4095 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4096 
    result.write(oprot)
4097 
    oprot.writeMessageEnd()
4098 
    oprot.trans.flush()
4099 
 
559 chandransh 4100 
  def process_getCart(self, seqid, iprot, oprot):
4101 
    args = getCart_args()
94 ashish 4102 
    args.read(iprot)
4103 
    iprot.readMessageEnd()
559 chandransh 4104 
    result = getCart_result()
94 ashish 4105 
    try:
559 chandransh 4106 
      result.success = self._handler.getCart(args.cartId)
4107 
    except ShoppingCartException, scx:
4108 
      result.scx = scx
4109 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4110 
    result.write(oprot)
4111 
    oprot.writeMessageEnd()
4112 
    oprot.trans.flush()
4113 
 
559 chandransh 4114 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4115 
    args = getCartsByTime_args()
94 ashish 4116 
    args.read(iprot)
4117 
    iprot.readMessageEnd()
559 chandransh 4118 
    result = getCartsByTime_result()
94 ashish 4119 
    try:
559 chandransh 4120 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4121 
    except ShoppingCartException, scx:
4122 
      result.scx = scx
4123 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4124 
    result.write(oprot)
4125 
    oprot.writeMessageEnd()
4126 
    oprot.trans.flush()
4127 
 
559 chandransh 4128 
  def process_addItemToCart(self, seqid, iprot, oprot):
4129 
    args = addItemToCart_args()
130 ashish 4130 
    args.read(iprot)
4131 
    iprot.readMessageEnd()
559 chandransh 4132 
    result = addItemToCart_result()
130 ashish 4133 
    try:
3557 rajveer 4134 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4135 
    except ShoppingCartException, scx:
4136 
      result.scx = scx
4137 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4138 
    result.write(oprot)
4139 
    oprot.writeMessageEnd()
4140 
    oprot.trans.flush()
4141 
 
559 chandransh 4142 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4143 
    args = deleteItemFromCart_args()
4144 
    args.read(iprot)
4145 
    iprot.readMessageEnd()
4146 
    result = deleteItemFromCart_result()
4147 
    try:
4148 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4149 
    except ShoppingCartException, scx:
4150 
      result.scx = scx
4151 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4152 
    result.write(oprot)
4153 
    oprot.writeMessageEnd()
4154 
    oprot.trans.flush()
130 ashish 4155 
 
559 chandransh 4156 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4157 
    args = addAddressToCart_args()
4158 
    args.read(iprot)
4159 
    iprot.readMessageEnd()
4160 
    result = addAddressToCart_result()
575 chandransh 4161 
    try:
4162 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4163 
    except ShoppingCartException, scx:
4164 
      result.scx = scx
559 chandransh 4165 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4166 
    result.write(oprot)
4167 
    oprot.writeMessageEnd()
4168 
    oprot.trans.flush()
4169 
 
5553 rajveer 4170 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4171 
    args = addStoreToCart_args()
4172 
    args.read(iprot)
4173 
    iprot.readMessageEnd()
4174 
    result = addStoreToCart_result()
4175 
    try:
4176 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4177 
    except ShoppingCartException, scx:
4178 
      result.scx = scx
4179 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4180 
    result.write(oprot)
4181 
    oprot.writeMessageEnd()
4182 
    oprot.trans.flush()
4183 
 
1976 varun.gupt 4184 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4185 
    args = applyCouponToCart_args()
4186 
    args.read(iprot)
4187 
    iprot.readMessageEnd()
4188 
    result = applyCouponToCart_result()
4189 
    try:
6922 anupam.sin 4190 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4191 
    except ShoppingCartException, scx:
4192 
      result.scx = scx
4193 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4194 
    result.write(oprot)
4195 
    oprot.writeMessageEnd()
4196 
    oprot.trans.flush()
4197 
 
4198 
  def process_removeCoupon(self, seqid, iprot, oprot):
4199 
    args = removeCoupon_args()
4200 
    args.read(iprot)
4201 
    iprot.readMessageEnd()
4202 
    result = removeCoupon_result()
4203 
    try:
4204 
      self._handler.removeCoupon(args.cartId)
4205 
    except ShoppingCartException, scx:
4206 
      result.scx = scx
4207 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
4211 
 
3554 varun.gupt 4212 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4213 
    args = deleteDiscountsFromCart_args()
4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
4216 
    result = deleteDiscountsFromCart_result()
4217 
    try:
4218 
      self._handler.deleteDiscountsFromCart(args.cartId)
4219 
    except ShoppingCartException, scx:
4220 
      result.scx = scx
4221 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4222 
    result.write(oprot)
4223 
    oprot.writeMessageEnd()
4224 
    oprot.trans.flush()
4225 
 
4226 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4227 
    args = saveDiscounts_args()
4228 
    args.read(iprot)
4229 
    iprot.readMessageEnd()
4230 
    result = saveDiscounts_result()
4231 
    try:
4232 
      self._handler.saveDiscounts(args.discounts)
4233 
    except ShoppingCartException, scx:
4234 
      result.scx = scx
4235 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4236 
    result.write(oprot)
4237 
    oprot.writeMessageEnd()
4238 
    oprot.trans.flush()
4239 
 
690 chandransh 4240 
  def process_createOrders(self, seqid, iprot, oprot):
4241 
    args = createOrders_args()
559 chandransh 4242 
    args.read(iprot)
4243 
    iprot.readMessageEnd()
690 chandransh 4244 
    result = createOrders_result()
559 chandransh 4245 
    try:
11526 amit.gupta 4246 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4247 
    except ShoppingCartException, scx:
4248 
      result.scx = scx
690 chandransh 4249 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4250 
    result.write(oprot)
4251 
    oprot.writeMessageEnd()
4252 
    oprot.trans.flush()
4253 
 
4254 
  def process_validateCart(self, seqid, iprot, oprot):
4255 
    args = validateCart_args()
4256 
    args.read(iprot)
4257 
    iprot.readMessageEnd()
4258 
    result = validateCart_result()
575 chandransh 4259 
    try:
3557 rajveer 4260 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4261 
    except ShoppingCartException, scex:
4262 
      result.scex = scex
559 chandransh 4263 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4264 
    result.write(oprot)
4265 
    oprot.writeMessageEnd()
4266 
    oprot.trans.flush()
4267 
 
11980 amit.gupta 4268 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4269 
    args = validateCartWithDealerCoupon_args()
4270 
    args.read(iprot)
4271 
    iprot.readMessageEnd()
4272 
    result = validateCartWithDealerCoupon_result()
4273 
    try:
4274 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4275 
    except ShoppingCartException, scex:
4276 
      result.scex = scex
4277 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4278 
    result.write(oprot)
4279 
    oprot.writeMessageEnd()
4280 
    oprot.trans.flush()
4281 
 
690 chandransh 4282 
  def process_mergeCart(self, seqid, iprot, oprot):
4283 
    args = mergeCart_args()
575 chandransh 4284 
    args.read(iprot)
4285 
    iprot.readMessageEnd()
690 chandransh 4286 
    result = mergeCart_result()
4287 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4288 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4289 
    result.write(oprot)
4290 
    oprot.writeMessageEnd()
4291 
    oprot.trans.flush()
4292 
 
4293 
  def process_checkOut(self, seqid, iprot, oprot):
4294 
    args = checkOut_args()
4295 
    args.read(iprot)
4296 
    iprot.readMessageEnd()
4297 
    result = checkOut_result()
575 chandransh 4298 
    try:
690 chandransh 4299 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4300 
    except ShoppingCartException, scex:
4301 
      result.scex = scex
690 chandransh 4302 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4303 
    result.write(oprot)
4304 
    oprot.writeMessageEnd()
4305 
    oprot.trans.flush()
4306 
 
690 chandransh 4307 
  def process_resetCart(self, seqid, iprot, oprot):
4308 
    args = resetCart_args()
559 chandransh 4309 
    args.read(iprot)
4310 
    iprot.readMessageEnd()
690 chandransh 4311 
    result = resetCart_result()
4312 
    try:
4313 
      result.success = self._handler.resetCart(args.cartId, args.items)
4314 
    except ShoppingCartException, scex:
4315 
      result.scex = scex
4316 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4317 
    result.write(oprot)
4318 
    oprot.writeMessageEnd()
4319 
    oprot.trans.flush()
4320 
 
2981 rajveer 4321 
  def process_getUserCount(self, seqid, iprot, oprot):
4322 
    args = getUserCount_args()
559 chandransh 4323 
    args.read(iprot)
4324 
    iprot.readMessageEnd()
2981 rajveer 4325 
    result = getUserCount_result()
4326 
    result.success = self._handler.getUserCount(args.userType)
4327 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4328 
    result.write(oprot)
4329 
    oprot.writeMessageEnd()
4330 
    oprot.trans.flush()
4331 
 
2981 rajveer 4332 
  def process_getAllUsers(self, seqid, iprot, oprot):
4333 
    args = getAllUsers_args()
559 chandransh 4334 
    args.read(iprot)
4335 
    iprot.readMessageEnd()
2981 rajveer 4336 
    result = getAllUsers_result()
4337 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4338 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4342 
 
2981 rajveer 4343 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4344 
    args = getMyResearchItems_args()
559 chandransh 4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
2981 rajveer 4347 
    result = getMyResearchItems_result()
559 chandransh 4348 
    try:
2981 rajveer 4349 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4350 
    except WidgetException, scx:
4351 
      result.scx = scx
2981 rajveer 4352 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
4356 
 
2981 rajveer 4357 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4358 
    args = updateMyResearch_args()
772 rajveer 4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
2981 rajveer 4361 
    result = updateMyResearch_result()
4362 
    try:
4363 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4364 
    except WidgetException, scx:
4365 
      result.scx = scx
4366 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
559 chandransh 4370 
 
2981 rajveer 4371 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4372 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
2981 rajveer 4375 
    result = deleteItemFromMyResearch_result()
4376 
    try:
4377 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4378 
    except WidgetException, scx:
4379 
      result.scx = scx
4380 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
772 rajveer 4384 
 
2981 rajveer 4385 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4386 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
2981 rajveer 4389 
    result = getBrowseHistoryItems_result()
4390 
    try:
4391 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4392 
    except WidgetException, scx:
4393 
      result.scx = scx
4394 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
1596 ankur.sing 4398 
 
2981 rajveer 4399 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4400 
    args = updateBrowseHistory_args()
2642 varun.gupt 4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
2981 rajveer 4403 
    result = updateBrowseHistory_result()
4404 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4405 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4406 
    result.write(oprot)
4407 
    oprot.writeMessageEnd()
4408 
    oprot.trans.flush()
1673 ankur.sing 4409 
 
3385 varun.gupt 4410 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4411 
    args = getCartsWithCouponCount_args()
4412 
    args.read(iprot)
4413 
    iprot.readMessageEnd()
4414 
    result = getCartsWithCouponCount_result()
4415 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4416 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
2642 varun.gupt 4420 
 
3499 mandeep.dh 4421 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4422 
    args = increaseTrustLevel_args()
4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
4425 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4426 
    return
3385 varun.gupt 4427 
 
5407 amar.kumar 4428 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4429 
    args = getTrustLevel_args()
4430 
    args.read(iprot)
4431 
    iprot.readMessageEnd()
4432 
    result = getTrustLevel_result()
4433 
    result.success = self._handler.getTrustLevel(args.userId)
4434 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4435 
    result.write(oprot)
4436 
    oprot.writeMessageEnd()
4437 
    oprot.trans.flush()
4438 
 
4668 varun.gupt 4439 
  def process_showCODOption(self, seqid, iprot, oprot):
4440 
    args = showCODOption_args()
4441 
    args.read(iprot)
4442 
    iprot.readMessageEnd()
4443 
    result = showCODOption_result()
4444 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4445 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4446 
    result.write(oprot)
4447 
    oprot.writeMessageEnd()
4448 
    oprot.trans.flush()
3499 mandeep.dh 4449 
 
5623 anupam.sin 4450 
  def process_getUserEmails(self, seqid, iprot, oprot):
4451 
    args = getUserEmails_args()
4452 
    args.read(iprot)
4453 
    iprot.readMessageEnd()
4454 
    result = getUserEmails_result()
4455 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4456 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4668 varun.gupt 4460 
 
6903 anupam.sin 4461 
  def process_insureItem(self, seqid, iprot, oprot):
4462 
    args = insureItem_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = insureItem_result()
9299 kshitij.so 4466 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4467 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4468 
    result.write(oprot)
4469 
    oprot.writeMessageEnd()
4470 
    oprot.trans.flush()
4471 
 
4472 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4473 
    args = cancelInsurance_args()
4474 
    args.read(iprot)
4475 
    iprot.readMessageEnd()
4476 
    result = cancelInsurance_result()
4477 
    result.success = self._handler.cancelInsurance(args.cartId)
4478 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4479 
    result.write(oprot)
4480 
    oprot.writeMessageEnd()
4481 
    oprot.trans.flush()
4482 
 
4483 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4484 
    args = storeInsuranceSpecificDetails_args()
4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
4487 
    result = storeInsuranceSpecificDetails_result()
4488 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4489 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4490 
    result.write(oprot)
4491 
    oprot.writeMessageEnd()
4492 
    oprot.trans.flush()
4493 
 
4494 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4495 
    args = isInsuranceDetailPresent_args()
4496 
    args.read(iprot)
4497 
    iprot.readMessageEnd()
4498 
    result = isInsuranceDetailPresent_result()
4499 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4500 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
9791 rajveer 4505 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4506 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
9791 rajveer 4509 
    result = getProductsAddedToCart_result()
4510 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4511 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4512 
    result.write(oprot)
4513 
    oprot.writeMessageEnd()
4514 
    oprot.trans.flush()
5623 anupam.sin 4515 
 
11592 amit.gupta 4516 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4517 
    args = validateCartPlus_args()
4518 
    args.read(iprot)
4519 
    iprot.readMessageEnd()
4520 
    result = validateCartPlus_result()
4521 
    try:
11980 amit.gupta 4522 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4523 
    except ShoppingCartException, scex:
4524 
      result.scex = scex
4525 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4526 
    result.write(oprot)
4527 
    oprot.writeMessageEnd()
4528 
    oprot.trans.flush()
6821 amar.kumar 4529 
 
11679 vikram.rag 4530 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4531 
    args = isPrivateDealUser_args()
4532 
    args.read(iprot)
4533 
    iprot.readMessageEnd()
4534 
    result = isPrivateDealUser_result()
4535 
    result.success = self._handler.isPrivateDealUser(args.userId)
4536 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
11592 amit.gupta 4540 
 
11890 kshitij.so 4541 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4542 
    args = addPrivateDealUser_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = addPrivateDealUser_result()
4546 
    result.success = self._handler.addPrivateDealUser(args.userId)
4547 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
11679 vikram.rag 4551 
 
11890 kshitij.so 4552 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4553 
    args = changePrivateDealUserStatus_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = changePrivateDealUserStatus_result()
4557 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4558 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4559 
    result.write(oprot)
4560 
    oprot.writeMessageEnd()
4561 
    oprot.trans.flush()
4562 
 
4563 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4564 
    args = getPrivateDealUser_args()
4565 
    args.read(iprot)
4566 
    iprot.readMessageEnd()
4567 
    result = getPrivateDealUser_result()
4568 
    result.success = self._handler.getPrivateDealUser(args.userId)
4569 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4570 
    result.write(oprot)
4571 
    oprot.writeMessageEnd()
4572 
    oprot.trans.flush()
4573 
 
12696 amit.gupta 4574 
  def process_registerCounter(self, seqid, iprot, oprot):
4575 
    args = registerCounter_args()
4576 
    args.read(iprot)
4577 
    iprot.readMessageEnd()
4578 
    result = registerCounter_result()
4579 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4580 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
11890 kshitij.so 4584 
 
12722 amit.gupta 4585 
  def process_searchCounter(self, seqid, iprot, oprot):
4586 
    args = searchCounter_args()
4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
4589 
    result = searchCounter_result()
4590 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4591 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4592 
    result.write(oprot)
4593 
    oprot.writeMessageEnd()
4594 
    oprot.trans.flush()
12696 amit.gupta 4595 
 
12722 amit.gupta 4596 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4597 
    args = getAllUsersByCounter_args()
4598 
    args.read(iprot)
4599 
    iprot.readMessageEnd()
4600 
    result = getAllUsersByCounter_result()
4601 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4602 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4603 
    result.write(oprot)
4604 
    oprot.writeMessageEnd()
4605 
    oprot.trans.flush()
4606 
 
4607 
 
94 ashish 4608 
# HELPER FUNCTIONS AND STRUCTURES
4609 
 
559 chandransh 4610 
class createAnonymousUser_args:
94 ashish 4611 
  """
4612 
  Attributes:
559 chandransh 4613 
   - jsessionId
94 ashish 4614 
  """
4615 
 
4616 
  thrift_spec = (
4617 
    None, # 0
559 chandransh 4618 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4619 
  )
4620 
 
559 chandransh 4621 
  def __init__(self, jsessionId=None,):
4622 
    self.jsessionId = jsessionId
94 ashish 4623 
 
4624 
  def read(self, iprot):
4625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4627 
      return
4628 
    iprot.readStructBegin()
4629 
    while True:
4630 
      (fname, ftype, fid) = iprot.readFieldBegin()
4631 
      if ftype == TType.STOP:
4632 
        break
4633 
      if fid == 1:
559 chandransh 4634 
        if ftype == TType.STRING:
4635 
          self.jsessionId = iprot.readString();
94 ashish 4636 
        else:
4637 
          iprot.skip(ftype)
4638 
      else:
4639 
        iprot.skip(ftype)
4640 
      iprot.readFieldEnd()
4641 
    iprot.readStructEnd()
4642 
 
4643 
  def write(self, oprot):
4644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4646 
      return
559 chandransh 4647 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4648 
    if self.jsessionId is not None:
559 chandransh 4649 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4650 
      oprot.writeString(self.jsessionId)
94 ashish 4651 
      oprot.writeFieldEnd()
4652 
    oprot.writeFieldStop()
4653 
    oprot.writeStructEnd()
4654 
 
3431 rajveer 4655 
  def validate(self):
4656 
    return
4657 
 
4658 
 
94 ashish 4659 
  def __repr__(self):
4660 
    L = ['%s=%r' % (key, value)
4661 
      for key, value in self.__dict__.iteritems()]
4662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4663 
 
4664 
  def __eq__(self, other):
4665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4666 
 
4667 
  def __ne__(self, other):
4668 
    return not (self == other)
4669 
 
559 chandransh 4670 
class createAnonymousUser_result:
94 ashish 4671 
  """
4672 
  Attributes:
4673 
   - success
559 chandransh 4674 
   - ucex
94 ashish 4675 
  """
4676 
 
4677 
  thrift_spec = (
559 chandransh 4678 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4679 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4680 
  )
4681 
 
559 chandransh 4682 
  def __init__(self, success=None, ucex=None,):
94 ashish 4683 
    self.success = success
559 chandransh 4684 
    self.ucex = ucex
94 ashish 4685 
 
4686 
  def read(self, iprot):
4687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4689 
      return
4690 
    iprot.readStructBegin()
4691 
    while True:
4692 
      (fname, ftype, fid) = iprot.readFieldBegin()
4693 
      if ftype == TType.STOP:
4694 
        break
4695 
      if fid == 0:
4696 
        if ftype == TType.STRUCT:
559 chandransh 4697 
          self.success = User()
94 ashish 4698 
          self.success.read(iprot)
4699 
        else:
4700 
          iprot.skip(ftype)
4701 
      elif fid == 1:
4702 
        if ftype == TType.STRUCT:
559 chandransh 4703 
          self.ucex = UserContextException()
4704 
          self.ucex.read(iprot)
94 ashish 4705 
        else:
4706 
          iprot.skip(ftype)
4707 
      else:
4708 
        iprot.skip(ftype)
4709 
      iprot.readFieldEnd()
4710 
    iprot.readStructEnd()
4711 
 
4712 
  def write(self, oprot):
4713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4715 
      return
559 chandransh 4716 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4717 
    if self.success is not None:
94 ashish 4718 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4719 
      self.success.write(oprot)
4720 
      oprot.writeFieldEnd()
3431 rajveer 4721 
    if self.ucex is not None:
559 chandransh 4722 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4723 
      self.ucex.write(oprot)
94 ashish 4724 
      oprot.writeFieldEnd()
4725 
    oprot.writeFieldStop()
4726 
    oprot.writeStructEnd()
4727 
 
3431 rajveer 4728 
  def validate(self):
4729 
    return
4730 
 
4731 
 
94 ashish 4732 
  def __repr__(self):
4733 
    L = ['%s=%r' % (key, value)
4734 
      for key, value in self.__dict__.iteritems()]
4735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4736 
 
4737 
  def __eq__(self, other):
4738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4739 
 
4740 
  def __ne__(self, other):
4741 
    return not (self == other)
4742 
 
559 chandransh 4743 
class getUserById_args:
94 ashish 4744 
  """
4745 
  Attributes:
4746 
   - userId
4747 
  """
4748 
 
4749 
  thrift_spec = (
4750 
    None, # 0
4751 
    (1, TType.I64, 'userId', None, None, ), # 1
4752 
  )
4753 
 
559 chandransh 4754 
  def __init__(self, userId=None,):
94 ashish 4755 
    self.userId = userId
4756 
 
4757 
  def read(self, iprot):
4758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4760 
      return
4761 
    iprot.readStructBegin()
4762 
    while True:
4763 
      (fname, ftype, fid) = iprot.readFieldBegin()
4764 
      if ftype == TType.STOP:
4765 
        break
4766 
      if fid == 1:
4767 
        if ftype == TType.I64:
4768 
          self.userId = iprot.readI64();
4769 
        else:
4770 
          iprot.skip(ftype)
4771 
      else:
4772 
        iprot.skip(ftype)
4773 
      iprot.readFieldEnd()
4774 
    iprot.readStructEnd()
4775 
 
4776 
  def write(self, oprot):
4777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4779 
      return
559 chandransh 4780 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4781 
    if self.userId is not None:
94 ashish 4782 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4783 
      oprot.writeI64(self.userId)
4784 
      oprot.writeFieldEnd()
4785 
    oprot.writeFieldStop()
4786 
    oprot.writeStructEnd()
4787 
 
3431 rajveer 4788 
  def validate(self):
4789 
    return
4790 
 
4791 
 
94 ashish 4792 
  def __repr__(self):
4793 
    L = ['%s=%r' % (key, value)
4794 
      for key, value in self.__dict__.iteritems()]
4795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4796 
 
4797 
  def __eq__(self, other):
4798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4799 
 
4800 
  def __ne__(self, other):
4801 
    return not (self == other)
4802 
 
559 chandransh 4803 
class getUserById_result:
94 ashish 4804 
  """
4805 
  Attributes:
4806 
   - success
559 chandransh 4807 
   - ucex
94 ashish 4808 
  """
4809 
 
4810 
  thrift_spec = (
559 chandransh 4811 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4812 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4813 
  )
4814 
 
559 chandransh 4815 
  def __init__(self, success=None, ucex=None,):
94 ashish 4816 
    self.success = success
559 chandransh 4817 
    self.ucex = ucex
94 ashish 4818 
 
4819 
  def read(self, iprot):
4820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4822 
      return
4823 
    iprot.readStructBegin()
4824 
    while True:
4825 
      (fname, ftype, fid) = iprot.readFieldBegin()
4826 
      if ftype == TType.STOP:
4827 
        break
4828 
      if fid == 0:
4829 
        if ftype == TType.STRUCT:
559 chandransh 4830 
          self.success = User()
94 ashish 4831 
          self.success.read(iprot)
4832 
        else:
4833 
          iprot.skip(ftype)
4834 
      elif fid == 1:
4835 
        if ftype == TType.STRUCT:
559 chandransh 4836 
          self.ucex = UserContextException()
4837 
          self.ucex.read(iprot)
94 ashish 4838 
        else:
4839 
          iprot.skip(ftype)
4840 
      else:
4841 
        iprot.skip(ftype)
4842 
      iprot.readFieldEnd()
4843 
    iprot.readStructEnd()
4844 
 
4845 
  def write(self, oprot):
4846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4848 
      return
559 chandransh 4849 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4850 
    if self.success is not None:
94 ashish 4851 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4852 
      self.success.write(oprot)
4853 
      oprot.writeFieldEnd()
3431 rajveer 4854 
    if self.ucex is not None:
559 chandransh 4855 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4856 
      self.ucex.write(oprot)
94 ashish 4857 
      oprot.writeFieldEnd()
4858 
    oprot.writeFieldStop()
4859 
    oprot.writeStructEnd()
4860 
 
3431 rajveer 4861 
  def validate(self):
4862 
    return
4863 
 
4864 
 
94 ashish 4865 
  def __repr__(self):
4866 
    L = ['%s=%r' % (key, value)
4867 
      for key, value in self.__dict__.iteritems()]
4868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4869 
 
4870 
  def __eq__(self, other):
4871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4872 
 
4873 
  def __ne__(self, other):
4874 
    return not (self == other)
4875 
 
5326 rajveer 4876 
class getUserByCartId_args:
1491 vikas 4877 
  """
4878 
  Attributes:
5326 rajveer 4879 
   - cartId
1491 vikas 4880 
  """
4881 
 
4882 
  thrift_spec = (
4883 
    None, # 0
5326 rajveer 4884 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4885 
  )
4886 
 
5326 rajveer 4887 
  def __init__(self, cartId=None,):
4888 
    self.cartId = cartId
1491 vikas 4889 
 
4890 
  def read(self, iprot):
4891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4893 
      return
4894 
    iprot.readStructBegin()
4895 
    while True:
4896 
      (fname, ftype, fid) = iprot.readFieldBegin()
4897 
      if ftype == TType.STOP:
4898 
        break
4899 
      if fid == 1:
5326 rajveer 4900 
        if ftype == TType.I64:
4901 
          self.cartId = iprot.readI64();
1491 vikas 4902 
        else:
4903 
          iprot.skip(ftype)
4904 
      else:
4905 
        iprot.skip(ftype)
4906 
      iprot.readFieldEnd()
4907 
    iprot.readStructEnd()
4908 
 
4909 
  def write(self, oprot):
4910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4912 
      return
5326 rajveer 4913 
    oprot.writeStructBegin('getUserByCartId_args')
4914 
    if self.cartId is not None:
4915 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4916 
      oprot.writeI64(self.cartId)
1491 vikas 4917 
      oprot.writeFieldEnd()
4918 
    oprot.writeFieldStop()
4919 
    oprot.writeStructEnd()
4920 
 
3431 rajveer 4921 
  def validate(self):
4922 
    return
4923 
 
4924 
 
1491 vikas 4925 
  def __repr__(self):
4926 
    L = ['%s=%r' % (key, value)
4927 
      for key, value in self.__dict__.iteritems()]
4928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4929 
 
4930 
  def __eq__(self, other):
4931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4932 
 
4933 
  def __ne__(self, other):
4934 
    return not (self == other)
4935 
 
5326 rajveer 4936 
class getUserByCartId_result:
1491 vikas 4937 
  """
4938 
  Attributes:
4939 
   - success
4940 
   - ucex
4941 
  """
4942 
 
4943 
  thrift_spec = (
4944 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4945 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4946 
  )
4947 
 
4948 
  def __init__(self, success=None, ucex=None,):
4949 
    self.success = success
4950 
    self.ucex = ucex
4951 
 
4952 
  def read(self, iprot):
4953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4955 
      return
4956 
    iprot.readStructBegin()
4957 
    while True:
4958 
      (fname, ftype, fid) = iprot.readFieldBegin()
4959 
      if ftype == TType.STOP:
4960 
        break
4961 
      if fid == 0:
4962 
        if ftype == TType.STRUCT:
4963 
          self.success = User()
4964 
          self.success.read(iprot)
4965 
        else:
4966 
          iprot.skip(ftype)
4967 
      elif fid == 1:
4968 
        if ftype == TType.STRUCT:
4969 
          self.ucex = UserContextException()
4970 
          self.ucex.read(iprot)
4971 
        else:
4972 
          iprot.skip(ftype)
4973 
      else:
4974 
        iprot.skip(ftype)
4975 
      iprot.readFieldEnd()
4976 
    iprot.readStructEnd()
4977 
 
4978 
  def write(self, oprot):
4979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4981 
      return
5326 rajveer 4982 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 4983 
    if self.success is not None:
1491 vikas 4984 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4985 
      self.success.write(oprot)
4986 
      oprot.writeFieldEnd()
3431 rajveer 4987 
    if self.ucex is not None:
1491 vikas 4988 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4989 
      self.ucex.write(oprot)
4990 
      oprot.writeFieldEnd()
4991 
    oprot.writeFieldStop()
4992 
    oprot.writeStructEnd()
4993 
 
3431 rajveer 4994 
  def validate(self):
4995 
    return
4996 
 
4997 
 
1491 vikas 4998 
  def __repr__(self):
4999 
    L = ['%s=%r' % (key, value)
5000 
      for key, value in self.__dict__.iteritems()]
5001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5002 
 
5003 
  def __eq__(self, other):
5004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5005 
 
5006 
  def __ne__(self, other):
5007 
    return not (self == other)
5008 
 
5326 rajveer 5009 
class getUserByEmail_args:
3032 mandeep.dh 5010 
  """
5011 
  Attributes:
5326 rajveer 5012 
   - email
3032 mandeep.dh 5013 
  """
5014 
 
5015 
  thrift_spec = (
5016 
    None, # 0
5326 rajveer 5017 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5018 
  )
5019 
 
5326 rajveer 5020 
  def __init__(self, email=None,):
5021 
    self.email = email
3032 mandeep.dh 5022 
 
5023 
  def read(self, iprot):
5024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5026 
      return
5027 
    iprot.readStructBegin()
5028 
    while True:
5029 
      (fname, ftype, fid) = iprot.readFieldBegin()
5030 
      if ftype == TType.STOP:
5031 
        break
5032 
      if fid == 1:
5326 rajveer 5033 
        if ftype == TType.STRING:
5034 
          self.email = iprot.readString();
3032 mandeep.dh 5035 
        else:
5036 
          iprot.skip(ftype)
5037 
      else:
5038 
        iprot.skip(ftype)
5039 
      iprot.readFieldEnd()
5040 
    iprot.readStructEnd()
5041 
 
5042 
  def write(self, oprot):
5043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5045 
      return
5326 rajveer 5046 
    oprot.writeStructBegin('getUserByEmail_args')
5047 
    if self.email is not None:
5048 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5049 
      oprot.writeString(self.email)
3032 mandeep.dh 5050 
      oprot.writeFieldEnd()
5051 
    oprot.writeFieldStop()
5052 
    oprot.writeStructEnd()
5053 
 
3431 rajveer 5054 
  def validate(self):
5055 
    return
5056 
 
5057 
 
3032 mandeep.dh 5058 
  def __repr__(self):
5059 
    L = ['%s=%r' % (key, value)
5060 
      for key, value in self.__dict__.iteritems()]
5061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5062 
 
5063 
  def __eq__(self, other):
5064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5065 
 
5066 
  def __ne__(self, other):
5067 
    return not (self == other)
5068 
 
5326 rajveer 5069 
class getUserByEmail_result:
3032 mandeep.dh 5070 
  """
5071 
  Attributes:
5072 
   - success
5073 
   - ucex
5074 
  """
5075 
 
5076 
  thrift_spec = (
5077 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5078 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5079 
  )
5080 
 
5081 
  def __init__(self, success=None, ucex=None,):
5082 
    self.success = success
5083 
    self.ucex = ucex
5084 
 
5085 
  def read(self, iprot):
5086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5088 
      return
5089 
    iprot.readStructBegin()
5090 
    while True:
5091 
      (fname, ftype, fid) = iprot.readFieldBegin()
5092 
      if ftype == TType.STOP:
5093 
        break
5094 
      if fid == 0:
5095 
        if ftype == TType.STRUCT:
5096 
          self.success = User()
5097 
          self.success.read(iprot)
5098 
        else:
5099 
          iprot.skip(ftype)
5100 
      elif fid == 1:
5101 
        if ftype == TType.STRUCT:
5102 
          self.ucex = UserContextException()
5103 
          self.ucex.read(iprot)
5104 
        else:
5105 
          iprot.skip(ftype)
5106 
      else:
5107 
        iprot.skip(ftype)
5108 
      iprot.readFieldEnd()
5109 
    iprot.readStructEnd()
5110 
 
5111 
  def write(self, oprot):
5112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5114 
      return
5326 rajveer 5115 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5116 
    if self.success is not None:
3032 mandeep.dh 5117 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5118 
      self.success.write(oprot)
5119 
      oprot.writeFieldEnd()
3431 rajveer 5120 
    if self.ucex is not None:
3032 mandeep.dh 5121 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5122 
      self.ucex.write(oprot)
5123 
      oprot.writeFieldEnd()
5124 
    oprot.writeFieldStop()
5125 
    oprot.writeStructEnd()
5126 
 
3431 rajveer 5127 
  def validate(self):
5128 
    return
5129 
 
5130 
 
3032 mandeep.dh 5131 
  def __repr__(self):
5132 
    L = ['%s=%r' % (key, value)
5133 
      for key, value in self.__dict__.iteritems()]
5134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5135 
 
5136 
  def __eq__(self, other):
5137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5138 
 
5139 
  def __ne__(self, other):
5140 
    return not (self == other)
5141 
 
5326 rajveer 5142 
class getUserByMobileNumber_args:
94 ashish 5143 
  """
5144 
  Attributes:
5326 rajveer 5145 
   - mobileNumber
94 ashish 5146 
  """
5147 
 
5148 
  thrift_spec = (
5149 
    None, # 0
5326 rajveer 5150 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5151 
  )
5152 
 
5326 rajveer 5153 
  def __init__(self, mobileNumber=None,):
5154 
    self.mobileNumber = mobileNumber
94 ashish 5155 
 
5156 
  def read(self, iprot):
5157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5159 
      return
5160 
    iprot.readStructBegin()
5161 
    while True:
5162 
      (fname, ftype, fid) = iprot.readFieldBegin()
5163 
      if ftype == TType.STOP:
5164 
        break
5165 
      if fid == 1:
5326 rajveer 5166 
        if ftype == TType.I64:
5167 
          self.mobileNumber = iprot.readI64();
94 ashish 5168 
        else:
5169 
          iprot.skip(ftype)
5170 
      else:
5171 
        iprot.skip(ftype)
5172 
      iprot.readFieldEnd()
5173 
    iprot.readStructEnd()
5174 
 
5175 
  def write(self, oprot):
5176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5178 
      return
5326 rajveer 5179 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5180 
    if self.mobileNumber is not None:
5181 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5182 
      oprot.writeI64(self.mobileNumber)
94 ashish 5183 
      oprot.writeFieldEnd()
5184 
    oprot.writeFieldStop()
5185 
    oprot.writeStructEnd()
5186 
 
3431 rajveer 5187 
  def validate(self):
5188 
    return
5189 
 
5190 
 
94 ashish 5191 
  def __repr__(self):
5192 
    L = ['%s=%r' % (key, value)
5193 
      for key, value in self.__dict__.iteritems()]
5194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5195 
 
5196 
  def __eq__(self, other):
5197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5198 
 
5199 
  def __ne__(self, other):
5200 
    return not (self == other)
5201 
 
5326 rajveer 5202 
class getUserByMobileNumber_result:
94 ashish 5203 
  """
5204 
  Attributes:
5205 
   - success
559 chandransh 5206 
   - ucex
94 ashish 5207 
  """
5208 
 
5209 
  thrift_spec = (
559 chandransh 5210 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5211 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5212 
  )
5213 
 
559 chandransh 5214 
  def __init__(self, success=None, ucex=None,):
94 ashish 5215 
    self.success = success
559 chandransh 5216 
    self.ucex = ucex
94 ashish 5217 
 
5218 
  def read(self, iprot):
5219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5221 
      return
5222 
    iprot.readStructBegin()
5223 
    while True:
5224 
      (fname, ftype, fid) = iprot.readFieldBegin()
5225 
      if ftype == TType.STOP:
5226 
        break
5227 
      if fid == 0:
5228 
        if ftype == TType.STRUCT:
559 chandransh 5229 
          self.success = User()
94 ashish 5230 
          self.success.read(iprot)
5231 
        else:
5232 
          iprot.skip(ftype)
5233 
      elif fid == 1:
5234 
        if ftype == TType.STRUCT:
559 chandransh 5235 
          self.ucex = UserContextException()
5236 
          self.ucex.read(iprot)
94 ashish 5237 
        else:
5238 
          iprot.skip(ftype)
5239 
      else:
5240 
        iprot.skip(ftype)
5241 
      iprot.readFieldEnd()
5242 
    iprot.readStructEnd()
5243 
 
5244 
  def write(self, oprot):
5245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5247 
      return
5326 rajveer 5248 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5249 
    if self.success is not None:
94 ashish 5250 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5251 
      self.success.write(oprot)
5252 
      oprot.writeFieldEnd()
3431 rajveer 5253 
    if self.ucex is not None:
559 chandransh 5254 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5255 
      self.ucex.write(oprot)
94 ashish 5256 
      oprot.writeFieldEnd()
5257 
    oprot.writeFieldStop()
5258 
    oprot.writeStructEnd()
5259 
 
3431 rajveer 5260 
  def validate(self):
5261 
    return
5262 
 
5263 
 
94 ashish 5264 
  def __repr__(self):
5265 
    L = ['%s=%r' % (key, value)
5266 
      for key, value in self.__dict__.iteritems()]
5267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5268 
 
5269 
  def __eq__(self, other):
5270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5271 
 
5272 
  def __ne__(self, other):
5273 
    return not (self == other)
5274 
 
5326 rajveer 5275 
class createUser_args:
94 ashish 5276 
  """
5277 
  Attributes:
559 chandransh 5278 
   - user
94 ashish 5279 
  """
5280 
 
5281 
  thrift_spec = (
5282 
    None, # 0
559 chandransh 5283 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5284 
  )
5285 
 
559 chandransh 5286 
  def __init__(self, user=None,):
5287 
    self.user = user
94 ashish 5288 
 
5289 
  def read(self, iprot):
5290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5292 
      return
5293 
    iprot.readStructBegin()
5294 
    while True:
5295 
      (fname, ftype, fid) = iprot.readFieldBegin()
5296 
      if ftype == TType.STOP:
5297 
        break
5298 
      if fid == 1:
559 chandransh 5299 
        if ftype == TType.STRUCT:
5300 
          self.user = User()
5301 
          self.user.read(iprot)
94 ashish 5302 
        else:
5303 
          iprot.skip(ftype)
5304 
      else:
5305 
        iprot.skip(ftype)
5306 
      iprot.readFieldEnd()
5307 
    iprot.readStructEnd()
5308 
 
5309 
  def write(self, oprot):
5310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5312 
      return
5326 rajveer 5313 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5314 
    if self.user is not None:
559 chandransh 5315 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5316 
      self.user.write(oprot)
94 ashish 5317 
      oprot.writeFieldEnd()
5318 
    oprot.writeFieldStop()
5319 
    oprot.writeStructEnd()
5320 
 
3431 rajveer 5321 
  def validate(self):
5322 
    return
5323 
 
5324 
 
94 ashish 5325 
  def __repr__(self):
5326 
    L = ['%s=%r' % (key, value)
5327 
      for key, value in self.__dict__.iteritems()]
5328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5329 
 
5330 
  def __eq__(self, other):
5331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5332 
 
5333 
  def __ne__(self, other):
5334 
    return not (self == other)
5335 
 
5326 rajveer 5336 
class createUser_result:
94 ashish 5337 
  """
5338 
  Attributes:
5339 
   - success
559 chandransh 5340 
   - ucex
94 ashish 5341 
  """
5342 
 
5343 
  thrift_spec = (
559 chandransh 5344 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5345 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5346 
  )
5347 
 
559 chandransh 5348 
  def __init__(self, success=None, ucex=None,):
94 ashish 5349 
    self.success = success
559 chandransh 5350 
    self.ucex = ucex
94 ashish 5351 
 
5352 
  def read(self, iprot):
5353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5355 
      return
5356 
    iprot.readStructBegin()
5357 
    while True:
5358 
      (fname, ftype, fid) = iprot.readFieldBegin()
5359 
      if ftype == TType.STOP:
5360 
        break
5361 
      if fid == 0:
5362 
        if ftype == TType.STRUCT:
559 chandransh 5363 
          self.success = User()
94 ashish 5364 
          self.success.read(iprot)
5365 
        else:
5366 
          iprot.skip(ftype)
5367 
      elif fid == 1:
5368 
        if ftype == TType.STRUCT:
559 chandransh 5369 
          self.ucex = UserContextException()
5370 
          self.ucex.read(iprot)
94 ashish 5371 
        else:
5372 
          iprot.skip(ftype)
5373 
      else:
5374 
        iprot.skip(ftype)
5375 
      iprot.readFieldEnd()
5376 
    iprot.readStructEnd()
5377 
 
5378 
  def write(self, oprot):
5379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5381 
      return
5326 rajveer 5382 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5383 
    if self.success is not None:
94 ashish 5384 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5385 
      self.success.write(oprot)
5386 
      oprot.writeFieldEnd()
3431 rajveer 5387 
    if self.ucex is not None:
559 chandransh 5388 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5389 
      self.ucex.write(oprot)
94 ashish 5390 
      oprot.writeFieldEnd()
5391 
    oprot.writeFieldStop()
5392 
    oprot.writeStructEnd()
5393 
 
3431 rajveer 5394 
  def validate(self):
5395 
    return
5396 
 
5397 
 
94 ashish 5398 
  def __repr__(self):
5399 
    L = ['%s=%r' % (key, value)
5400 
      for key, value in self.__dict__.iteritems()]
5401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5402 
 
5403 
  def __eq__(self, other):
5404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5405 
 
5406 
  def __ne__(self, other):
5407 
    return not (self == other)
5408 
 
5326 rajveer 5409 
class updateUser_args:
94 ashish 5410 
  """
5411 
  Attributes:
5326 rajveer 5412 
   - user
94 ashish 5413 
  """
5414 
 
5415 
  thrift_spec = (
5416 
    None, # 0
5326 rajveer 5417 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5418 
  )
5419 
 
5326 rajveer 5420 
  def __init__(self, user=None,):
5421 
    self.user = user
94 ashish 5422 
 
5423 
  def read(self, iprot):
5424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5426 
      return
5427 
    iprot.readStructBegin()
5428 
    while True:
5429 
      (fname, ftype, fid) = iprot.readFieldBegin()
5430 
      if ftype == TType.STOP:
5431 
        break
5432 
      if fid == 1:
5326 rajveer 5433 
        if ftype == TType.STRUCT:
5434 
          self.user = User()
5435 
          self.user.read(iprot)
94 ashish 5436 
        else:
5437 
          iprot.skip(ftype)
5438 
      else:
5439 
        iprot.skip(ftype)
5440 
      iprot.readFieldEnd()
5441 
    iprot.readStructEnd()
5442 
 
5443 
  def write(self, oprot):
5444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5446 
      return
5326 rajveer 5447 
    oprot.writeStructBegin('updateUser_args')
5448 
    if self.user is not None:
5449 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5450 
      self.user.write(oprot)
94 ashish 5451 
      oprot.writeFieldEnd()
5452 
    oprot.writeFieldStop()
5453 
    oprot.writeStructEnd()
5454 
 
3431 rajveer 5455 
  def validate(self):
5456 
    return
5457 
 
5458 
 
94 ashish 5459 
  def __repr__(self):
5460 
    L = ['%s=%r' % (key, value)
5461 
      for key, value in self.__dict__.iteritems()]
5462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5463 
 
5464 
  def __eq__(self, other):
5465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5466 
 
5467 
  def __ne__(self, other):
5468 
    return not (self == other)
5469 
 
5326 rajveer 5470 
class updateUser_result:
94 ashish 5471 
  """
5472 
  Attributes:
5473 
   - success
559 chandransh 5474 
   - ucex
94 ashish 5475 
  """
5476 
 
5477 
  thrift_spec = (
5326 rajveer 5478 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5479 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5480 
  )
5481 
 
559 chandransh 5482 
  def __init__(self, success=None, ucex=None,):
94 ashish 5483 
    self.success = success
559 chandransh 5484 
    self.ucex = ucex
94 ashish 5485 
 
5486 
  def read(self, iprot):
5487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5489 
      return
5490 
    iprot.readStructBegin()
5491 
    while True:
5492 
      (fname, ftype, fid) = iprot.readFieldBegin()
5493 
      if ftype == TType.STOP:
5494 
        break
5495 
      if fid == 0:
5326 rajveer 5496 
        if ftype == TType.STRUCT:
5497 
          self.success = User()
5498 
          self.success.read(iprot)
94 ashish 5499 
        else:
5500 
          iprot.skip(ftype)
5501 
      elif fid == 1:
5502 
        if ftype == TType.STRUCT:
559 chandransh 5503 
          self.ucex = UserContextException()
5504 
          self.ucex.read(iprot)
94 ashish 5505 
        else:
5506 
          iprot.skip(ftype)
5507 
      else:
5508 
        iprot.skip(ftype)
5509 
      iprot.readFieldEnd()
5510 
    iprot.readStructEnd()
5511 
 
5512 
  def write(self, oprot):
5513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5515 
      return
5326 rajveer 5516 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5517 
    if self.success is not None:
5326 rajveer 5518 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5519 
      self.success.write(oprot)
94 ashish 5520 
      oprot.writeFieldEnd()
3431 rajveer 5521 
    if self.ucex is not None:
559 chandransh 5522 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5523 
      self.ucex.write(oprot)
94 ashish 5524 
      oprot.writeFieldEnd()
5525 
    oprot.writeFieldStop()
5526 
    oprot.writeStructEnd()
5527 
 
3431 rajveer 5528 
  def validate(self):
5529 
    return
5530 
 
5531 
 
94 ashish 5532 
  def __repr__(self):
5533 
    L = ['%s=%r' % (key, value)
5534 
      for key, value in self.__dict__.iteritems()]
5535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5536 
 
5537 
  def __eq__(self, other):
5538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5539 
 
5540 
  def __ne__(self, other):
5541 
    return not (self == other)
5542 
 
559 chandransh 5543 
class authenticateUser_args:
94 ashish 5544 
  """
5545 
  Attributes:
5546 
   - email
5547 
   - password
5548 
  """
5549 
 
5550 
  thrift_spec = (
5551 
    None, # 0
5552 
    (1, TType.STRING, 'email', None, None, ), # 1
5553 
    (2, TType.STRING, 'password', None, None, ), # 2
5554 
  )
5555 
 
5556 
  def __init__(self, email=None, password=None,):
5557 
    self.email = email
5558 
    self.password = password
5559 
 
5560 
  def read(self, iprot):
5561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5563 
      return
5564 
    iprot.readStructBegin()
5565 
    while True:
5566 
      (fname, ftype, fid) = iprot.readFieldBegin()
5567 
      if ftype == TType.STOP:
5568 
        break
5569 
      if fid == 1:
5570 
        if ftype == TType.STRING:
5571 
          self.email = iprot.readString();
5572 
        else:
5573 
          iprot.skip(ftype)
5574 
      elif fid == 2:
5575 
        if ftype == TType.STRING:
5576 
          self.password = iprot.readString();
5577 
        else:
5578 
          iprot.skip(ftype)
5579 
      else:
5580 
        iprot.skip(ftype)
5581 
      iprot.readFieldEnd()
5582 
    iprot.readStructEnd()
5583 
 
5584 
  def write(self, oprot):
5585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5587 
      return
559 chandransh 5588 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5589 
    if self.email is not None:
94 ashish 5590 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5591 
      oprot.writeString(self.email)
5592 
      oprot.writeFieldEnd()
3431 rajveer 5593 
    if self.password is not None:
94 ashish 5594 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5595 
      oprot.writeString(self.password)
5596 
      oprot.writeFieldEnd()
5597 
    oprot.writeFieldStop()
5598 
    oprot.writeStructEnd()
5599 
 
3431 rajveer 5600 
  def validate(self):
5601 
    return
5602 
 
5603 
 
94 ashish 5604 
  def __repr__(self):
5605 
    L = ['%s=%r' % (key, value)
5606 
      for key, value in self.__dict__.iteritems()]
5607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5608 
 
5609 
  def __eq__(self, other):
5610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5611 
 
5612 
  def __ne__(self, other):
5613 
    return not (self == other)
5614 
 
559 chandransh 5615 
class authenticateUser_result:
94 ashish 5616 
  """
5617 
  Attributes:
5618 
   - success
559 chandransh 5619 
   - auex
94 ashish 5620 
  """
5621 
 
5622 
  thrift_spec = (
559 chandransh 5623 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5624 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5625 
  )
5626 
 
559 chandransh 5627 
  def __init__(self, success=None, auex=None,):
94 ashish 5628 
    self.success = success
559 chandransh 5629 
    self.auex = auex
94 ashish 5630 
 
5631 
  def read(self, iprot):
5632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5634 
      return
5635 
    iprot.readStructBegin()
5636 
    while True:
5637 
      (fname, ftype, fid) = iprot.readFieldBegin()
5638 
      if ftype == TType.STOP:
5639 
        break
5640 
      if fid == 0:
5641 
        if ftype == TType.STRUCT:
559 chandransh 5642 
          self.success = User()
94 ashish 5643 
          self.success.read(iprot)
5644 
        else:
5645 
          iprot.skip(ftype)
5646 
      elif fid == 1:
5647 
        if ftype == TType.STRUCT:
559 chandransh 5648 
          self.auex = AuthenticationException()
5649 
          self.auex.read(iprot)
94 ashish 5650 
        else:
5651 
          iprot.skip(ftype)
5652 
      else:
5653 
        iprot.skip(ftype)
5654 
      iprot.readFieldEnd()
5655 
    iprot.readStructEnd()
5656 
 
5657 
  def write(self, oprot):
5658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5660 
      return
559 chandransh 5661 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5662 
    if self.success is not None:
94 ashish 5663 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5664 
      self.success.write(oprot)
5665 
      oprot.writeFieldEnd()
3431 rajveer 5666 
    if self.auex is not None:
559 chandransh 5667 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5668 
      self.auex.write(oprot)
94 ashish 5669 
      oprot.writeFieldEnd()
5670 
    oprot.writeFieldStop()
5671 
    oprot.writeStructEnd()
5672 
 
3431 rajveer 5673 
  def validate(self):
5674 
    return
5675 
 
5676 
 
94 ashish 5677 
  def __repr__(self):
5678 
    L = ['%s=%r' % (key, value)
5679 
      for key, value in self.__dict__.iteritems()]
5680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5681 
 
5682 
  def __eq__(self, other):
5683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5684 
 
5685 
  def __ne__(self, other):
5686 
    return not (self == other)
5687 
 
559 chandransh 5688 
class userExists_args:
122 ashish 5689 
  """
5690 
  Attributes:
559 chandransh 5691 
   - email
122 ashish 5692 
  """
5693 
 
5694 
  thrift_spec = (
5695 
    None, # 0
559 chandransh 5696 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5697 
  )
5698 
 
559 chandransh 5699 
  def __init__(self, email=None,):
5700 
    self.email = email
122 ashish 5701 
 
5702 
  def read(self, iprot):
5703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5705 
      return
5706 
    iprot.readStructBegin()
5707 
    while True:
5708 
      (fname, ftype, fid) = iprot.readFieldBegin()
5709 
      if ftype == TType.STOP:
5710 
        break
5711 
      if fid == 1:
5712 
        if ftype == TType.STRING:
559 chandransh 5713 
          self.email = iprot.readString();
122 ashish 5714 
        else:
5715 
          iprot.skip(ftype)
559 chandransh 5716 
      else:
5717 
        iprot.skip(ftype)
5718 
      iprot.readFieldEnd()
5719 
    iprot.readStructEnd()
5720 
 
5721 
  def write(self, oprot):
5722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5724 
      return
5725 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5726 
    if self.email is not None:
559 chandransh 5727 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5728 
      oprot.writeString(self.email)
5729 
      oprot.writeFieldEnd()
5730 
    oprot.writeFieldStop()
5731 
    oprot.writeStructEnd()
5732 
 
3431 rajveer 5733 
  def validate(self):
5734 
    return
5735 
 
5736 
 
559 chandransh 5737 
  def __repr__(self):
5738 
    L = ['%s=%r' % (key, value)
5739 
      for key, value in self.__dict__.iteritems()]
5740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5741 
 
5742 
  def __eq__(self, other):
5743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5744 
 
5745 
  def __ne__(self, other):
5746 
    return not (self == other)
5747 
 
5748 
class userExists_result:
5749 
  """
5750 
  Attributes:
5751 
   - success
5752 
   - ucx
5753 
  """
5754 
 
5755 
  thrift_spec = (
5756 
    (0, TType.BOOL, 'success', None, None, ), # 0
5757 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5758 
  )
5759 
 
5760 
  def __init__(self, success=None, ucx=None,):
5761 
    self.success = success
5762 
    self.ucx = ucx
5763 
 
5764 
  def read(self, iprot):
5765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5767 
      return
5768 
    iprot.readStructBegin()
5769 
    while True:
5770 
      (fname, ftype, fid) = iprot.readFieldBegin()
5771 
      if ftype == TType.STOP:
5772 
        break
5773 
      if fid == 0:
5774 
        if ftype == TType.BOOL:
5775 
          self.success = iprot.readBool();
5776 
        else:
5777 
          iprot.skip(ftype)
5778 
      elif fid == 1:
5779 
        if ftype == TType.STRUCT:
5780 
          self.ucx = UserContextException()
5781 
          self.ucx.read(iprot)
5782 
        else:
5783 
          iprot.skip(ftype)
5784 
      else:
5785 
        iprot.skip(ftype)
5786 
      iprot.readFieldEnd()
5787 
    iprot.readStructEnd()
5788 
 
5789 
  def write(self, oprot):
5790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5792 
      return
5793 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5794 
    if self.success is not None:
559 chandransh 5795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5796 
      oprot.writeBool(self.success)
5797 
      oprot.writeFieldEnd()
3431 rajveer 5798 
    if self.ucx is not None:
559 chandransh 5799 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5800 
      self.ucx.write(oprot)
5801 
      oprot.writeFieldEnd()
5802 
    oprot.writeFieldStop()
5803 
    oprot.writeStructEnd()
5804 
 
3431 rajveer 5805 
  def validate(self):
5806 
    return
5807 
 
5808 
 
559 chandransh 5809 
  def __repr__(self):
5810 
    L = ['%s=%r' % (key, value)
5811 
      for key, value in self.__dict__.iteritems()]
5812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5813 
 
5814 
  def __eq__(self, other):
5815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5816 
 
5817 
  def __ne__(self, other):
5818 
    return not (self == other)
5819 
 
5820 
class addAddressForUser_args:
5821 
  """
5822 
  Attributes:
5823 
   - userId
5824 
   - address
5825 
   - setDefault
5826 
  """
5827 
 
5828 
  thrift_spec = (
5829 
    None, # 0
5830 
    (1, TType.I64, 'userId', None, None, ), # 1
5831 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5832 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5833 
  )
5834 
 
567 rajveer 5835 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5836 
    self.userId = userId
5837 
    self.address = address
5838 
    self.setDefault = setDefault
5839 
 
5840 
  def read(self, iprot):
5841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5843 
      return
5844 
    iprot.readStructBegin()
5845 
    while True:
5846 
      (fname, ftype, fid) = iprot.readFieldBegin()
5847 
      if ftype == TType.STOP:
5848 
        break
5849 
      if fid == 1:
5850 
        if ftype == TType.I64:
5851 
          self.userId = iprot.readI64();
5852 
        else:
5853 
          iprot.skip(ftype)
122 ashish 5854 
      elif fid == 2:
559 chandransh 5855 
        if ftype == TType.STRUCT:
5856 
          self.address = Address()
5857 
          self.address.read(iprot)
122 ashish 5858 
        else:
5859 
          iprot.skip(ftype)
5860 
      elif fid == 3:
5861 
        if ftype == TType.BOOL:
559 chandransh 5862 
          self.setDefault = iprot.readBool();
122 ashish 5863 
        else:
5864 
          iprot.skip(ftype)
5865 
      else:
5866 
        iprot.skip(ftype)
5867 
      iprot.readFieldEnd()
5868 
    iprot.readStructEnd()
5869 
 
5870 
  def write(self, oprot):
5871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5873 
      return
559 chandransh 5874 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5875 
    if self.userId is not None:
559 chandransh 5876 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5877 
      oprot.writeI64(self.userId)
122 ashish 5878 
      oprot.writeFieldEnd()
3431 rajveer 5879 
    if self.address is not None:
559 chandransh 5880 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5881 
      self.address.write(oprot)
122 ashish 5882 
      oprot.writeFieldEnd()
3431 rajveer 5883 
    if self.setDefault is not None:
567 rajveer 5884 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5885 
      oprot.writeBool(self.setDefault)
5886 
      oprot.writeFieldEnd()
122 ashish 5887 
    oprot.writeFieldStop()
5888 
    oprot.writeStructEnd()
5889 
 
3431 rajveer 5890 
  def validate(self):
5891 
    return
5892 
 
5893 
 
122 ashish 5894 
  def __repr__(self):
5895 
    L = ['%s=%r' % (key, value)
5896 
      for key, value in self.__dict__.iteritems()]
5897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5898 
 
5899 
  def __eq__(self, other):
5900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5901 
 
5902 
  def __ne__(self, other):
5903 
    return not (self == other)
5904 
 
559 chandransh 5905 
class addAddressForUser_result:
122 ashish 5906 
  """
5907 
  Attributes:
5908 
   - success
559 chandransh 5909 
   - ucx
122 ashish 5910 
  """
5911 
 
5912 
  thrift_spec = (
567 rajveer 5913 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5914 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5915 
  )
5916 
 
559 chandransh 5917 
  def __init__(self, success=None, ucx=None,):
122 ashish 5918 
    self.success = success
559 chandransh 5919 
    self.ucx = ucx
122 ashish 5920 
 
5921 
  def read(self, iprot):
5922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5924 
      return
5925 
    iprot.readStructBegin()
5926 
    while True:
5927 
      (fname, ftype, fid) = iprot.readFieldBegin()
5928 
      if ftype == TType.STOP:
5929 
        break
5930 
      if fid == 0:
567 rajveer 5931 
        if ftype == TType.I64:
5932 
          self.success = iprot.readI64();
122 ashish 5933 
        else:
5934 
          iprot.skip(ftype)
5935 
      elif fid == 1:
5936 
        if ftype == TType.STRUCT:
559 chandransh 5937 
          self.ucx = UserContextException()
5938 
          self.ucx.read(iprot)
122 ashish 5939 
        else:
5940 
          iprot.skip(ftype)
5941 
      else:
5942 
        iprot.skip(ftype)
5943 
      iprot.readFieldEnd()
5944 
    iprot.readStructEnd()
5945 
 
5946 
  def write(self, oprot):
5947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5949 
      return
559 chandransh 5950 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 5951 
    if self.success is not None:
567 rajveer 5952 
      oprot.writeFieldBegin('success', TType.I64, 0)
5953 
      oprot.writeI64(self.success)
122 ashish 5954 
      oprot.writeFieldEnd()
3431 rajveer 5955 
    if self.ucx is not None:
559 chandransh 5956 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5957 
      self.ucx.write(oprot)
122 ashish 5958 
      oprot.writeFieldEnd()
5959 
    oprot.writeFieldStop()
5960 
    oprot.writeStructEnd()
5961 
 
3431 rajveer 5962 
  def validate(self):
5963 
    return
5964 
 
5965 
 
122 ashish 5966 
  def __repr__(self):
5967 
    L = ['%s=%r' % (key, value)
5968 
      for key, value in self.__dict__.iteritems()]
5969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5970 
 
5971 
  def __eq__(self, other):
5972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5973 
 
5974 
  def __ne__(self, other):
5975 
    return not (self == other)
5976 
 
559 chandransh 5977 
class removeAddressForUser_args:
94 ashish 5978 
  """
5979 
  Attributes:
559 chandransh 5980 
   - userid
5981 
   - addressId
94 ashish 5982 
  """
5983 
 
5984 
  thrift_spec = (
5985 
    None, # 0
559 chandransh 5986 
    (1, TType.I64, 'userid', None, None, ), # 1
5987 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5988 
  )
5989 
 
559 chandransh 5990 
  def __init__(self, userid=None, addressId=None,):
5991 
    self.userid = userid
5992 
    self.addressId = addressId
94 ashish 5993 
 
5994 
  def read(self, iprot):
5995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5997 
      return
5998 
    iprot.readStructBegin()
5999 
    while True:
6000 
      (fname, ftype, fid) = iprot.readFieldBegin()
6001 
      if ftype == TType.STOP:
6002 
        break
6003 
      if fid == 1:
559 chandransh 6004 
        if ftype == TType.I64:
6005 
          self.userid = iprot.readI64();
94 ashish 6006 
        else:
6007 
          iprot.skip(ftype)
559 chandransh 6008 
      elif fid == 2:
6009 
        if ftype == TType.I64:
6010 
          self.addressId = iprot.readI64();
6011 
        else:
6012 
          iprot.skip(ftype)
94 ashish 6013 
      else:
6014 
        iprot.skip(ftype)
6015 
      iprot.readFieldEnd()
6016 
    iprot.readStructEnd()
6017 
 
6018 
  def write(self, oprot):
6019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6021 
      return
559 chandransh 6022 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6023 
    if self.userid is not None:
559 chandransh 6024 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6025 
      oprot.writeI64(self.userid)
94 ashish 6026 
      oprot.writeFieldEnd()
3431 rajveer 6027 
    if self.addressId is not None:
559 chandransh 6028 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6029 
      oprot.writeI64(self.addressId)
6030 
      oprot.writeFieldEnd()
94 ashish 6031 
    oprot.writeFieldStop()
6032 
    oprot.writeStructEnd()
6033 
 
3431 rajveer 6034 
  def validate(self):
6035 
    return
6036 
 
6037 
 
94 ashish 6038 
  def __repr__(self):
6039 
    L = ['%s=%r' % (key, value)
6040 
      for key, value in self.__dict__.iteritems()]
6041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6042 
 
6043 
  def __eq__(self, other):
6044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6045 
 
6046 
  def __ne__(self, other):
6047 
    return not (self == other)
6048 
 
559 chandransh 6049 
class removeAddressForUser_result:
94 ashish 6050 
  """
6051 
  Attributes:
6052 
   - success
6053 
   - ucx
6054 
  """
6055 
 
6056 
  thrift_spec = (
6057 
    (0, TType.BOOL, 'success', None, None, ), # 0
6058 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6059 
  )
6060 
 
6061 
  def __init__(self, success=None, ucx=None,):
6062 
    self.success = success
6063 
    self.ucx = ucx
6064 
 
6065 
  def read(self, iprot):
6066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6068 
      return
6069 
    iprot.readStructBegin()
6070 
    while True:
6071 
      (fname, ftype, fid) = iprot.readFieldBegin()
6072 
      if ftype == TType.STOP:
6073 
        break
6074 
      if fid == 0:
6075 
        if ftype == TType.BOOL:
6076 
          self.success = iprot.readBool();
6077 
        else:
6078 
          iprot.skip(ftype)
6079 
      elif fid == 1:
6080 
        if ftype == TType.STRUCT:
6081 
          self.ucx = UserContextException()
6082 
          self.ucx.read(iprot)
6083 
        else:
6084 
          iprot.skip(ftype)
6085 
      else:
6086 
        iprot.skip(ftype)
6087 
      iprot.readFieldEnd()
6088 
    iprot.readStructEnd()
6089 
 
6090 
  def write(self, oprot):
6091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6093 
      return
559 chandransh 6094 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6095 
    if self.success is not None:
94 ashish 6096 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6097 
      oprot.writeBool(self.success)
6098 
      oprot.writeFieldEnd()
3431 rajveer 6099 
    if self.ucx is not None:
94 ashish 6100 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6101 
      self.ucx.write(oprot)
6102 
      oprot.writeFieldEnd()
6103 
    oprot.writeFieldStop()
6104 
    oprot.writeStructEnd()
6105 
 
3431 rajveer 6106 
  def validate(self):
6107 
    return
6108 
 
6109 
 
94 ashish 6110 
  def __repr__(self):
6111 
    L = ['%s=%r' % (key, value)
6112 
      for key, value in self.__dict__.iteritems()]
6113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6114 
 
6115 
  def __eq__(self, other):
6116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6117 
 
6118 
  def __ne__(self, other):
6119 
    return not (self == other)
6120 
 
559 chandransh 6121 
class setUserAsLoggedIn_args:
94 ashish 6122 
  """
6123 
  Attributes:
559 chandransh 6124 
   - userId
94 ashish 6125 
   - timestamp
6126 
  """
6127 
 
6128 
  thrift_spec = (
6129 
    None, # 0
559 chandransh 6130 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6131 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6132 
  )
6133 
 
559 chandransh 6134 
  def __init__(self, userId=None, timestamp=None,):
6135 
    self.userId = userId
94 ashish 6136 
    self.timestamp = timestamp
6137 
 
6138 
  def read(self, iprot):
6139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6141 
      return
6142 
    iprot.readStructBegin()
6143 
    while True:
6144 
      (fname, ftype, fid) = iprot.readFieldBegin()
6145 
      if ftype == TType.STOP:
6146 
        break
6147 
      if fid == 1:
559 chandransh 6148 
        if ftype == TType.I64:
6149 
          self.userId = iprot.readI64();
94 ashish 6150 
        else:
6151 
          iprot.skip(ftype)
6152 
      elif fid == 2:
6153 
        if ftype == TType.I64:
6154 
          self.timestamp = iprot.readI64();
6155 
        else:
6156 
          iprot.skip(ftype)
6157 
      else:
6158 
        iprot.skip(ftype)
6159 
      iprot.readFieldEnd()
6160 
    iprot.readStructEnd()
6161 
 
6162 
  def write(self, oprot):
6163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6165 
      return
559 chandransh 6166 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6167 
    if self.userId is not None:
559 chandransh 6168 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6169 
      oprot.writeI64(self.userId)
94 ashish 6170 
      oprot.writeFieldEnd()
3431 rajveer 6171 
    if self.timestamp is not None:
94 ashish 6172 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6173 
      oprot.writeI64(self.timestamp)
6174 
      oprot.writeFieldEnd()
6175 
    oprot.writeFieldStop()
6176 
    oprot.writeStructEnd()
6177 
 
3431 rajveer 6178 
  def validate(self):
6179 
    return
6180 
 
6181 
 
94 ashish 6182 
  def __repr__(self):
6183 
    L = ['%s=%r' % (key, value)
6184 
      for key, value in self.__dict__.iteritems()]
6185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6186 
 
6187 
  def __eq__(self, other):
6188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6189 
 
6190 
  def __ne__(self, other):
6191 
    return not (self == other)
6192 
 
559 chandransh 6193 
class setUserAsLoggedIn_result:
94 ashish 6194 
  """
6195 
  Attributes:
6196 
   - success
6197 
   - ucx
6198 
  """
6199 
 
6200 
  thrift_spec = (
6201 
    (0, TType.BOOL, 'success', None, None, ), # 0
6202 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6203 
  )
6204 
 
6205 
  def __init__(self, success=None, ucx=None,):
6206 
    self.success = success
6207 
    self.ucx = ucx
6208 
 
6209 
  def read(self, iprot):
6210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6212 
      return
6213 
    iprot.readStructBegin()
6214 
    while True:
6215 
      (fname, ftype, fid) = iprot.readFieldBegin()
6216 
      if ftype == TType.STOP:
6217 
        break
6218 
      if fid == 0:
6219 
        if ftype == TType.BOOL:
6220 
          self.success = iprot.readBool();
6221 
        else:
6222 
          iprot.skip(ftype)
6223 
      elif fid == 1:
6224 
        if ftype == TType.STRUCT:
6225 
          self.ucx = UserContextException()
6226 
          self.ucx.read(iprot)
6227 
        else:
6228 
          iprot.skip(ftype)
6229 
      else:
6230 
        iprot.skip(ftype)
6231 
      iprot.readFieldEnd()
6232 
    iprot.readStructEnd()
6233 
 
6234 
  def write(self, oprot):
6235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6237 
      return
559 chandransh 6238 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6239 
    if self.success is not None:
94 ashish 6240 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6241 
      oprot.writeBool(self.success)
6242 
      oprot.writeFieldEnd()
3431 rajveer 6243 
    if self.ucx is not None:
94 ashish 6244 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6245 
      self.ucx.write(oprot)
6246 
      oprot.writeFieldEnd()
6247 
    oprot.writeFieldStop()
6248 
    oprot.writeStructEnd()
6249 
 
3431 rajveer 6250 
  def validate(self):
6251 
    return
6252 
 
6253 
 
94 ashish 6254 
  def __repr__(self):
6255 
    L = ['%s=%r' % (key, value)
6256 
      for key, value in self.__dict__.iteritems()]
6257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6258 
 
6259 
  def __eq__(self, other):
6260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6261 
 
6262 
  def __ne__(self, other):
6263 
    return not (self == other)
6264 
 
559 chandransh 6265 
class setUserAsLoggedOut_args:
94 ashish 6266 
  """
6267 
  Attributes:
6268 
   - userid
6269 
   - timestamp
6270 
  """
6271 
 
6272 
  thrift_spec = (
6273 
    None, # 0
559 chandransh 6274 
    (1, TType.I64, 'userid', None, None, ), # 1
6275 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6276 
  )
6277 
 
559 chandransh 6278 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6279 
    self.userid = userid
6280 
    self.timestamp = timestamp
6281 
 
6282 
  def read(self, iprot):
6283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6285 
      return
6286 
    iprot.readStructBegin()
6287 
    while True:
6288 
      (fname, ftype, fid) = iprot.readFieldBegin()
6289 
      if ftype == TType.STOP:
6290 
        break
6291 
      if fid == 1:
6292 
        if ftype == TType.I64:
6293 
          self.userid = iprot.readI64();
6294 
        else:
6295 
          iprot.skip(ftype)
559 chandransh 6296 
      elif fid == 2:
94 ashish 6297 
        if ftype == TType.I64:
6298 
          self.timestamp = iprot.readI64();
6299 
        else:
6300 
          iprot.skip(ftype)
6301 
      else:
6302 
        iprot.skip(ftype)
6303 
      iprot.readFieldEnd()
6304 
    iprot.readStructEnd()
6305 
 
6306 
  def write(self, oprot):
6307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6309 
      return
559 chandransh 6310 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6311 
    if self.userid is not None:
559 chandransh 6312 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6313 
      oprot.writeI64(self.userid)
6314 
      oprot.writeFieldEnd()
3431 rajveer 6315 
    if self.timestamp is not None:
559 chandransh 6316 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6317 
      oprot.writeI64(self.timestamp)
6318 
      oprot.writeFieldEnd()
6319 
    oprot.writeFieldStop()
6320 
    oprot.writeStructEnd()
6321 
 
3431 rajveer 6322 
  def validate(self):
6323 
    return
6324 
 
6325 
 
94 ashish 6326 
  def __repr__(self):
6327 
    L = ['%s=%r' % (key, value)
6328 
      for key, value in self.__dict__.iteritems()]
6329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6330 
 
6331 
  def __eq__(self, other):
6332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6333 
 
6334 
  def __ne__(self, other):
6335 
    return not (self == other)
6336 
 
559 chandransh 6337 
class setUserAsLoggedOut_result:
94 ashish 6338 
  """
6339 
  Attributes:
6340 
   - success
6341 
   - ucx
6342 
  """
6343 
 
6344 
  thrift_spec = (
6345 
    (0, TType.BOOL, 'success', None, None, ), # 0
6346 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6347 
  )
6348 
 
6349 
  def __init__(self, success=None, ucx=None,):
6350 
    self.success = success
6351 
    self.ucx = ucx
6352 
 
6353 
  def read(self, iprot):
6354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6356 
      return
6357 
    iprot.readStructBegin()
6358 
    while True:
6359 
      (fname, ftype, fid) = iprot.readFieldBegin()
6360 
      if ftype == TType.STOP:
6361 
        break
6362 
      if fid == 0:
6363 
        if ftype == TType.BOOL:
6364 
          self.success = iprot.readBool();
6365 
        else:
6366 
          iprot.skip(ftype)
6367 
      elif fid == 1:
6368 
        if ftype == TType.STRUCT:
6369 
          self.ucx = UserContextException()
6370 
          self.ucx.read(iprot)
6371 
        else:
6372 
          iprot.skip(ftype)
6373 
      else:
6374 
        iprot.skip(ftype)
6375 
      iprot.readFieldEnd()
6376 
    iprot.readStructEnd()
6377 
 
6378 
  def write(self, oprot):
6379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6381 
      return
559 chandransh 6382 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6383 
    if self.success is not None:
94 ashish 6384 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6385 
      oprot.writeBool(self.success)
6386 
      oprot.writeFieldEnd()
3431 rajveer 6387 
    if self.ucx is not None:
94 ashish 6388 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6389 
      self.ucx.write(oprot)
6390 
      oprot.writeFieldEnd()
6391 
    oprot.writeFieldStop()
6392 
    oprot.writeStructEnd()
6393 
 
3431 rajveer 6394 
  def validate(self):
6395 
    return
6396 
 
6397 
 
94 ashish 6398 
  def __repr__(self):
6399 
    L = ['%s=%r' % (key, value)
6400 
      for key, value in self.__dict__.iteritems()]
6401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6402 
 
6403 
  def __eq__(self, other):
6404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6405 
 
6406 
  def __ne__(self, other):
6407 
    return not (self == other)
6408 
 
559 chandransh 6409 
class setDefaultAddress_args:
94 ashish 6410 
  """
6411 
  Attributes:
6412 
   - userid
6413 
   - addressId
6414 
  """
6415 
 
6416 
  thrift_spec = (
6417 
    None, # 0
6418 
    (1, TType.I64, 'userid', None, None, ), # 1
6419 
    (2, TType.I64, 'addressId', None, None, ), # 2
6420 
  )
6421 
 
6422 
  def __init__(self, userid=None, addressId=None,):
6423 
    self.userid = userid
6424 
    self.addressId = addressId
6425 
 
6426 
  def read(self, iprot):
6427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6429 
      return
6430 
    iprot.readStructBegin()
6431 
    while True:
6432 
      (fname, ftype, fid) = iprot.readFieldBegin()
6433 
      if ftype == TType.STOP:
6434 
        break
6435 
      if fid == 1:
6436 
        if ftype == TType.I64:
6437 
          self.userid = iprot.readI64();
6438 
        else:
6439 
          iprot.skip(ftype)
6440 
      elif fid == 2:
6441 
        if ftype == TType.I64:
6442 
          self.addressId = iprot.readI64();
6443 
        else:
6444 
          iprot.skip(ftype)
6445 
      else:
6446 
        iprot.skip(ftype)
6447 
      iprot.readFieldEnd()
6448 
    iprot.readStructEnd()
6449 
 
6450 
  def write(self, oprot):
6451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6453 
      return
559 chandransh 6454 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6455 
    if self.userid is not None:
94 ashish 6456 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6457 
      oprot.writeI64(self.userid)
6458 
      oprot.writeFieldEnd()
3431 rajveer 6459 
    if self.addressId is not None:
94 ashish 6460 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6461 
      oprot.writeI64(self.addressId)
6462 
      oprot.writeFieldEnd()
6463 
    oprot.writeFieldStop()
6464 
    oprot.writeStructEnd()
6465 
 
3431 rajveer 6466 
  def validate(self):
6467 
    return
6468 
 
6469 
 
94 ashish 6470 
  def __repr__(self):
6471 
    L = ['%s=%r' % (key, value)
6472 
      for key, value in self.__dict__.iteritems()]
6473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6474 
 
6475 
  def __eq__(self, other):
6476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6477 
 
6478 
  def __ne__(self, other):
6479 
    return not (self == other)
6480 
 
559 chandransh 6481 
class setDefaultAddress_result:
94 ashish 6482 
  """
6483 
  Attributes:
6484 
   - success
6485 
   - ucx
6486 
  """
6487 
 
6488 
  thrift_spec = (
6489 
    (0, TType.BOOL, 'success', None, None, ), # 0
6490 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6491 
  )
6492 
 
6493 
  def __init__(self, success=None, ucx=None,):
6494 
    self.success = success
6495 
    self.ucx = ucx
6496 
 
6497 
  def read(self, iprot):
6498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6500 
      return
6501 
    iprot.readStructBegin()
6502 
    while True:
6503 
      (fname, ftype, fid) = iprot.readFieldBegin()
6504 
      if ftype == TType.STOP:
6505 
        break
6506 
      if fid == 0:
6507 
        if ftype == TType.BOOL:
6508 
          self.success = iprot.readBool();
6509 
        else:
6510 
          iprot.skip(ftype)
6511 
      elif fid == 1:
6512 
        if ftype == TType.STRUCT:
6513 
          self.ucx = UserContextException()
6514 
          self.ucx.read(iprot)
6515 
        else:
6516 
          iprot.skip(ftype)
6517 
      else:
6518 
        iprot.skip(ftype)
6519 
      iprot.readFieldEnd()
6520 
    iprot.readStructEnd()
6521 
 
6522 
  def write(self, oprot):
6523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6525 
      return
559 chandransh 6526 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6527 
    if self.success is not None:
94 ashish 6528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6529 
      oprot.writeBool(self.success)
6530 
      oprot.writeFieldEnd()
3431 rajveer 6531 
    if self.ucx is not None:
94 ashish 6532 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6533 
      self.ucx.write(oprot)
6534 
      oprot.writeFieldEnd()
6535 
    oprot.writeFieldStop()
6536 
    oprot.writeStructEnd()
6537 
 
3431 rajveer 6538 
  def validate(self):
6539 
    return
6540 
 
6541 
 
94 ashish 6542 
  def __repr__(self):
6543 
    L = ['%s=%r' % (key, value)
6544 
      for key, value in self.__dict__.iteritems()]
6545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6546 
 
6547 
  def __eq__(self, other):
6548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6549 
 
6550 
  def __ne__(self, other):
6551 
    return not (self == other)
6552 
 
559 chandransh 6553 
class updatePassword_args:
94 ashish 6554 
  """
6555 
  Attributes:
559 chandransh 6556 
   - userid
594 rajveer 6557 
   - oldPassword
6558 
   - newPassword
94 ashish 6559 
  """
6560 
 
6561 
  thrift_spec = (
6562 
    None, # 0
559 chandransh 6563 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6564 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6565 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6566 
  )
6567 
 
594 rajveer 6568 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6569 
    self.userid = userid
594 rajveer 6570 
    self.oldPassword = oldPassword
6571 
    self.newPassword = newPassword
94 ashish 6572 
 
6573 
  def read(self, iprot):
6574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6576 
      return
6577 
    iprot.readStructBegin()
6578 
    while True:
6579 
      (fname, ftype, fid) = iprot.readFieldBegin()
6580 
      if ftype == TType.STOP:
6581 
        break
6582 
      if fid == 1:
6583 
        if ftype == TType.I64:
559 chandransh 6584 
          self.userid = iprot.readI64();
94 ashish 6585 
        else:
6586 
          iprot.skip(ftype)
6587 
      elif fid == 2:
559 chandransh 6588 
        if ftype == TType.STRING:
594 rajveer 6589 
          self.oldPassword = iprot.readString();
94 ashish 6590 
        else:
6591 
          iprot.skip(ftype)
594 rajveer 6592 
      elif fid == 3:
6593 
        if ftype == TType.STRING:
6594 
          self.newPassword = iprot.readString();
6595 
        else:
6596 
          iprot.skip(ftype)
94 ashish 6597 
      else:
6598 
        iprot.skip(ftype)
6599 
      iprot.readFieldEnd()
6600 
    iprot.readStructEnd()
6601 
 
6602 
  def write(self, oprot):
6603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6605 
      return
559 chandransh 6606 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6607 
    if self.userid is not None:
559 chandransh 6608 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6609 
      oprot.writeI64(self.userid)
94 ashish 6610 
      oprot.writeFieldEnd()
3431 rajveer 6611 
    if self.oldPassword is not None:
594 rajveer 6612 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6613 
      oprot.writeString(self.oldPassword)
94 ashish 6614 
      oprot.writeFieldEnd()
3431 rajveer 6615 
    if self.newPassword is not None:
594 rajveer 6616 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6617 
      oprot.writeString(self.newPassword)
6618 
      oprot.writeFieldEnd()
94 ashish 6619 
    oprot.writeFieldStop()
6620 
    oprot.writeStructEnd()
6621 
 
3431 rajveer 6622 
  def validate(self):
6623 
    return
6624 
 
6625 
 
94 ashish 6626 
  def __repr__(self):
6627 
    L = ['%s=%r' % (key, value)
6628 
      for key, value in self.__dict__.iteritems()]
6629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6630 
 
6631 
  def __eq__(self, other):
6632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6633 
 
6634 
  def __ne__(self, other):
6635 
    return not (self == other)
6636 
 
559 chandransh 6637 
class updatePassword_result:
94 ashish 6638 
  """
6639 
  Attributes:
6640 
   - success
6641 
   - ucx
6642 
  """
6643 
 
6644 
  thrift_spec = (
6645 
    (0, TType.BOOL, 'success', None, None, ), # 0
6646 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6647 
  )
6648 
 
6649 
  def __init__(self, success=None, ucx=None,):
6650 
    self.success = success
6651 
    self.ucx = ucx
6652 
 
6653 
  def read(self, iprot):
6654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6656 
      return
6657 
    iprot.readStructBegin()
6658 
    while True:
6659 
      (fname, ftype, fid) = iprot.readFieldBegin()
6660 
      if ftype == TType.STOP:
6661 
        break
6662 
      if fid == 0:
6663 
        if ftype == TType.BOOL:
6664 
          self.success = iprot.readBool();
6665 
        else:
6666 
          iprot.skip(ftype)
6667 
      elif fid == 1:
6668 
        if ftype == TType.STRUCT:
6669 
          self.ucx = UserContextException()
6670 
          self.ucx.read(iprot)
6671 
        else:
6672 
          iprot.skip(ftype)
6673 
      else:
6674 
        iprot.skip(ftype)
6675 
      iprot.readFieldEnd()
6676 
    iprot.readStructEnd()
6677 
 
6678 
  def write(self, oprot):
6679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6681 
      return
559 chandransh 6682 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6683 
    if self.success is not None:
94 ashish 6684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6685 
      oprot.writeBool(self.success)
6686 
      oprot.writeFieldEnd()
3431 rajveer 6687 
    if self.ucx is not None:
94 ashish 6688 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6689 
      self.ucx.write(oprot)
6690 
      oprot.writeFieldEnd()
6691 
    oprot.writeFieldStop()
6692 
    oprot.writeStructEnd()
6693 
 
3431 rajveer 6694 
  def validate(self):
6695 
    return
6696 
 
6697 
 
94 ashish 6698 
  def __repr__(self):
6699 
    L = ['%s=%r' % (key, value)
6700 
      for key, value in self.__dict__.iteritems()]
6701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6702 
 
6703 
  def __eq__(self, other):
6704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6705 
 
6706 
  def __ne__(self, other):
6707 
    return not (self == other)
6708 
 
581 rajveer 6709 
class forgotPassword_args:
6710 
  """
6711 
  Attributes:
6712 
   - email
884 rajveer 6713 
   - newPassword
581 rajveer 6714 
  """
6715 
 
6716 
  thrift_spec = (
6717 
    None, # 0
6718 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6719 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6720 
  )
6721 
 
884 rajveer 6722 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6723 
    self.email = email
884 rajveer 6724 
    self.newPassword = newPassword
581 rajveer 6725 
 
6726 
  def read(self, iprot):
6727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6729 
      return
6730 
    iprot.readStructBegin()
6731 
    while True:
6732 
      (fname, ftype, fid) = iprot.readFieldBegin()
6733 
      if ftype == TType.STOP:
6734 
        break
6735 
      if fid == 1:
6736 
        if ftype == TType.STRING:
6737 
          self.email = iprot.readString();
6738 
        else:
6739 
          iprot.skip(ftype)
884 rajveer 6740 
      elif fid == 2:
6741 
        if ftype == TType.STRING:
6742 
          self.newPassword = iprot.readString();
6743 
        else:
6744 
          iprot.skip(ftype)
581 rajveer 6745 
      else:
6746 
        iprot.skip(ftype)
6747 
      iprot.readFieldEnd()
6748 
    iprot.readStructEnd()
6749 
 
6750 
  def write(self, oprot):
6751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6753 
      return
6754 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6755 
    if self.email is not None:
581 rajveer 6756 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6757 
      oprot.writeString(self.email)
6758 
      oprot.writeFieldEnd()
3431 rajveer 6759 
    if self.newPassword is not None:
884 rajveer 6760 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6761 
      oprot.writeString(self.newPassword)
6762 
      oprot.writeFieldEnd()
581 rajveer 6763 
    oprot.writeFieldStop()
6764 
    oprot.writeStructEnd()
6765 
 
3431 rajveer 6766 
  def validate(self):
6767 
    return
6768 
 
6769 
 
581 rajveer 6770 
  def __repr__(self):
6771 
    L = ['%s=%r' % (key, value)
6772 
      for key, value in self.__dict__.iteritems()]
6773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6774 
 
6775 
  def __eq__(self, other):
6776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6777 
 
6778 
  def __ne__(self, other):
6779 
    return not (self == other)
6780 
 
6781 
class forgotPassword_result:
6782 
  """
6783 
  Attributes:
6784 
   - success
6785 
   - ucx
6786 
  """
6787 
 
6788 
  thrift_spec = (
6789 
    (0, TType.BOOL, 'success', None, None, ), # 0
6790 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6791 
  )
6792 
 
6793 
  def __init__(self, success=None, ucx=None,):
6794 
    self.success = success
6795 
    self.ucx = ucx
6796 
 
6797 
  def read(self, iprot):
6798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6800 
      return
6801 
    iprot.readStructBegin()
6802 
    while True:
6803 
      (fname, ftype, fid) = iprot.readFieldBegin()
6804 
      if ftype == TType.STOP:
6805 
        break
6806 
      if fid == 0:
6807 
        if ftype == TType.BOOL:
6808 
          self.success = iprot.readBool();
6809 
        else:
6810 
          iprot.skip(ftype)
6811 
      elif fid == 1:
6812 
        if ftype == TType.STRUCT:
6813 
          self.ucx = UserContextException()
6814 
          self.ucx.read(iprot)
6815 
        else:
6816 
          iprot.skip(ftype)
6817 
      else:
6818 
        iprot.skip(ftype)
6819 
      iprot.readFieldEnd()
6820 
    iprot.readStructEnd()
6821 
 
6822 
  def write(self, oprot):
6823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6825 
      return
6826 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6827 
    if self.success is not None:
581 rajveer 6828 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6829 
      oprot.writeBool(self.success)
6830 
      oprot.writeFieldEnd()
3431 rajveer 6831 
    if self.ucx is not None:
581 rajveer 6832 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6833 
      self.ucx.write(oprot)
6834 
      oprot.writeFieldEnd()
6835 
    oprot.writeFieldStop()
6836 
    oprot.writeStructEnd()
6837 
 
3431 rajveer 6838 
  def validate(self):
6839 
    return
6840 
 
6841 
 
581 rajveer 6842 
  def __repr__(self):
6843 
    L = ['%s=%r' % (key, value)
6844 
      for key, value in self.__dict__.iteritems()]
6845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6846 
 
6847 
  def __eq__(self, other):
6848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6849 
 
6850 
  def __ne__(self, other):
6851 
    return not (self == other)
6852 
 
594 rajveer 6853 
class getAllAddressesForUser_args:
6854 
  """
6855 
  Attributes:
6856 
   - userId
6857 
  """
6858 
 
6859 
  thrift_spec = (
6860 
    None, # 0
6861 
    (1, TType.I64, 'userId', None, None, ), # 1
6862 
  )
6863 
 
6864 
  def __init__(self, userId=None,):
6865 
    self.userId = userId
6866 
 
6867 
  def read(self, iprot):
6868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6870 
      return
6871 
    iprot.readStructBegin()
6872 
    while True:
6873 
      (fname, ftype, fid) = iprot.readFieldBegin()
6874 
      if ftype == TType.STOP:
6875 
        break
6876 
      if fid == 1:
6877 
        if ftype == TType.I64:
6878 
          self.userId = iprot.readI64();
6879 
        else:
6880 
          iprot.skip(ftype)
6881 
      else:
6882 
        iprot.skip(ftype)
6883 
      iprot.readFieldEnd()
6884 
    iprot.readStructEnd()
6885 
 
6886 
  def write(self, oprot):
6887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6889 
      return
6890 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6891 
    if self.userId is not None:
594 rajveer 6892 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6893 
      oprot.writeI64(self.userId)
6894 
      oprot.writeFieldEnd()
6895 
    oprot.writeFieldStop()
6896 
    oprot.writeStructEnd()
6897 
 
3431 rajveer 6898 
  def validate(self):
6899 
    return
6900 
 
6901 
 
594 rajveer 6902 
  def __repr__(self):
6903 
    L = ['%s=%r' % (key, value)
6904 
      for key, value in self.__dict__.iteritems()]
6905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6906 
 
6907 
  def __eq__(self, other):
6908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6909 
 
6910 
  def __ne__(self, other):
6911 
    return not (self == other)
6912 
 
6913 
class getAllAddressesForUser_result:
6914 
  """
6915 
  Attributes:
6916 
   - success
6917 
   - ucx
6918 
  """
6919 
 
6920 
  thrift_spec = (
6921 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6922 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6923 
  )
6924 
 
6925 
  def __init__(self, success=None, ucx=None,):
6926 
    self.success = success
6927 
    self.ucx = ucx
6928 
 
6929 
  def read(self, iprot):
6930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6932 
      return
6933 
    iprot.readStructBegin()
6934 
    while True:
6935 
      (fname, ftype, fid) = iprot.readFieldBegin()
6936 
      if ftype == TType.STOP:
6937 
        break
6938 
      if fid == 0:
6939 
        if ftype == TType.LIST:
6940 
          self.success = []
11592 amit.gupta 6941 
          (_etype100, _size97) = iprot.readListBegin()
6942 
          for _i101 in xrange(_size97):
6943 
            _elem102 = Address()
6944 
            _elem102.read(iprot)
6945 
            self.success.append(_elem102)
594 rajveer 6946 
          iprot.readListEnd()
6947 
        else:
6948 
          iprot.skip(ftype)
6949 
      elif fid == 1:
6950 
        if ftype == TType.STRUCT:
6951 
          self.ucx = UserContextException()
6952 
          self.ucx.read(iprot)
6953 
        else:
6954 
          iprot.skip(ftype)
6955 
      else:
6956 
        iprot.skip(ftype)
6957 
      iprot.readFieldEnd()
6958 
    iprot.readStructEnd()
6959 
 
6960 
  def write(self, oprot):
6961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6963 
      return
6964 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 6965 
    if self.success is not None:
594 rajveer 6966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6967 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 6968 
      for iter103 in self.success:
6969 
        iter103.write(oprot)
594 rajveer 6970 
      oprot.writeListEnd()
6971 
      oprot.writeFieldEnd()
3431 rajveer 6972 
    if self.ucx is not None:
594 rajveer 6973 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6974 
      self.ucx.write(oprot)
6975 
      oprot.writeFieldEnd()
6976 
    oprot.writeFieldStop()
6977 
    oprot.writeStructEnd()
6978 
 
3431 rajveer 6979 
  def validate(self):
6980 
    return
6981 
 
6982 
 
594 rajveer 6983 
  def __repr__(self):
6984 
    L = ['%s=%r' % (key, value)
6985 
      for key, value in self.__dict__.iteritems()]
6986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6987 
 
6988 
  def __eq__(self, other):
6989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6990 
 
6991 
  def __ne__(self, other):
6992 
    return not (self == other)
6993 
 
1894 vikas 6994 
class getAddressById_args:
6995 
  """
6996 
  Attributes:
6997 
   - addressId
6998 
  """
6999 
 
7000 
  thrift_spec = (
7001 
    None, # 0
7002 
    (1, TType.I64, 'addressId', None, None, ), # 1
7003 
  )
7004 
 
7005 
  def __init__(self, addressId=None,):
7006 
    self.addressId = addressId
7007 
 
7008 
  def read(self, iprot):
7009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7011 
      return
7012 
    iprot.readStructBegin()
7013 
    while True:
7014 
      (fname, ftype, fid) = iprot.readFieldBegin()
7015 
      if ftype == TType.STOP:
7016 
        break
7017 
      if fid == 1:
7018 
        if ftype == TType.I64:
7019 
          self.addressId = iprot.readI64();
7020 
        else:
7021 
          iprot.skip(ftype)
7022 
      else:
7023 
        iprot.skip(ftype)
7024 
      iprot.readFieldEnd()
7025 
    iprot.readStructEnd()
7026 
 
7027 
  def write(self, oprot):
7028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7030 
      return
7031 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7032 
    if self.addressId is not None:
1894 vikas 7033 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7034 
      oprot.writeI64(self.addressId)
7035 
      oprot.writeFieldEnd()
7036 
    oprot.writeFieldStop()
7037 
    oprot.writeStructEnd()
7038 
 
3431 rajveer 7039 
  def validate(self):
7040 
    return
7041 
 
7042 
 
1894 vikas 7043 
  def __repr__(self):
7044 
    L = ['%s=%r' % (key, value)
7045 
      for key, value in self.__dict__.iteritems()]
7046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7047 
 
7048 
  def __eq__(self, other):
7049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7050 
 
7051 
  def __ne__(self, other):
7052 
    return not (self == other)
7053 
 
7054 
class getAddressById_result:
7055 
  """
7056 
  Attributes:
7057 
   - success
7058 
   - ucx
7059 
  """
7060 
 
7061 
  thrift_spec = (
7062 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7063 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7064 
  )
7065 
 
7066 
  def __init__(self, success=None, ucx=None,):
7067 
    self.success = success
7068 
    self.ucx = ucx
7069 
 
7070 
  def read(self, iprot):
7071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7073 
      return
7074 
    iprot.readStructBegin()
7075 
    while True:
7076 
      (fname, ftype, fid) = iprot.readFieldBegin()
7077 
      if ftype == TType.STOP:
7078 
        break
7079 
      if fid == 0:
7080 
        if ftype == TType.STRUCT:
7081 
          self.success = Address()
7082 
          self.success.read(iprot)
7083 
        else:
7084 
          iprot.skip(ftype)
7085 
      elif fid == 1:
7086 
        if ftype == TType.STRUCT:
7087 
          self.ucx = UserContextException()
7088 
          self.ucx.read(iprot)
7089 
        else:
7090 
          iprot.skip(ftype)
7091 
      else:
7092 
        iprot.skip(ftype)
7093 
      iprot.readFieldEnd()
7094 
    iprot.readStructEnd()
7095 
 
7096 
  def write(self, oprot):
7097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7099 
      return
7100 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7101 
    if self.success is not None:
1894 vikas 7102 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7103 
      self.success.write(oprot)
7104 
      oprot.writeFieldEnd()
3431 rajveer 7105 
    if self.ucx is not None:
1894 vikas 7106 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7107 
      self.ucx.write(oprot)
7108 
      oprot.writeFieldEnd()
7109 
    oprot.writeFieldStop()
7110 
    oprot.writeStructEnd()
7111 
 
3431 rajveer 7112 
  def validate(self):
7113 
    return
7114 
 
7115 
 
1894 vikas 7116 
  def __repr__(self):
7117 
    L = ['%s=%r' % (key, value)
7118 
      for key, value in self.__dict__.iteritems()]
7119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7120 
 
7121 
  def __eq__(self, other):
7122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7123 
 
7124 
  def __ne__(self, other):
7125 
    return not (self == other)
7126 
 
594 rajveer 7127 
class getDefaultAddressId_args:
7128 
  """
7129 
  Attributes:
7130 
   - userId
7131 
  """
7132 
 
7133 
  thrift_spec = (
7134 
    None, # 0
7135 
    (1, TType.I64, 'userId', None, None, ), # 1
7136 
  )
7137 
 
7138 
  def __init__(self, userId=None,):
7139 
    self.userId = userId
7140 
 
7141 
  def read(self, iprot):
7142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7144 
      return
7145 
    iprot.readStructBegin()
7146 
    while True:
7147 
      (fname, ftype, fid) = iprot.readFieldBegin()
7148 
      if ftype == TType.STOP:
7149 
        break
7150 
      if fid == 1:
7151 
        if ftype == TType.I64:
7152 
          self.userId = iprot.readI64();
7153 
        else:
7154 
          iprot.skip(ftype)
7155 
      else:
7156 
        iprot.skip(ftype)
7157 
      iprot.readFieldEnd()
7158 
    iprot.readStructEnd()
7159 
 
7160 
  def write(self, oprot):
7161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7163 
      return
7164 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7165 
    if self.userId is not None:
594 rajveer 7166 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7167 
      oprot.writeI64(self.userId)
7168 
      oprot.writeFieldEnd()
7169 
    oprot.writeFieldStop()
7170 
    oprot.writeStructEnd()
7171 
 
3431 rajveer 7172 
  def validate(self):
7173 
    return
7174 
 
7175 
 
594 rajveer 7176 
  def __repr__(self):
7177 
    L = ['%s=%r' % (key, value)
7178 
      for key, value in self.__dict__.iteritems()]
7179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7180 
 
7181 
  def __eq__(self, other):
7182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7183 
 
7184 
  def __ne__(self, other):
7185 
    return not (self == other)
7186 
 
7187 
class getDefaultAddressId_result:
7188 
  """
7189 
  Attributes:
7190 
   - success
7191 
   - ucx
7192 
  """
7193 
 
7194 
  thrift_spec = (
7195 
    (0, TType.I64, 'success', None, None, ), # 0
7196 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7197 
  )
7198 
 
7199 
  def __init__(self, success=None, ucx=None,):
7200 
    self.success = success
7201 
    self.ucx = ucx
7202 
 
7203 
  def read(self, iprot):
7204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7206 
      return
7207 
    iprot.readStructBegin()
7208 
    while True:
7209 
      (fname, ftype, fid) = iprot.readFieldBegin()
7210 
      if ftype == TType.STOP:
7211 
        break
7212 
      if fid == 0:
7213 
        if ftype == TType.I64:
7214 
          self.success = iprot.readI64();
7215 
        else:
7216 
          iprot.skip(ftype)
7217 
      elif fid == 1:
7218 
        if ftype == TType.STRUCT:
7219 
          self.ucx = UserContextException()
7220 
          self.ucx.read(iprot)
7221 
        else:
7222 
          iprot.skip(ftype)
7223 
      else:
7224 
        iprot.skip(ftype)
7225 
      iprot.readFieldEnd()
7226 
    iprot.readStructEnd()
7227 
 
7228 
  def write(self, oprot):
7229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7231 
      return
7232 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7233 
    if self.success is not None:
594 rajveer 7234 
      oprot.writeFieldBegin('success', TType.I64, 0)
7235 
      oprot.writeI64(self.success)
7236 
      oprot.writeFieldEnd()
3431 rajveer 7237 
    if self.ucx is not None:
594 rajveer 7238 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7239 
      self.ucx.write(oprot)
7240 
      oprot.writeFieldEnd()
7241 
    oprot.writeFieldStop()
7242 
    oprot.writeStructEnd()
7243 
 
3431 rajveer 7244 
  def validate(self):
7245 
    return
7246 
 
7247 
 
594 rajveer 7248 
  def __repr__(self):
7249 
    L = ['%s=%r' % (key, value)
7250 
      for key, value in self.__dict__.iteritems()]
7251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7252 
 
7253 
  def __eq__(self, other):
7254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7255 
 
7256 
  def __ne__(self, other):
7257 
    return not (self == other)
7258 
 
785 rajveer 7259 
class getDefaultPincode_args:
7260 
  """
7261 
  Attributes:
7262 
   - userId
7263 
  """
7264 
 
7265 
  thrift_spec = (
7266 
    None, # 0
7267 
    (1, TType.I64, 'userId', None, None, ), # 1
7268 
  )
7269 
 
7270 
  def __init__(self, userId=None,):
7271 
    self.userId = userId
7272 
 
7273 
  def read(self, iprot):
7274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7276 
      return
7277 
    iprot.readStructBegin()
7278 
    while True:
7279 
      (fname, ftype, fid) = iprot.readFieldBegin()
7280 
      if ftype == TType.STOP:
7281 
        break
7282 
      if fid == 1:
7283 
        if ftype == TType.I64:
7284 
          self.userId = iprot.readI64();
7285 
        else:
7286 
          iprot.skip(ftype)
7287 
      else:
7288 
        iprot.skip(ftype)
7289 
      iprot.readFieldEnd()
7290 
    iprot.readStructEnd()
7291 
 
7292 
  def write(self, oprot):
7293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7295 
      return
7296 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7297 
    if self.userId is not None:
785 rajveer 7298 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7299 
      oprot.writeI64(self.userId)
7300 
      oprot.writeFieldEnd()
7301 
    oprot.writeFieldStop()
7302 
    oprot.writeStructEnd()
7303 
 
3431 rajveer 7304 
  def validate(self):
7305 
    return
7306 
 
7307 
 
785 rajveer 7308 
  def __repr__(self):
7309 
    L = ['%s=%r' % (key, value)
7310 
      for key, value in self.__dict__.iteritems()]
7311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7312 
 
7313 
  def __eq__(self, other):
7314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7315 
 
7316 
  def __ne__(self, other):
7317 
    return not (self == other)
7318 
 
7319 
class getDefaultPincode_result:
7320 
  """
7321 
  Attributes:
7322 
   - success
7323 
   - ucx
7324 
  """
7325 
 
7326 
  thrift_spec = (
7327 
    (0, TType.STRING, 'success', None, None, ), # 0
7328 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7329 
  )
7330 
 
7331 
  def __init__(self, success=None, ucx=None,):
7332 
    self.success = success
7333 
    self.ucx = ucx
7334 
 
7335 
  def read(self, iprot):
7336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7338 
      return
7339 
    iprot.readStructBegin()
7340 
    while True:
7341 
      (fname, ftype, fid) = iprot.readFieldBegin()
7342 
      if ftype == TType.STOP:
7343 
        break
7344 
      if fid == 0:
7345 
        if ftype == TType.STRING:
7346 
          self.success = iprot.readString();
7347 
        else:
7348 
          iprot.skip(ftype)
7349 
      elif fid == 1:
7350 
        if ftype == TType.STRUCT:
7351 
          self.ucx = UserContextException()
7352 
          self.ucx.read(iprot)
7353 
        else:
7354 
          iprot.skip(ftype)
7355 
      else:
7356 
        iprot.skip(ftype)
7357 
      iprot.readFieldEnd()
7358 
    iprot.readStructEnd()
7359 
 
7360 
  def write(self, oprot):
7361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7363 
      return
7364 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7365 
    if self.success is not None:
785 rajveer 7366 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7367 
      oprot.writeString(self.success)
7368 
      oprot.writeFieldEnd()
3431 rajveer 7369 
    if self.ucx is not None:
785 rajveer 7370 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7371 
      self.ucx.write(oprot)
7372 
      oprot.writeFieldEnd()
7373 
    oprot.writeFieldStop()
7374 
    oprot.writeStructEnd()
7375 
 
3431 rajveer 7376 
  def validate(self):
7377 
    return
7378 
 
7379 
 
785 rajveer 7380 
  def __repr__(self):
7381 
    L = ['%s=%r' % (key, value)
7382 
      for key, value in self.__dict__.iteritems()]
7383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7384 
 
7385 
  def __eq__(self, other):
7386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7387 
 
7388 
  def __ne__(self, other):
7389 
    return not (self == other)
7390 
 
1274 varun.gupt 7391 
class saveUserCommunication_args:
7392 
  """
7393 
  Attributes:
7394 
   - userId
7395 
   - replyTo
7396 
   - communicationType
7397 
   - orderId
7398 
   - airwaybillNo
7399 
   - productName
7400 
   - subject
7401 
   - message
7402 
  """
7403 
 
7404 
  thrift_spec = (
7405 
    None, # 0
7406 
    (1, TType.I64, 'userId', None, None, ), # 1
7407 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7408 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7409 
    (4, TType.I64, 'orderId', None, None, ), # 4
7410 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7411 
    (6, TType.STRING, 'productName', None, None, ), # 6
7412 
    (7, TType.STRING, 'subject', None, None, ), # 7
7413 
    (8, TType.STRING, 'message', None, None, ), # 8
7414 
  )
7415 
 
7416 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7417 
    self.userId = userId
7418 
    self.replyTo = replyTo
7419 
    self.communicationType = communicationType
7420 
    self.orderId = orderId
7421 
    self.airwaybillNo = airwaybillNo
7422 
    self.productName = productName
7423 
    self.subject = subject
7424 
    self.message = message
7425 
 
7426 
  def read(self, iprot):
7427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7429 
      return
7430 
    iprot.readStructBegin()
7431 
    while True:
7432 
      (fname, ftype, fid) = iprot.readFieldBegin()
7433 
      if ftype == TType.STOP:
7434 
        break
7435 
      if fid == 1:
7436 
        if ftype == TType.I64:
7437 
          self.userId = iprot.readI64();
7438 
        else:
7439 
          iprot.skip(ftype)
7440 
      elif fid == 2:
7441 
        if ftype == TType.STRING:
7442 
          self.replyTo = iprot.readString();
7443 
        else:
7444 
          iprot.skip(ftype)
7445 
      elif fid == 3:
7446 
        if ftype == TType.I64:
7447 
          self.communicationType = iprot.readI64();
7448 
        else:
7449 
          iprot.skip(ftype)
7450 
      elif fid == 4:
7451 
        if ftype == TType.I64:
7452 
          self.orderId = iprot.readI64();
7453 
        else:
7454 
          iprot.skip(ftype)
7455 
      elif fid == 5:
7456 
        if ftype == TType.STRING:
7457 
          self.airwaybillNo = iprot.readString();
7458 
        else:
7459 
          iprot.skip(ftype)
7460 
      elif fid == 6:
7461 
        if ftype == TType.STRING:
7462 
          self.productName = iprot.readString();
7463 
        else:
7464 
          iprot.skip(ftype)
7465 
      elif fid == 7:
7466 
        if ftype == TType.STRING:
7467 
          self.subject = iprot.readString();
7468 
        else:
7469 
          iprot.skip(ftype)
7470 
      elif fid == 8:
7471 
        if ftype == TType.STRING:
7472 
          self.message = iprot.readString();
7473 
        else:
7474 
          iprot.skip(ftype)
7475 
      else:
7476 
        iprot.skip(ftype)
7477 
      iprot.readFieldEnd()
7478 
    iprot.readStructEnd()
7479 
 
7480 
  def write(self, oprot):
7481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7483 
      return
7484 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7485 
    if self.userId is not None:
1274 varun.gupt 7486 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7487 
      oprot.writeI64(self.userId)
7488 
      oprot.writeFieldEnd()
3431 rajveer 7489 
    if self.replyTo is not None:
1274 varun.gupt 7490 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7491 
      oprot.writeString(self.replyTo)
7492 
      oprot.writeFieldEnd()
3431 rajveer 7493 
    if self.communicationType is not None:
1274 varun.gupt 7494 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7495 
      oprot.writeI64(self.communicationType)
7496 
      oprot.writeFieldEnd()
3431 rajveer 7497 
    if self.orderId is not None:
1274 varun.gupt 7498 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7499 
      oprot.writeI64(self.orderId)
7500 
      oprot.writeFieldEnd()
3431 rajveer 7501 
    if self.airwaybillNo is not None:
1274 varun.gupt 7502 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7503 
      oprot.writeString(self.airwaybillNo)
7504 
      oprot.writeFieldEnd()
3431 rajveer 7505 
    if self.productName is not None:
1274 varun.gupt 7506 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7507 
      oprot.writeString(self.productName)
7508 
      oprot.writeFieldEnd()
3431 rajveer 7509 
    if self.subject is not None:
1274 varun.gupt 7510 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7511 
      oprot.writeString(self.subject)
7512 
      oprot.writeFieldEnd()
3431 rajveer 7513 
    if self.message is not None:
1274 varun.gupt 7514 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7515 
      oprot.writeString(self.message)
7516 
      oprot.writeFieldEnd()
7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
3431 rajveer 7520 
  def validate(self):
7521 
    return
7522 
 
7523 
 
1274 varun.gupt 7524 
  def __repr__(self):
7525 
    L = ['%s=%r' % (key, value)
7526 
      for key, value in self.__dict__.iteritems()]
7527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7528 
 
7529 
  def __eq__(self, other):
7530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7531 
 
7532 
  def __ne__(self, other):
7533 
    return not (self == other)
7534 
 
7535 
class saveUserCommunication_result:
7536 
  """
7537 
  Attributes:
7538 
   - success
7539 
   - ucx
7540 
  """
7541 
 
7542 
  thrift_spec = (
7543 
    (0, TType.BOOL, 'success', None, None, ), # 0
7544 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7545 
  )
7546 
 
7547 
  def __init__(self, success=None, ucx=None,):
7548 
    self.success = success
7549 
    self.ucx = ucx
7550 
 
7551 
  def read(self, iprot):
7552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7554 
      return
7555 
    iprot.readStructBegin()
7556 
    while True:
7557 
      (fname, ftype, fid) = iprot.readFieldBegin()
7558 
      if ftype == TType.STOP:
7559 
        break
7560 
      if fid == 0:
7561 
        if ftype == TType.BOOL:
7562 
          self.success = iprot.readBool();
7563 
        else:
7564 
          iprot.skip(ftype)
7565 
      elif fid == 1:
7566 
        if ftype == TType.STRUCT:
7567 
          self.ucx = UserCommunicationException()
7568 
          self.ucx.read(iprot)
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      else:
7572 
        iprot.skip(ftype)
7573 
      iprot.readFieldEnd()
7574 
    iprot.readStructEnd()
7575 
 
7576 
  def write(self, oprot):
7577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7579 
      return
7580 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7581 
    if self.success is not None:
1274 varun.gupt 7582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7583 
      oprot.writeBool(self.success)
7584 
      oprot.writeFieldEnd()
3431 rajveer 7585 
    if self.ucx is not None:
1274 varun.gupt 7586 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7587 
      self.ucx.write(oprot)
7588 
      oprot.writeFieldEnd()
7589 
    oprot.writeFieldStop()
7590 
    oprot.writeStructEnd()
7591 
 
3431 rajveer 7592 
  def validate(self):
7593 
    return
7594 
 
7595 
 
1274 varun.gupt 7596 
  def __repr__(self):
7597 
    L = ['%s=%r' % (key, value)
7598 
      for key, value in self.__dict__.iteritems()]
7599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7600 
 
7601 
  def __eq__(self, other):
7602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7603 
 
7604 
  def __ne__(self, other):
7605 
    return not (self == other)
7606 
 
1590 varun.gupt 7607 
class getUserCommunicationById_args:
7608 
  """
7609 
  Attributes:
7610 
   - id
7611 
  """
7612 
 
7613 
  thrift_spec = (
7614 
    None, # 0
7615 
    (1, TType.I64, 'id', None, None, ), # 1
7616 
  )
7617 
 
7618 
  def __init__(self, id=None,):
7619 
    self.id = id
7620 
 
7621 
  def read(self, iprot):
7622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7624 
      return
7625 
    iprot.readStructBegin()
7626 
    while True:
7627 
      (fname, ftype, fid) = iprot.readFieldBegin()
7628 
      if ftype == TType.STOP:
7629 
        break
7630 
      if fid == 1:
7631 
        if ftype == TType.I64:
7632 
          self.id = iprot.readI64();
7633 
        else:
7634 
          iprot.skip(ftype)
7635 
      else:
7636 
        iprot.skip(ftype)
7637 
      iprot.readFieldEnd()
7638 
    iprot.readStructEnd()
7639 
 
7640 
  def write(self, oprot):
7641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7643 
      return
7644 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7645 
    if self.id is not None:
1590 varun.gupt 7646 
      oprot.writeFieldBegin('id', TType.I64, 1)
7647 
      oprot.writeI64(self.id)
7648 
      oprot.writeFieldEnd()
7649 
    oprot.writeFieldStop()
7650 
    oprot.writeStructEnd()
7651 
 
3431 rajveer 7652 
  def validate(self):
7653 
    return
7654 
 
7655 
 
1590 varun.gupt 7656 
  def __repr__(self):
7657 
    L = ['%s=%r' % (key, value)
7658 
      for key, value in self.__dict__.iteritems()]
7659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7660 
 
7661 
  def __eq__(self, other):
7662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7663 
 
7664 
  def __ne__(self, other):
7665 
    return not (self == other)
7666 
 
7667 
class getUserCommunicationById_result:
7668 
  """
7669 
  Attributes:
7670 
   - success
7671 
   - ucx
7672 
  """
7673 
 
7674 
  thrift_spec = (
7675 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7676 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7677 
  )
7678 
 
7679 
  def __init__(self, success=None, ucx=None,):
7680 
    self.success = success
7681 
    self.ucx = ucx
7682 
 
7683 
  def read(self, iprot):
7684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7686 
      return
7687 
    iprot.readStructBegin()
7688 
    while True:
7689 
      (fname, ftype, fid) = iprot.readFieldBegin()
7690 
      if ftype == TType.STOP:
7691 
        break
7692 
      if fid == 0:
7693 
        if ftype == TType.STRUCT:
7694 
          self.success = UserCommunication()
7695 
          self.success.read(iprot)
7696 
        else:
7697 
          iprot.skip(ftype)
7698 
      elif fid == 1:
7699 
        if ftype == TType.STRUCT:
7700 
          self.ucx = UserCommunicationException()
7701 
          self.ucx.read(iprot)
7702 
        else:
7703 
          iprot.skip(ftype)
7704 
      else:
7705 
        iprot.skip(ftype)
7706 
      iprot.readFieldEnd()
7707 
    iprot.readStructEnd()
7708 
 
7709 
  def write(self, oprot):
7710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7712 
      return
7713 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7714 
    if self.success is not None:
1590 varun.gupt 7715 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7716 
      self.success.write(oprot)
7717 
      oprot.writeFieldEnd()
3431 rajveer 7718 
    if self.ucx is not None:
1590 varun.gupt 7719 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7720 
      self.ucx.write(oprot)
7721 
      oprot.writeFieldEnd()
7722 
    oprot.writeFieldStop()
7723 
    oprot.writeStructEnd()
7724 
 
3431 rajveer 7725 
  def validate(self):
7726 
    return
7727 
 
7728 
 
1590 varun.gupt 7729 
  def __repr__(self):
7730 
    L = ['%s=%r' % (key, value)
7731 
      for key, value in self.__dict__.iteritems()]
7732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7733 
 
7734 
  def __eq__(self, other):
7735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7736 
 
7737 
  def __ne__(self, other):
7738 
    return not (self == other)
7739 
 
7740 
class getUserCommunicationByUser_args:
7741 
  """
7742 
  Attributes:
7743 
   - userId
7744 
  """
7745 
 
7746 
  thrift_spec = (
7747 
    None, # 0
7748 
    (1, TType.I64, 'userId', None, None, ), # 1
7749 
  )
7750 
 
7751 
  def __init__(self, userId=None,):
7752 
    self.userId = userId
7753 
 
7754 
  def read(self, iprot):
7755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7757 
      return
7758 
    iprot.readStructBegin()
7759 
    while True:
7760 
      (fname, ftype, fid) = iprot.readFieldBegin()
7761 
      if ftype == TType.STOP:
7762 
        break
7763 
      if fid == 1:
7764 
        if ftype == TType.I64:
7765 
          self.userId = iprot.readI64();
7766 
        else:
7767 
          iprot.skip(ftype)
7768 
      else:
7769 
        iprot.skip(ftype)
7770 
      iprot.readFieldEnd()
7771 
    iprot.readStructEnd()
7772 
 
7773 
  def write(self, oprot):
7774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7776 
      return
7777 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7778 
    if self.userId is not None:
1590 varun.gupt 7779 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7780 
      oprot.writeI64(self.userId)
7781 
      oprot.writeFieldEnd()
7782 
    oprot.writeFieldStop()
7783 
    oprot.writeStructEnd()
7784 
 
3431 rajveer 7785 
  def validate(self):
7786 
    return
7787 
 
7788 
 
1590 varun.gupt 7789 
  def __repr__(self):
7790 
    L = ['%s=%r' % (key, value)
7791 
      for key, value in self.__dict__.iteritems()]
7792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7793 
 
7794 
  def __eq__(self, other):
7795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7796 
 
7797 
  def __ne__(self, other):
7798 
    return not (self == other)
7799 
 
7800 
class getUserCommunicationByUser_result:
7801 
  """
7802 
  Attributes:
7803 
   - success
7804 
   - ucx
7805 
  """
7806 
 
7807 
  thrift_spec = (
7808 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7809 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7810 
  )
7811 
 
7812 
  def __init__(self, success=None, ucx=None,):
7813 
    self.success = success
7814 
    self.ucx = ucx
7815 
 
7816 
  def read(self, iprot):
7817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7819 
      return
7820 
    iprot.readStructBegin()
7821 
    while True:
7822 
      (fname, ftype, fid) = iprot.readFieldBegin()
7823 
      if ftype == TType.STOP:
7824 
        break
7825 
      if fid == 0:
7826 
        if ftype == TType.LIST:
7827 
          self.success = []
11592 amit.gupta 7828 
          (_etype107, _size104) = iprot.readListBegin()
7829 
          for _i108 in xrange(_size104):
7830 
            _elem109 = UserCommunication()
7831 
            _elem109.read(iprot)
7832 
            self.success.append(_elem109)
1590 varun.gupt 7833 
          iprot.readListEnd()
7834 
        else:
7835 
          iprot.skip(ftype)
7836 
      elif fid == 1:
7837 
        if ftype == TType.STRUCT:
7838 
          self.ucx = UserCommunicationException()
7839 
          self.ucx.read(iprot)
7840 
        else:
7841 
          iprot.skip(ftype)
7842 
      else:
7843 
        iprot.skip(ftype)
7844 
      iprot.readFieldEnd()
7845 
    iprot.readStructEnd()
7846 
 
7847 
  def write(self, oprot):
7848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7850 
      return
7851 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7852 
    if self.success is not None:
1590 varun.gupt 7853 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7854 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7855 
      for iter110 in self.success:
7856 
        iter110.write(oprot)
1590 varun.gupt 7857 
      oprot.writeListEnd()
7858 
      oprot.writeFieldEnd()
3431 rajveer 7859 
    if self.ucx is not None:
1590 varun.gupt 7860 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7861 
      self.ucx.write(oprot)
7862 
      oprot.writeFieldEnd()
7863 
    oprot.writeFieldStop()
7864 
    oprot.writeStructEnd()
7865 
 
3431 rajveer 7866 
  def validate(self):
7867 
    return
7868 
 
7869 
 
1590 varun.gupt 7870 
  def __repr__(self):
7871 
    L = ['%s=%r' % (key, value)
7872 
      for key, value in self.__dict__.iteritems()]
7873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7874 
 
7875 
  def __eq__(self, other):
7876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7877 
 
7878 
  def __ne__(self, other):
7879 
    return not (self == other)
7880 
 
7881 
class getAllUserCommunications_args:
7882 
 
7883 
  thrift_spec = (
7884 
  )
7885 
 
7886 
  def read(self, iprot):
7887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7889 
      return
7890 
    iprot.readStructBegin()
7891 
    while True:
7892 
      (fname, ftype, fid) = iprot.readFieldBegin()
7893 
      if ftype == TType.STOP:
7894 
        break
7895 
      else:
7896 
        iprot.skip(ftype)
7897 
      iprot.readFieldEnd()
7898 
    iprot.readStructEnd()
7899 
 
7900 
  def write(self, oprot):
7901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7903 
      return
7904 
    oprot.writeStructBegin('getAllUserCommunications_args')
7905 
    oprot.writeFieldStop()
7906 
    oprot.writeStructEnd()
7907 
 
3431 rajveer 7908 
  def validate(self):
7909 
    return
7910 
 
7911 
 
1590 varun.gupt 7912 
  def __repr__(self):
7913 
    L = ['%s=%r' % (key, value)
7914 
      for key, value in self.__dict__.iteritems()]
7915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7916 
 
7917 
  def __eq__(self, other):
7918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7919 
 
7920 
  def __ne__(self, other):
7921 
    return not (self == other)
7922 
 
7923 
class getAllUserCommunications_result:
7924 
  """
7925 
  Attributes:
7926 
   - success
7927 
   - ucx
7928 
  """
7929 
 
7930 
  thrift_spec = (
7931 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7932 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7933 
  )
7934 
 
7935 
  def __init__(self, success=None, ucx=None,):
7936 
    self.success = success
7937 
    self.ucx = ucx
7938 
 
7939 
  def read(self, iprot):
7940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7942 
      return
7943 
    iprot.readStructBegin()
7944 
    while True:
7945 
      (fname, ftype, fid) = iprot.readFieldBegin()
7946 
      if ftype == TType.STOP:
7947 
        break
7948 
      if fid == 0:
7949 
        if ftype == TType.LIST:
7950 
          self.success = []
11592 amit.gupta 7951 
          (_etype114, _size111) = iprot.readListBegin()
7952 
          for _i115 in xrange(_size111):
7953 
            _elem116 = UserCommunication()
7954 
            _elem116.read(iprot)
7955 
            self.success.append(_elem116)
1590 varun.gupt 7956 
          iprot.readListEnd()
7957 
        else:
7958 
          iprot.skip(ftype)
7959 
      elif fid == 1:
7960 
        if ftype == TType.STRUCT:
7961 
          self.ucx = UserCommunicationException()
7962 
          self.ucx.read(iprot)
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('getAllUserCommunications_result')
3431 rajveer 7975 
    if self.success is not None:
1590 varun.gupt 7976 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7977 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7978 
      for iter117 in self.success:
7979 
        iter117.write(oprot)
1590 varun.gupt 7980 
      oprot.writeListEnd()
7981 
      oprot.writeFieldEnd()
3431 rajveer 7982 
    if self.ucx is not None:
1590 varun.gupt 7983 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7984 
      self.ucx.write(oprot)
7985 
      oprot.writeFieldEnd()
7986 
    oprot.writeFieldStop()
7987 
    oprot.writeStructEnd()
7988 
 
3431 rajveer 7989 
  def validate(self):
7990 
    return
7991 
 
7992 
 
1590 varun.gupt 7993 
  def __repr__(self):
7994 
    L = ['%s=%r' % (key, value)
7995 
      for key, value in self.__dict__.iteritems()]
7996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7997 
 
7998 
  def __eq__(self, other):
7999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8000 
 
8001 
  def __ne__(self, other):
8002 
    return not (self == other)
8003 
 
5407 amar.kumar 8004 
class removeUserCommunication_args:
8005 
  """
8006 
  Attributes:
8007 
   - id
8008 
  """
8009 
 
8010 
  thrift_spec = (
8011 
    None, # 0
8012 
    (1, TType.I64, 'id', None, None, ), # 1
8013 
  )
8014 
 
8015 
  def __init__(self, id=None,):
8016 
    self.id = id
8017 
 
8018 
  def read(self, iprot):
8019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8021 
      return
8022 
    iprot.readStructBegin()
8023 
    while True:
8024 
      (fname, ftype, fid) = iprot.readFieldBegin()
8025 
      if ftype == TType.STOP:
8026 
        break
8027 
      if fid == 1:
8028 
        if ftype == TType.I64:
8029 
          self.id = iprot.readI64();
8030 
        else:
8031 
          iprot.skip(ftype)
8032 
      else:
8033 
        iprot.skip(ftype)
8034 
      iprot.readFieldEnd()
8035 
    iprot.readStructEnd()
8036 
 
8037 
  def write(self, oprot):
8038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8040 
      return
8041 
    oprot.writeStructBegin('removeUserCommunication_args')
8042 
    if self.id is not None:
8043 
      oprot.writeFieldBegin('id', TType.I64, 1)
8044 
      oprot.writeI64(self.id)
8045 
      oprot.writeFieldEnd()
8046 
    oprot.writeFieldStop()
8047 
    oprot.writeStructEnd()
8048 
 
8049 
  def validate(self):
8050 
    return
8051 
 
8052 
 
8053 
  def __repr__(self):
8054 
    L = ['%s=%r' % (key, value)
8055 
      for key, value in self.__dict__.iteritems()]
8056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8057 
 
8058 
  def __eq__(self, other):
8059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8060 
 
8061 
  def __ne__(self, other):
8062 
    return not (self == other)
8063 
 
8064 
class removeUserCommunication_result:
8065 
  """
8066 
  Attributes:
8067 
   - ucx
8068 
  """
8069 
 
8070 
  thrift_spec = (
8071 
    None, # 0
8072 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8073 
  )
8074 
 
8075 
  def __init__(self, ucx=None,):
8076 
    self.ucx = ucx
8077 
 
8078 
  def read(self, iprot):
8079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8081 
      return
8082 
    iprot.readStructBegin()
8083 
    while True:
8084 
      (fname, ftype, fid) = iprot.readFieldBegin()
8085 
      if ftype == TType.STOP:
8086 
        break
8087 
      if fid == 1:
8088 
        if ftype == TType.STRUCT:
8089 
          self.ucx = UserCommunicationException()
8090 
          self.ucx.read(iprot)
8091 
        else:
8092 
          iprot.skip(ftype)
8093 
      else:
8094 
        iprot.skip(ftype)
8095 
      iprot.readFieldEnd()
8096 
    iprot.readStructEnd()
8097 
 
8098 
  def write(self, oprot):
8099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8101 
      return
8102 
    oprot.writeStructBegin('removeUserCommunication_result')
8103 
    if self.ucx is not None:
8104 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8105 
      self.ucx.write(oprot)
8106 
      oprot.writeFieldEnd()
8107 
    oprot.writeFieldStop()
8108 
    oprot.writeStructEnd()
8109 
 
8110 
  def validate(self):
8111 
    return
8112 
 
8113 
 
8114 
  def __repr__(self):
8115 
    L = ['%s=%r' % (key, value)
8116 
      for key, value in self.__dict__.iteritems()]
8117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8118 
 
8119 
  def __eq__(self, other):
8120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8121 
 
8122 
  def __ne__(self, other):
8123 
    return not (self == other)
8124 
 
1845 vikas 8125 
class createMasterAffiliate_args:
8126 
  """
8127 
  Attributes:
8128 
   - name
1859 vikas 8129 
   - addedOn
1845 vikas 8130 
  """
8131 
 
8132 
  thrift_spec = (
8133 
    None, # 0
8134 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8135 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8136 
  )
8137 
 
1859 vikas 8138 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8139 
    self.name = name
1859 vikas 8140 
    self.addedOn = addedOn
1845 vikas 8141 
 
8142 
  def read(self, iprot):
8143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8145 
      return
8146 
    iprot.readStructBegin()
8147 
    while True:
8148 
      (fname, ftype, fid) = iprot.readFieldBegin()
8149 
      if ftype == TType.STOP:
8150 
        break
8151 
      if fid == 1:
8152 
        if ftype == TType.STRING:
8153 
          self.name = iprot.readString();
8154 
        else:
8155 
          iprot.skip(ftype)
1859 vikas 8156 
      elif fid == 2:
8157 
        if ftype == TType.I64:
8158 
          self.addedOn = iprot.readI64();
8159 
        else:
8160 
          iprot.skip(ftype)
1845 vikas 8161 
      else:
8162 
        iprot.skip(ftype)
8163 
      iprot.readFieldEnd()
8164 
    iprot.readStructEnd()
8165 
 
8166 
  def write(self, oprot):
8167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8169 
      return
8170 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8171 
    if self.name is not None:
1845 vikas 8172 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8173 
      oprot.writeString(self.name)
8174 
      oprot.writeFieldEnd()
3431 rajveer 8175 
    if self.addedOn is not None:
1859 vikas 8176 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8177 
      oprot.writeI64(self.addedOn)
8178 
      oprot.writeFieldEnd()
1845 vikas 8179 
    oprot.writeFieldStop()
8180 
    oprot.writeStructEnd()
8181 
 
3431 rajveer 8182 
  def validate(self):
8183 
    return
8184 
 
8185 
 
1845 vikas 8186 
  def __repr__(self):
8187 
    L = ['%s=%r' % (key, value)
8188 
      for key, value in self.__dict__.iteritems()]
8189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8190 
 
8191 
  def __eq__(self, other):
8192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8193 
 
8194 
  def __ne__(self, other):
8195 
    return not (self == other)
8196 
 
8197 
class createMasterAffiliate_result:
8198 
  """
8199 
  Attributes:
8200 
   - success
8201 
   - utx
8202 
  """
8203 
 
8204 
  thrift_spec = (
8205 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8206 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8207 
  )
8208 
 
8209 
  def __init__(self, success=None, utx=None,):
8210 
    self.success = success
8211 
    self.utx = utx
8212 
 
8213 
  def read(self, iprot):
8214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8216 
      return
8217 
    iprot.readStructBegin()
8218 
    while True:
8219 
      (fname, ftype, fid) = iprot.readFieldBegin()
8220 
      if ftype == TType.STOP:
8221 
        break
8222 
      if fid == 0:
8223 
        if ftype == TType.STRUCT:
8224 
          self.success = MasterAffiliate()
8225 
          self.success.read(iprot)
8226 
        else:
8227 
          iprot.skip(ftype)
8228 
      elif fid == 1:
8229 
        if ftype == TType.STRUCT:
1996 vikas 8230 
          self.utx = UserAffiliateException()
1845 vikas 8231 
          self.utx.read(iprot)
8232 
        else:
8233 
          iprot.skip(ftype)
8234 
      else:
8235 
        iprot.skip(ftype)
8236 
      iprot.readFieldEnd()
8237 
    iprot.readStructEnd()
8238 
 
8239 
  def write(self, oprot):
8240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8242 
      return
8243 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8244 
    if self.success is not None:
1845 vikas 8245 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8246 
      self.success.write(oprot)
8247 
      oprot.writeFieldEnd()
3431 rajveer 8248 
    if self.utx is not None:
1845 vikas 8249 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8250 
      self.utx.write(oprot)
8251 
      oprot.writeFieldEnd()
8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
3431 rajveer 8255 
  def validate(self):
8256 
    return
8257 
 
8258 
 
1845 vikas 8259 
  def __repr__(self):
8260 
    L = ['%s=%r' % (key, value)
8261 
      for key, value in self.__dict__.iteritems()]
8262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8263 
 
8264 
  def __eq__(self, other):
8265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8266 
 
8267 
  def __ne__(self, other):
8268 
    return not (self == other)
8269 
 
1899 vikas 8270 
class getAllMasterAffiliates_args:
8271 
 
8272 
  thrift_spec = (
8273 
  )
8274 
 
8275 
  def read(self, iprot):
8276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8278 
      return
8279 
    iprot.readStructBegin()
8280 
    while True:
8281 
      (fname, ftype, fid) = iprot.readFieldBegin()
8282 
      if ftype == TType.STOP:
8283 
        break
8284 
      else:
8285 
        iprot.skip(ftype)
8286 
      iprot.readFieldEnd()
8287 
    iprot.readStructEnd()
8288 
 
8289 
  def write(self, oprot):
8290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8292 
      return
8293 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8294 
    oprot.writeFieldStop()
8295 
    oprot.writeStructEnd()
8296 
 
3431 rajveer 8297 
  def validate(self):
8298 
    return
8299 
 
8300 
 
1899 vikas 8301 
  def __repr__(self):
8302 
    L = ['%s=%r' % (key, value)
8303 
      for key, value in self.__dict__.iteritems()]
8304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8305 
 
8306 
  def __eq__(self, other):
8307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8308 
 
8309 
  def __ne__(self, other):
8310 
    return not (self == other)
8311 
 
8312 
class getAllMasterAffiliates_result:
8313 
  """
8314 
  Attributes:
8315 
   - success
8316 
   - utx
8317 
  """
8318 
 
8319 
  thrift_spec = (
8320 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8321 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8322 
  )
8323 
 
8324 
  def __init__(self, success=None, utx=None,):
8325 
    self.success = success
8326 
    self.utx = utx
8327 
 
8328 
  def read(self, iprot):
8329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8331 
      return
8332 
    iprot.readStructBegin()
8333 
    while True:
8334 
      (fname, ftype, fid) = iprot.readFieldBegin()
8335 
      if ftype == TType.STOP:
8336 
        break
8337 
      if fid == 0:
8338 
        if ftype == TType.LIST:
8339 
          self.success = []
11592 amit.gupta 8340 
          (_etype121, _size118) = iprot.readListBegin()
8341 
          for _i122 in xrange(_size118):
8342 
            _elem123 = MasterAffiliate()
8343 
            _elem123.read(iprot)
8344 
            self.success.append(_elem123)
1899 vikas 8345 
          iprot.readListEnd()
8346 
        else:
8347 
          iprot.skip(ftype)
8348 
      elif fid == 1:
8349 
        if ftype == TType.STRUCT:
1996 vikas 8350 
          self.utx = UserAffiliateException()
1899 vikas 8351 
          self.utx.read(iprot)
8352 
        else:
8353 
          iprot.skip(ftype)
8354 
      else:
8355 
        iprot.skip(ftype)
8356 
      iprot.readFieldEnd()
8357 
    iprot.readStructEnd()
8358 
 
8359 
  def write(self, oprot):
8360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8362 
      return
8363 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8364 
    if self.success is not None:
1899 vikas 8365 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8366 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8367 
      for iter124 in self.success:
8368 
        iter124.write(oprot)
1899 vikas 8369 
      oprot.writeListEnd()
8370 
      oprot.writeFieldEnd()
3431 rajveer 8371 
    if self.utx is not None:
1899 vikas 8372 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8373 
      self.utx.write(oprot)
8374 
      oprot.writeFieldEnd()
8375 
    oprot.writeFieldStop()
8376 
    oprot.writeStructEnd()
8377 
 
3431 rajveer 8378 
  def validate(self):
8379 
    return
8380 
 
8381 
 
1899 vikas 8382 
  def __repr__(self):
8383 
    L = ['%s=%r' % (key, value)
8384 
      for key, value in self.__dict__.iteritems()]
8385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8386 
 
8387 
  def __eq__(self, other):
8388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8389 
 
8390 
  def __ne__(self, other):
8391 
    return not (self == other)
8392 
 
1845 vikas 8393 
class getMasterAffiliateById_args:
8394 
  """
8395 
  Attributes:
8396 
   - id
8397 
  """
8398 
 
8399 
  thrift_spec = (
8400 
    None, # 0
8401 
    (1, TType.I64, 'id', None, None, ), # 1
8402 
  )
8403 
 
8404 
  def __init__(self, id=None,):
8405 
    self.id = id
8406 
 
8407 
  def read(self, iprot):
8408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8410 
      return
8411 
    iprot.readStructBegin()
8412 
    while True:
8413 
      (fname, ftype, fid) = iprot.readFieldBegin()
8414 
      if ftype == TType.STOP:
8415 
        break
8416 
      if fid == 1:
8417 
        if ftype == TType.I64:
8418 
          self.id = iprot.readI64();
8419 
        else:
8420 
          iprot.skip(ftype)
8421 
      else:
8422 
        iprot.skip(ftype)
8423 
      iprot.readFieldEnd()
8424 
    iprot.readStructEnd()
8425 
 
8426 
  def write(self, oprot):
8427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8429 
      return
8430 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8431 
    if self.id is not None:
1845 vikas 8432 
      oprot.writeFieldBegin('id', TType.I64, 1)
8433 
      oprot.writeI64(self.id)
8434 
      oprot.writeFieldEnd()
8435 
    oprot.writeFieldStop()
8436 
    oprot.writeStructEnd()
8437 
 
3431 rajveer 8438 
  def validate(self):
8439 
    return
8440 
 
8441 
 
1845 vikas 8442 
  def __repr__(self):
8443 
    L = ['%s=%r' % (key, value)
8444 
      for key, value in self.__dict__.iteritems()]
8445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8446 
 
8447 
  def __eq__(self, other):
8448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8449 
 
8450 
  def __ne__(self, other):
8451 
    return not (self == other)
8452 
 
8453 
class getMasterAffiliateById_result:
8454 
  """
8455 
  Attributes:
8456 
   - success
8457 
   - utx
8458 
  """
8459 
 
8460 
  thrift_spec = (
8461 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8462 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8463 
  )
8464 
 
8465 
  def __init__(self, success=None, utx=None,):
8466 
    self.success = success
8467 
    self.utx = utx
8468 
 
8469 
  def read(self, iprot):
8470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8472 
      return
8473 
    iprot.readStructBegin()
8474 
    while True:
8475 
      (fname, ftype, fid) = iprot.readFieldBegin()
8476 
      if ftype == TType.STOP:
8477 
        break
8478 
      if fid == 0:
8479 
        if ftype == TType.STRUCT:
8480 
          self.success = MasterAffiliate()
8481 
          self.success.read(iprot)
8482 
        else:
8483 
          iprot.skip(ftype)
8484 
      elif fid == 1:
8485 
        if ftype == TType.STRUCT:
1996 vikas 8486 
          self.utx = UserAffiliateException()
1845 vikas 8487 
          self.utx.read(iprot)
8488 
        else:
8489 
          iprot.skip(ftype)
8490 
      else:
8491 
        iprot.skip(ftype)
8492 
      iprot.readFieldEnd()
8493 
    iprot.readStructEnd()
8494 
 
8495 
  def write(self, oprot):
8496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8498 
      return
8499 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8500 
    if self.success is not None:
1845 vikas 8501 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8502 
      self.success.write(oprot)
8503 
      oprot.writeFieldEnd()
3431 rajveer 8504 
    if self.utx is not None:
1845 vikas 8505 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8506 
      self.utx.write(oprot)
8507 
      oprot.writeFieldEnd()
8508 
    oprot.writeFieldStop()
8509 
    oprot.writeStructEnd()
8510 
 
3431 rajveer 8511 
  def validate(self):
8512 
    return
8513 
 
8514 
 
1845 vikas 8515 
  def __repr__(self):
8516 
    L = ['%s=%r' % (key, value)
8517 
      for key, value in self.__dict__.iteritems()]
8518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8519 
 
8520 
  def __eq__(self, other):
8521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8522 
 
8523 
  def __ne__(self, other):
8524 
    return not (self == other)
8525 
 
8526 
class getMasterAffiliateByName_args:
8527 
  """
8528 
  Attributes:
8529 
   - name
8530 
  """
8531 
 
8532 
  thrift_spec = (
8533 
    None, # 0
8534 
    (1, TType.STRING, 'name', None, None, ), # 1
8535 
  )
8536 
 
8537 
  def __init__(self, name=None,):
8538 
    self.name = name
8539 
 
8540 
  def read(self, iprot):
8541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8543 
      return
8544 
    iprot.readStructBegin()
8545 
    while True:
8546 
      (fname, ftype, fid) = iprot.readFieldBegin()
8547 
      if ftype == TType.STOP:
8548 
        break
8549 
      if fid == 1:
8550 
        if ftype == TType.STRING:
8551 
          self.name = iprot.readString();
8552 
        else:
8553 
          iprot.skip(ftype)
8554 
      else:
8555 
        iprot.skip(ftype)
8556 
      iprot.readFieldEnd()
8557 
    iprot.readStructEnd()
8558 
 
8559 
  def write(self, oprot):
8560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8562 
      return
8563 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8564 
    if self.name is not None:
1845 vikas 8565 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8566 
      oprot.writeString(self.name)
8567 
      oprot.writeFieldEnd()
8568 
    oprot.writeFieldStop()
8569 
    oprot.writeStructEnd()
8570 
 
3431 rajveer 8571 
  def validate(self):
8572 
    return
8573 
 
8574 
 
1845 vikas 8575 
  def __repr__(self):
8576 
    L = ['%s=%r' % (key, value)
8577 
      for key, value in self.__dict__.iteritems()]
8578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8579 
 
8580 
  def __eq__(self, other):
8581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8582 
 
8583 
  def __ne__(self, other):
8584 
    return not (self == other)
8585 
 
8586 
class getMasterAffiliateByName_result:
8587 
  """
8588 
  Attributes:
8589 
   - success
8590 
   - utx
8591 
  """
8592 
 
8593 
  thrift_spec = (
8594 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8595 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8596 
  )
8597 
 
8598 
  def __init__(self, success=None, utx=None,):
8599 
    self.success = success
8600 
    self.utx = utx
8601 
 
8602 
  def read(self, iprot):
8603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8605 
      return
8606 
    iprot.readStructBegin()
8607 
    while True:
8608 
      (fname, ftype, fid) = iprot.readFieldBegin()
8609 
      if ftype == TType.STOP:
8610 
        break
8611 
      if fid == 0:
8612 
        if ftype == TType.STRUCT:
8613 
          self.success = MasterAffiliate()
8614 
          self.success.read(iprot)
8615 
        else:
8616 
          iprot.skip(ftype)
8617 
      elif fid == 1:
8618 
        if ftype == TType.STRUCT:
1996 vikas 8619 
          self.utx = UserAffiliateException()
1845 vikas 8620 
          self.utx.read(iprot)
8621 
        else:
8622 
          iprot.skip(ftype)
8623 
      else:
8624 
        iprot.skip(ftype)
8625 
      iprot.readFieldEnd()
8626 
    iprot.readStructEnd()
8627 
 
8628 
  def write(self, oprot):
8629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8631 
      return
8632 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8633 
    if self.success is not None:
1845 vikas 8634 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8635 
      self.success.write(oprot)
8636 
      oprot.writeFieldEnd()
3431 rajveer 8637 
    if self.utx is not None:
1845 vikas 8638 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8639 
      self.utx.write(oprot)
8640 
      oprot.writeFieldEnd()
8641 
    oprot.writeFieldStop()
8642 
    oprot.writeStructEnd()
8643 
 
3431 rajveer 8644 
  def validate(self):
8645 
    return
8646 
 
8647 
 
1845 vikas 8648 
  def __repr__(self):
8649 
    L = ['%s=%r' % (key, value)
8650 
      for key, value in self.__dict__.iteritems()]
8651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8652 
 
8653 
  def __eq__(self, other):
8654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8655 
 
8656 
  def __ne__(self, other):
8657 
    return not (self == other)
8658 
 
8659 
class createAffiliate_args:
8660 
  """
8661 
  Attributes:
8662 
   - name
8663 
   - url
8664 
   - masterAffiliateId
1859 vikas 8665 
   - addedOn
1845 vikas 8666 
  """
8667 
 
8668 
  thrift_spec = (
8669 
    None, # 0
8670 
    (1, TType.STRING, 'name', None, None, ), # 1
8671 
    (2, TType.STRING, 'url', None, None, ), # 2
8672 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8673 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8674 
  )
8675 
 
1859 vikas 8676 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8677 
    self.name = name
8678 
    self.url = url
8679 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8680 
    self.addedOn = addedOn
1845 vikas 8681 
 
8682 
  def read(self, iprot):
8683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8685 
      return
8686 
    iprot.readStructBegin()
8687 
    while True:
8688 
      (fname, ftype, fid) = iprot.readFieldBegin()
8689 
      if ftype == TType.STOP:
8690 
        break
8691 
      if fid == 1:
8692 
        if ftype == TType.STRING:
8693 
          self.name = iprot.readString();
8694 
        else:
8695 
          iprot.skip(ftype)
8696 
      elif fid == 2:
8697 
        if ftype == TType.STRING:
8698 
          self.url = iprot.readString();
8699 
        else:
8700 
          iprot.skip(ftype)
8701 
      elif fid == 3:
8702 
        if ftype == TType.I64:
8703 
          self.masterAffiliateId = iprot.readI64();
8704 
        else:
8705 
          iprot.skip(ftype)
1859 vikas 8706 
      elif fid == 4:
8707 
        if ftype == TType.I64:
8708 
          self.addedOn = iprot.readI64();
8709 
        else:
8710 
          iprot.skip(ftype)
1845 vikas 8711 
      else:
8712 
        iprot.skip(ftype)
8713 
      iprot.readFieldEnd()
8714 
    iprot.readStructEnd()
8715 
 
8716 
  def write(self, oprot):
8717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8719 
      return
8720 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8721 
    if self.name is not None:
1845 vikas 8722 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8723 
      oprot.writeString(self.name)
8724 
      oprot.writeFieldEnd()
3431 rajveer 8725 
    if self.url is not None:
1845 vikas 8726 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8727 
      oprot.writeString(self.url)
8728 
      oprot.writeFieldEnd()
3431 rajveer 8729 
    if self.masterAffiliateId is not None:
1845 vikas 8730 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8731 
      oprot.writeI64(self.masterAffiliateId)
8732 
      oprot.writeFieldEnd()
3431 rajveer 8733 
    if self.addedOn is not None:
1859 vikas 8734 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8735 
      oprot.writeI64(self.addedOn)
8736 
      oprot.writeFieldEnd()
1845 vikas 8737 
    oprot.writeFieldStop()
8738 
    oprot.writeStructEnd()
8739 
 
3431 rajveer 8740 
  def validate(self):
8741 
    return
8742 
 
8743 
 
1845 vikas 8744 
  def __repr__(self):
8745 
    L = ['%s=%r' % (key, value)
8746 
      for key, value in self.__dict__.iteritems()]
8747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8748 
 
8749 
  def __eq__(self, other):
8750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8751 
 
8752 
  def __ne__(self, other):
8753 
    return not (self == other)
8754 
 
8755 
class createAffiliate_result:
8756 
  """
8757 
  Attributes:
8758 
   - success
8759 
   - utx
8760 
  """
8761 
 
8762 
  thrift_spec = (
8763 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8764 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8765 
  )
8766 
 
8767 
  def __init__(self, success=None, utx=None,):
8768 
    self.success = success
8769 
    self.utx = utx
8770 
 
8771 
  def read(self, iprot):
8772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8774 
      return
8775 
    iprot.readStructBegin()
8776 
    while True:
8777 
      (fname, ftype, fid) = iprot.readFieldBegin()
8778 
      if ftype == TType.STOP:
8779 
        break
8780 
      if fid == 0:
8781 
        if ftype == TType.STRUCT:
8782 
          self.success = Affiliate()
8783 
          self.success.read(iprot)
8784 
        else:
8785 
          iprot.skip(ftype)
8786 
      elif fid == 1:
8787 
        if ftype == TType.STRUCT:
1996 vikas 8788 
          self.utx = UserAffiliateException()
1845 vikas 8789 
          self.utx.read(iprot)
8790 
        else:
8791 
          iprot.skip(ftype)
8792 
      else:
8793 
        iprot.skip(ftype)
8794 
      iprot.readFieldEnd()
8795 
    iprot.readStructEnd()
8796 
 
8797 
  def write(self, oprot):
8798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8800 
      return
8801 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8802 
    if self.success is not None:
1845 vikas 8803 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8804 
      self.success.write(oprot)
8805 
      oprot.writeFieldEnd()
3431 rajveer 8806 
    if self.utx is not None:
1845 vikas 8807 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8808 
      self.utx.write(oprot)
8809 
      oprot.writeFieldEnd()
8810 
    oprot.writeFieldStop()
8811 
    oprot.writeStructEnd()
8812 
 
3431 rajveer 8813 
  def validate(self):
8814 
    return
8815 
 
8816 
 
1845 vikas 8817 
  def __repr__(self):
8818 
    L = ['%s=%r' % (key, value)
8819 
      for key, value in self.__dict__.iteritems()]
8820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8821 
 
8822 
  def __eq__(self, other):
8823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8824 
 
8825 
  def __ne__(self, other):
8826 
    return not (self == other)
8827 
 
8828 
class getAffiliateById_args:
8829 
  """
8830 
  Attributes:
8831 
   - id
8832 
  """
8833 
 
8834 
  thrift_spec = (
8835 
    None, # 0
8836 
    (1, TType.I64, 'id', None, None, ), # 1
8837 
  )
8838 
 
8839 
  def __init__(self, id=None,):
8840 
    self.id = id
8841 
 
8842 
  def read(self, iprot):
8843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8845 
      return
8846 
    iprot.readStructBegin()
8847 
    while True:
8848 
      (fname, ftype, fid) = iprot.readFieldBegin()
8849 
      if ftype == TType.STOP:
8850 
        break
8851 
      if fid == 1:
8852 
        if ftype == TType.I64:
8853 
          self.id = iprot.readI64();
8854 
        else:
8855 
          iprot.skip(ftype)
8856 
      else:
8857 
        iprot.skip(ftype)
8858 
      iprot.readFieldEnd()
8859 
    iprot.readStructEnd()
8860 
 
8861 
  def write(self, oprot):
8862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8864 
      return
8865 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8866 
    if self.id is not None:
1845 vikas 8867 
      oprot.writeFieldBegin('id', TType.I64, 1)
8868 
      oprot.writeI64(self.id)
8869 
      oprot.writeFieldEnd()
8870 
    oprot.writeFieldStop()
8871 
    oprot.writeStructEnd()
8872 
 
3431 rajveer 8873 
  def validate(self):
8874 
    return
8875 
 
8876 
 
1845 vikas 8877 
  def __repr__(self):
8878 
    L = ['%s=%r' % (key, value)
8879 
      for key, value in self.__dict__.iteritems()]
8880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8881 
 
8882 
  def __eq__(self, other):
8883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8884 
 
8885 
  def __ne__(self, other):
8886 
    return not (self == other)
8887 
 
8888 
class getAffiliateById_result:
8889 
  """
8890 
  Attributes:
8891 
   - success
8892 
   - utx
8893 
  """
8894 
 
8895 
  thrift_spec = (
8896 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8897 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8898 
  )
8899 
 
8900 
  def __init__(self, success=None, utx=None,):
8901 
    self.success = success
8902 
    self.utx = utx
8903 
 
8904 
  def read(self, iprot):
8905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8907 
      return
8908 
    iprot.readStructBegin()
8909 
    while True:
8910 
      (fname, ftype, fid) = iprot.readFieldBegin()
8911 
      if ftype == TType.STOP:
8912 
        break
8913 
      if fid == 0:
8914 
        if ftype == TType.STRUCT:
8915 
          self.success = Affiliate()
8916 
          self.success.read(iprot)
8917 
        else:
8918 
          iprot.skip(ftype)
8919 
      elif fid == 1:
8920 
        if ftype == TType.STRUCT:
1996 vikas 8921 
          self.utx = UserAffiliateException()
1845 vikas 8922 
          self.utx.read(iprot)
8923 
        else:
8924 
          iprot.skip(ftype)
8925 
      else:
8926 
        iprot.skip(ftype)
8927 
      iprot.readFieldEnd()
8928 
    iprot.readStructEnd()
8929 
 
8930 
  def write(self, oprot):
8931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8933 
      return
8934 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 8935 
    if self.success is not None:
1845 vikas 8936 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8937 
      self.success.write(oprot)
8938 
      oprot.writeFieldEnd()
3431 rajveer 8939 
    if self.utx is not None:
1845 vikas 8940 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8941 
      self.utx.write(oprot)
8942 
      oprot.writeFieldEnd()
8943 
    oprot.writeFieldStop()
8944 
    oprot.writeStructEnd()
8945 
 
3431 rajveer 8946 
  def validate(self):
8947 
    return
8948 
 
8949 
 
1845 vikas 8950 
  def __repr__(self):
8951 
    L = ['%s=%r' % (key, value)
8952 
      for key, value in self.__dict__.iteritems()]
8953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8954 
 
8955 
  def __eq__(self, other):
8956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8957 
 
8958 
  def __ne__(self, other):
8959 
    return not (self == other)
8960 
 
8961 
class getAffiliateByName_args:
8962 
  """
8963 
  Attributes:
8964 
   - name
8965 
  """
8966 
 
8967 
  thrift_spec = (
8968 
    None, # 0
8969 
    (1, TType.STRING, 'name', None, None, ), # 1
8970 
  )
8971 
 
8972 
  def __init__(self, name=None,):
8973 
    self.name = name
8974 
 
8975 
  def read(self, iprot):
8976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8978 
      return
8979 
    iprot.readStructBegin()
8980 
    while True:
8981 
      (fname, ftype, fid) = iprot.readFieldBegin()
8982 
      if ftype == TType.STOP:
8983 
        break
8984 
      if fid == 1:
8985 
        if ftype == TType.STRING:
8986 
          self.name = iprot.readString();
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      else:
8990 
        iprot.skip(ftype)
8991 
      iprot.readFieldEnd()
8992 
    iprot.readStructEnd()
8993 
 
8994 
  def write(self, oprot):
8995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8997 
      return
8998 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 8999 
    if self.name is not None:
1845 vikas 9000 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9001 
      oprot.writeString(self.name)
9002 
      oprot.writeFieldEnd()
9003 
    oprot.writeFieldStop()
9004 
    oprot.writeStructEnd()
9005 
 
3431 rajveer 9006 
  def validate(self):
9007 
    return
9008 
 
9009 
 
1845 vikas 9010 
  def __repr__(self):
9011 
    L = ['%s=%r' % (key, value)
9012 
      for key, value in self.__dict__.iteritems()]
9013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9014 
 
9015 
  def __eq__(self, other):
9016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9017 
 
9018 
  def __ne__(self, other):
9019 
    return not (self == other)
9020 
 
9021 
class getAffiliateByName_result:
9022 
  """
9023 
  Attributes:
9024 
   - success
9025 
   - utx
9026 
  """
9027 
 
9028 
  thrift_spec = (
9029 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9030 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9031 
  )
9032 
 
9033 
  def __init__(self, success=None, utx=None,):
9034 
    self.success = success
9035 
    self.utx = utx
9036 
 
9037 
  def read(self, iprot):
9038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9040 
      return
9041 
    iprot.readStructBegin()
9042 
    while True:
9043 
      (fname, ftype, fid) = iprot.readFieldBegin()
9044 
      if ftype == TType.STOP:
9045 
        break
9046 
      if fid == 0:
9047 
        if ftype == TType.STRUCT:
9048 
          self.success = Affiliate()
9049 
          self.success.read(iprot)
9050 
        else:
9051 
          iprot.skip(ftype)
9052 
      elif fid == 1:
9053 
        if ftype == TType.STRUCT:
1996 vikas 9054 
          self.utx = UserAffiliateException()
1845 vikas 9055 
          self.utx.read(iprot)
9056 
        else:
9057 
          iprot.skip(ftype)
9058 
      else:
9059 
        iprot.skip(ftype)
9060 
      iprot.readFieldEnd()
9061 
    iprot.readStructEnd()
9062 
 
9063 
  def write(self, oprot):
9064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9066 
      return
9067 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9068 
    if self.success is not None:
1845 vikas 9069 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9070 
      self.success.write(oprot)
9071 
      oprot.writeFieldEnd()
3431 rajveer 9072 
    if self.utx is not None:
1845 vikas 9073 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9074 
      self.utx.write(oprot)
9075 
      oprot.writeFieldEnd()
9076 
    oprot.writeFieldStop()
9077 
    oprot.writeStructEnd()
9078 
 
3431 rajveer 9079 
  def validate(self):
9080 
    return
9081 
 
9082 
 
1845 vikas 9083 
  def __repr__(self):
9084 
    L = ['%s=%r' % (key, value)
9085 
      for key, value in self.__dict__.iteritems()]
9086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9087 
 
9088 
  def __eq__(self, other):
9089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9090 
 
9091 
  def __ne__(self, other):
9092 
    return not (self == other)
9093 
 
1996 vikas 9094 
class getTrackerById_args:
1845 vikas 9095 
  """
9096 
  Attributes:
9097 
   - id
9098 
  """
9099 
 
9100 
  thrift_spec = (
9101 
    None, # 0
9102 
    (1, TType.I64, 'id', None, None, ), # 1
9103 
  )
9104 
 
9105 
  def __init__(self, id=None,):
9106 
    self.id = id
9107 
 
9108 
  def read(self, iprot):
9109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9111 
      return
9112 
    iprot.readStructBegin()
9113 
    while True:
9114 
      (fname, ftype, fid) = iprot.readFieldBegin()
9115 
      if ftype == TType.STOP:
9116 
        break
9117 
      if fid == 1:
9118 
        if ftype == TType.I64:
9119 
          self.id = iprot.readI64();
9120 
        else:
9121 
          iprot.skip(ftype)
9122 
      else:
9123 
        iprot.skip(ftype)
9124 
      iprot.readFieldEnd()
9125 
    iprot.readStructEnd()
9126 
 
9127 
  def write(self, oprot):
9128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9130 
      return
1996 vikas 9131 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9132 
    if self.id is not None:
1845 vikas 9133 
      oprot.writeFieldBegin('id', TType.I64, 1)
9134 
      oprot.writeI64(self.id)
9135 
      oprot.writeFieldEnd()
9136 
    oprot.writeFieldStop()
9137 
    oprot.writeStructEnd()
9138 
 
3431 rajveer 9139 
  def validate(self):
9140 
    return
9141 
 
9142 
 
1845 vikas 9143 
  def __repr__(self):
9144 
    L = ['%s=%r' % (key, value)
9145 
      for key, value in self.__dict__.iteritems()]
9146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9147 
 
9148 
  def __eq__(self, other):
9149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9150 
 
9151 
  def __ne__(self, other):
9152 
    return not (self == other)
9153 
 
9154 
class getTrackerById_result:
9155 
  """
9156 
  Attributes:
9157 
   - success
9158 
   - utx
9159 
  """
9160 
 
9161 
  thrift_spec = (
9162 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9163 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9164 
  )
9165 
 
9166 
  def __init__(self, success=None, utx=None,):
9167 
    self.success = success
9168 
    self.utx = utx
9169 
 
9170 
  def read(self, iprot):
9171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9173 
      return
9174 
    iprot.readStructBegin()
9175 
    while True:
9176 
      (fname, ftype, fid) = iprot.readFieldBegin()
9177 
      if ftype == TType.STOP:
9178 
        break
9179 
      if fid == 0:
9180 
        if ftype == TType.STRUCT:
9181 
          self.success = Tracker()
9182 
          self.success.read(iprot)
9183 
        else:
9184 
          iprot.skip(ftype)
9185 
      elif fid == 1:
9186 
        if ftype == TType.STRUCT:
1996 vikas 9187 
          self.utx = UserAffiliateException()
1845 vikas 9188 
          self.utx.read(iprot)
9189 
        else:
9190 
          iprot.skip(ftype)
9191 
      else:
9192 
        iprot.skip(ftype)
9193 
      iprot.readFieldEnd()
9194 
    iprot.readStructEnd()
9195 
 
9196 
  def write(self, oprot):
9197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9199 
      return
9200 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9201 
    if self.success is not None:
1845 vikas 9202 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9203 
      self.success.write(oprot)
9204 
      oprot.writeFieldEnd()
3431 rajveer 9205 
    if self.utx is not None:
1845 vikas 9206 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9207 
      self.utx.write(oprot)
9208 
      oprot.writeFieldEnd()
9209 
    oprot.writeFieldStop()
9210 
    oprot.writeStructEnd()
9211 
 
3431 rajveer 9212 
  def validate(self):
9213 
    return
9214 
 
9215 
 
1845 vikas 9216 
  def __repr__(self):
9217 
    L = ['%s=%r' % (key, value)
9218 
      for key, value in self.__dict__.iteritems()]
9219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9220 
 
9221 
  def __eq__(self, other):
9222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9223 
 
9224 
  def __ne__(self, other):
9225 
    return not (self == other)
9226 
 
1996 vikas 9227 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9228 
  """
9229 
  Attributes:
1996 vikas 9230 
   - id
1845 vikas 9231 
  """
9232 
 
9233 
  thrift_spec = (
9234 
    None, # 0
1996 vikas 9235 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9236 
  )
9237 
 
1996 vikas 9238 
  def __init__(self, id=None,):
9239 
    self.id = id
1845 vikas 9240 
 
9241 
  def read(self, iprot):
9242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9244 
      return
9245 
    iprot.readStructBegin()
9246 
    while True:
9247 
      (fname, ftype, fid) = iprot.readFieldBegin()
9248 
      if ftype == TType.STOP:
9249 
        break
9250 
      if fid == 1:
9251 
        if ftype == TType.I64:
1996 vikas 9252 
          self.id = iprot.readI64();
1845 vikas 9253 
        else:
9254 
          iprot.skip(ftype)
9255 
      else:
9256 
        iprot.skip(ftype)
9257 
      iprot.readFieldEnd()
9258 
    iprot.readStructEnd()
9259 
 
9260 
  def write(self, oprot):
9261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9263 
      return
1996 vikas 9264 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9265 
    if self.id is not None:
1996 vikas 9266 
      oprot.writeFieldBegin('id', TType.I64, 1)
9267 
      oprot.writeI64(self.id)
1845 vikas 9268 
      oprot.writeFieldEnd()
9269 
    oprot.writeFieldStop()
9270 
    oprot.writeStructEnd()
9271 
 
3431 rajveer 9272 
  def validate(self):
9273 
    return
9274 
 
9275 
 
1845 vikas 9276 
  def __repr__(self):
9277 
    L = ['%s=%r' % (key, value)
9278 
      for key, value in self.__dict__.iteritems()]
9279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9280 
 
9281 
  def __eq__(self, other):
9282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9283 
 
9284 
  def __ne__(self, other):
9285 
    return not (self == other)
9286 
 
1996 vikas 9287 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9288 
  """
9289 
  Attributes:
9290 
   - success
9291 
   - utx
9292 
  """
9293 
 
9294 
  thrift_spec = (
1996 vikas 9295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9296 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9297 
  )
9298 
 
9299 
  def __init__(self, success=None, utx=None,):
9300 
    self.success = success
9301 
    self.utx = utx
9302 
 
9303 
  def read(self, iprot):
9304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9306 
      return
9307 
    iprot.readStructBegin()
9308 
    while True:
9309 
      (fname, ftype, fid) = iprot.readFieldBegin()
9310 
      if ftype == TType.STOP:
9311 
        break
9312 
      if fid == 0:
9313 
        if ftype == TType.LIST:
9314 
          self.success = []
11592 amit.gupta 9315 
          (_etype128, _size125) = iprot.readListBegin()
9316 
          for _i129 in xrange(_size125):
9317 
            _elem130 = Affiliate()
9318 
            _elem130.read(iprot)
9319 
            self.success.append(_elem130)
1845 vikas 9320 
          iprot.readListEnd()
9321 
        else:
9322 
          iprot.skip(ftype)
9323 
      elif fid == 1:
9324 
        if ftype == TType.STRUCT:
1996 vikas 9325 
          self.utx = UserAffiliateException()
1845 vikas 9326 
          self.utx.read(iprot)
9327 
        else:
9328 
          iprot.skip(ftype)
9329 
      else:
9330 
        iprot.skip(ftype)
9331 
      iprot.readFieldEnd()
9332 
    iprot.readStructEnd()
9333 
 
9334 
  def write(self, oprot):
9335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9337 
      return
1996 vikas 9338 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9339 
    if self.success is not None:
1845 vikas 9340 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9341 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9342 
      for iter131 in self.success:
9343 
        iter131.write(oprot)
1845 vikas 9344 
      oprot.writeListEnd()
9345 
      oprot.writeFieldEnd()
3431 rajveer 9346 
    if self.utx is not None:
1845 vikas 9347 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9348 
      self.utx.write(oprot)
9349 
      oprot.writeFieldEnd()
9350 
    oprot.writeFieldStop()
9351 
    oprot.writeStructEnd()
9352 
 
3431 rajveer 9353 
  def validate(self):
9354 
    return
9355 
 
9356 
 
1845 vikas 9357 
  def __repr__(self):
9358 
    L = ['%s=%r' % (key, value)
9359 
      for key, value in self.__dict__.iteritems()]
9360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9361 
 
9362 
  def __eq__(self, other):
9363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9364 
 
9365 
  def __ne__(self, other):
9366 
    return not (self == other)
9367 
 
9368 
class addTrackLog_args:
9369 
  """
9370 
  Attributes:
1996 vikas 9371 
   - affiliateId
1845 vikas 9372 
   - userId
9373 
   - event
9374 
   - url
9375 
   - data
1859 vikas 9376 
   - addedOn
1845 vikas 9377 
  """
9378 
 
9379 
  thrift_spec = (
9380 
    None, # 0
1996 vikas 9381 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9382 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9383 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9384 
    (4, TType.STRING, 'url', None, None, ), # 4
9385 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9386 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9387 
  )
9388 
 
1996 vikas 9389 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9390 
    self.affiliateId = affiliateId
1845 vikas 9391 
    self.userId = userId
9392 
    self.event = event
9393 
    self.url = url
9394 
    self.data = data
1859 vikas 9395 
    self.addedOn = addedOn
1845 vikas 9396 
 
9397 
  def read(self, iprot):
9398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9400 
      return
9401 
    iprot.readStructBegin()
9402 
    while True:
9403 
      (fname, ftype, fid) = iprot.readFieldBegin()
9404 
      if ftype == TType.STOP:
9405 
        break
9406 
      if fid == 1:
9407 
        if ftype == TType.I64:
1996 vikas 9408 
          self.affiliateId = iprot.readI64();
1845 vikas 9409 
        else:
9410 
          iprot.skip(ftype)
9411 
      elif fid == 2:
9412 
        if ftype == TType.I64:
9413 
          self.userId = iprot.readI64();
9414 
        else:
9415 
          iprot.skip(ftype)
9416 
      elif fid == 3:
3378 vikas 9417 
        if ftype == TType.I32:
9418 
          self.event = iprot.readI32();
1845 vikas 9419 
        else:
9420 
          iprot.skip(ftype)
9421 
      elif fid == 4:
9422 
        if ftype == TType.STRING:
9423 
          self.url = iprot.readString();
9424 
        else:
9425 
          iprot.skip(ftype)
9426 
      elif fid == 5:
9427 
        if ftype == TType.STRING:
9428 
          self.data = iprot.readString();
9429 
        else:
9430 
          iprot.skip(ftype)
1859 vikas 9431 
      elif fid == 6:
9432 
        if ftype == TType.I64:
9433 
          self.addedOn = iprot.readI64();
9434 
        else:
9435 
          iprot.skip(ftype)
1845 vikas 9436 
      else:
9437 
        iprot.skip(ftype)
9438 
      iprot.readFieldEnd()
9439 
    iprot.readStructEnd()
9440 
 
9441 
  def write(self, oprot):
9442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9444 
      return
9445 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9446 
    if self.affiliateId is not None:
1996 vikas 9447 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9448 
      oprot.writeI64(self.affiliateId)
1845 vikas 9449 
      oprot.writeFieldEnd()
3431 rajveer 9450 
    if self.userId is not None:
1845 vikas 9451 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9452 
      oprot.writeI64(self.userId)
9453 
      oprot.writeFieldEnd()
3431 rajveer 9454 
    if self.event is not None:
3378 vikas 9455 
      oprot.writeFieldBegin('event', TType.I32, 3)
9456 
      oprot.writeI32(self.event)
1845 vikas 9457 
      oprot.writeFieldEnd()
3431 rajveer 9458 
    if self.url is not None:
1845 vikas 9459 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9460 
      oprot.writeString(self.url)
9461 
      oprot.writeFieldEnd()
3431 rajveer 9462 
    if self.data is not None:
1845 vikas 9463 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9464 
      oprot.writeString(self.data)
9465 
      oprot.writeFieldEnd()
3431 rajveer 9466 
    if self.addedOn is not None:
1859 vikas 9467 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9468 
      oprot.writeI64(self.addedOn)
9469 
      oprot.writeFieldEnd()
1845 vikas 9470 
    oprot.writeFieldStop()
9471 
    oprot.writeStructEnd()
9472 
 
3431 rajveer 9473 
  def validate(self):
9474 
    return
9475 
 
9476 
 
1845 vikas 9477 
  def __repr__(self):
9478 
    L = ['%s=%r' % (key, value)
9479 
      for key, value in self.__dict__.iteritems()]
9480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9481 
 
9482 
  def __eq__(self, other):
9483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9484 
 
9485 
  def __ne__(self, other):
9486 
    return not (self == other)
9487 
 
9488 
class addTrackLog_result:
9489 
  """
9490 
  Attributes:
9491 
   - success
9492 
   - utx
9493 
  """
9494 
 
9495 
  thrift_spec = (
9496 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9497 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9498 
  )
9499 
 
9500 
  def __init__(self, success=None, utx=None,):
9501 
    self.success = success
9502 
    self.utx = utx
9503 
 
9504 
  def read(self, iprot):
9505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9507 
      return
9508 
    iprot.readStructBegin()
9509 
    while True:
9510 
      (fname, ftype, fid) = iprot.readFieldBegin()
9511 
      if ftype == TType.STOP:
9512 
        break
9513 
      if fid == 0:
9514 
        if ftype == TType.I64:
9515 
          self.success = iprot.readI64();
9516 
        else:
9517 
          iprot.skip(ftype)
9518 
      elif fid == 1:
9519 
        if ftype == TType.STRUCT:
1996 vikas 9520 
          self.utx = UserAffiliateException()
1845 vikas 9521 
          self.utx.read(iprot)
9522 
        else:
9523 
          iprot.skip(ftype)
9524 
      else:
9525 
        iprot.skip(ftype)
9526 
      iprot.readFieldEnd()
9527 
    iprot.readStructEnd()
9528 
 
9529 
  def write(self, oprot):
9530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9532 
      return
9533 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9534 
    if self.success is not None:
1845 vikas 9535 
      oprot.writeFieldBegin('success', TType.I64, 0)
9536 
      oprot.writeI64(self.success)
9537 
      oprot.writeFieldEnd()
3431 rajveer 9538 
    if self.utx is not None:
1845 vikas 9539 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9540 
      self.utx.write(oprot)
9541 
      oprot.writeFieldEnd()
9542 
    oprot.writeFieldStop()
9543 
    oprot.writeStructEnd()
9544 
 
3431 rajveer 9545 
  def validate(self):
9546 
    return
9547 
 
9548 
 
1845 vikas 9549 
  def __repr__(self):
9550 
    L = ['%s=%r' % (key, value)
9551 
      for key, value in self.__dict__.iteritems()]
9552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9553 
 
9554 
  def __eq__(self, other):
9555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9556 
 
9557 
  def __ne__(self, other):
9558 
    return not (self == other)
9559 
 
9560 
class getTrackLogById_args:
9561 
  """
9562 
  Attributes:
9563 
   - id
9564 
  """
9565 
 
9566 
  thrift_spec = (
9567 
    None, # 0
9568 
    (1, TType.I64, 'id', None, None, ), # 1
9569 
  )
9570 
 
9571 
  def __init__(self, id=None,):
9572 
    self.id = id
9573 
 
9574 
  def read(self, iprot):
9575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9577 
      return
9578 
    iprot.readStructBegin()
9579 
    while True:
9580 
      (fname, ftype, fid) = iprot.readFieldBegin()
9581 
      if ftype == TType.STOP:
9582 
        break
9583 
      if fid == 1:
9584 
        if ftype == TType.I64:
9585 
          self.id = iprot.readI64();
9586 
        else:
9587 
          iprot.skip(ftype)
9588 
      else:
9589 
        iprot.skip(ftype)
9590 
      iprot.readFieldEnd()
9591 
    iprot.readStructEnd()
9592 
 
9593 
  def write(self, oprot):
9594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9596 
      return
9597 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9598 
    if self.id is not None:
1845 vikas 9599 
      oprot.writeFieldBegin('id', TType.I64, 1)
9600 
      oprot.writeI64(self.id)
9601 
      oprot.writeFieldEnd()
9602 
    oprot.writeFieldStop()
9603 
    oprot.writeStructEnd()
9604 
 
3431 rajveer 9605 
  def validate(self):
9606 
    return
9607 
 
9608 
 
1845 vikas 9609 
  def __repr__(self):
9610 
    L = ['%s=%r' % (key, value)
9611 
      for key, value in self.__dict__.iteritems()]
9612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9613 
 
9614 
  def __eq__(self, other):
9615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9616 
 
9617 
  def __ne__(self, other):
9618 
    return not (self == other)
9619 
 
9620 
class getTrackLogById_result:
9621 
  """
9622 
  Attributes:
9623 
   - success
9624 
   - utx
9625 
  """
9626 
 
9627 
  thrift_spec = (
9628 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9629 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9630 
  )
9631 
 
9632 
  def __init__(self, success=None, utx=None,):
9633 
    self.success = success
9634 
    self.utx = utx
9635 
 
9636 
  def read(self, iprot):
9637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9639 
      return
9640 
    iprot.readStructBegin()
9641 
    while True:
9642 
      (fname, ftype, fid) = iprot.readFieldBegin()
9643 
      if ftype == TType.STOP:
9644 
        break
9645 
      if fid == 0:
9646 
        if ftype == TType.STRUCT:
9647 
          self.success = TrackLog()
9648 
          self.success.read(iprot)
9649 
        else:
9650 
          iprot.skip(ftype)
9651 
      elif fid == 1:
9652 
        if ftype == TType.STRUCT:
1996 vikas 9653 
          self.utx = UserAffiliateException()
1845 vikas 9654 
          self.utx.read(iprot)
9655 
        else:
9656 
          iprot.skip(ftype)
9657 
      else:
9658 
        iprot.skip(ftype)
9659 
      iprot.readFieldEnd()
9660 
    iprot.readStructEnd()
9661 
 
9662 
  def write(self, oprot):
9663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9665 
      return
9666 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9667 
    if self.success is not None:
1845 vikas 9668 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9669 
      self.success.write(oprot)
9670 
      oprot.writeFieldEnd()
3431 rajveer 9671 
    if self.utx is not None:
1845 vikas 9672 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9673 
      self.utx.write(oprot)
9674 
      oprot.writeFieldEnd()
9675 
    oprot.writeFieldStop()
9676 
    oprot.writeStructEnd()
9677 
 
3431 rajveer 9678 
  def validate(self):
9679 
    return
9680 
 
9681 
 
1845 vikas 9682 
  def __repr__(self):
9683 
    L = ['%s=%r' % (key, value)
9684 
      for key, value in self.__dict__.iteritems()]
9685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9686 
 
9687 
  def __eq__(self, other):
9688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9689 
 
9690 
  def __ne__(self, other):
9691 
    return not (self == other)
9692 
 
1996 vikas 9693 
class getTrackLogsByAffiliate_args:
1845 vikas 9694 
  """
9695 
  Attributes:
1996 vikas 9696 
   - affiliateId
3293 vikas 9697 
   - startDate
9698 
   - endDate
1845 vikas 9699 
  """
9700 
 
9701 
  thrift_spec = (
9702 
    None, # 0
1996 vikas 9703 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9704 
    (2, TType.I64, 'startDate', None, None, ), # 2
9705 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9706 
  )
9707 
 
3293 vikas 9708 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9709 
    self.affiliateId = affiliateId
3293 vikas 9710 
    self.startDate = startDate
9711 
    self.endDate = endDate
1845 vikas 9712 
 
9713 
  def read(self, iprot):
9714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9716 
      return
9717 
    iprot.readStructBegin()
9718 
    while True:
9719 
      (fname, ftype, fid) = iprot.readFieldBegin()
9720 
      if ftype == TType.STOP:
9721 
        break
9722 
      if fid == 1:
9723 
        if ftype == TType.I64:
1996 vikas 9724 
          self.affiliateId = iprot.readI64();
1845 vikas 9725 
        else:
9726 
          iprot.skip(ftype)
3293 vikas 9727 
      elif fid == 2:
9728 
        if ftype == TType.I64:
9729 
          self.startDate = iprot.readI64();
9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      elif fid == 3:
9733 
        if ftype == TType.I64:
9734 
          self.endDate = iprot.readI64();
9735 
        else:
9736 
          iprot.skip(ftype)
1845 vikas 9737 
      else:
9738 
        iprot.skip(ftype)
9739 
      iprot.readFieldEnd()
9740 
    iprot.readStructEnd()
9741 
 
9742 
  def write(self, oprot):
9743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9745 
      return
1996 vikas 9746 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9747 
    if self.affiliateId is not None:
1996 vikas 9748 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9749 
      oprot.writeI64(self.affiliateId)
1845 vikas 9750 
      oprot.writeFieldEnd()
3431 rajveer 9751 
    if self.startDate is not None:
3293 vikas 9752 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9753 
      oprot.writeI64(self.startDate)
9754 
      oprot.writeFieldEnd()
3431 rajveer 9755 
    if self.endDate is not None:
3293 vikas 9756 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9757 
      oprot.writeI64(self.endDate)
9758 
      oprot.writeFieldEnd()
1845 vikas 9759 
    oprot.writeFieldStop()
9760 
    oprot.writeStructEnd()
9761 
 
3431 rajveer 9762 
  def validate(self):
9763 
    return
9764 
 
9765 
 
1845 vikas 9766 
  def __repr__(self):
9767 
    L = ['%s=%r' % (key, value)
9768 
      for key, value in self.__dict__.iteritems()]
9769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9770 
 
9771 
  def __eq__(self, other):
9772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9773 
 
9774 
  def __ne__(self, other):
9775 
    return not (self == other)
9776 
 
1996 vikas 9777 
class getTrackLogsByAffiliate_result:
1845 vikas 9778 
  """
9779 
  Attributes:
9780 
   - success
9781 
   - utx
9782 
  """
9783 
 
9784 
  thrift_spec = (
9785 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9786 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9787 
  )
9788 
 
9789 
  def __init__(self, success=None, utx=None,):
9790 
    self.success = success
9791 
    self.utx = utx
9792 
 
9793 
  def read(self, iprot):
9794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9796 
      return
9797 
    iprot.readStructBegin()
9798 
    while True:
9799 
      (fname, ftype, fid) = iprot.readFieldBegin()
9800 
      if ftype == TType.STOP:
9801 
        break
9802 
      if fid == 0:
9803 
        if ftype == TType.LIST:
9804 
          self.success = []
11592 amit.gupta 9805 
          (_etype135, _size132) = iprot.readListBegin()
9806 
          for _i136 in xrange(_size132):
9807 
            _elem137 = TrackLog()
9808 
            _elem137.read(iprot)
9809 
            self.success.append(_elem137)
1845 vikas 9810 
          iprot.readListEnd()
9811 
        else:
9812 
          iprot.skip(ftype)
9813 
      elif fid == 1:
9814 
        if ftype == TType.STRUCT:
1996 vikas 9815 
          self.utx = UserAffiliateException()
1845 vikas 9816 
          self.utx.read(iprot)
9817 
        else:
9818 
          iprot.skip(ftype)
9819 
      else:
9820 
        iprot.skip(ftype)
9821 
      iprot.readFieldEnd()
9822 
    iprot.readStructEnd()
9823 
 
9824 
  def write(self, oprot):
9825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9827 
      return
1996 vikas 9828 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9829 
    if self.success is not None:
1845 vikas 9830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9832 
      for iter138 in self.success:
9833 
        iter138.write(oprot)
1845 vikas 9834 
      oprot.writeListEnd()
9835 
      oprot.writeFieldEnd()
3431 rajveer 9836 
    if self.utx is not None:
1845 vikas 9837 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9838 
      self.utx.write(oprot)
9839 
      oprot.writeFieldEnd()
9840 
    oprot.writeFieldStop()
9841 
    oprot.writeStructEnd()
9842 
 
3431 rajveer 9843 
  def validate(self):
9844 
    return
9845 
 
9846 
 
1845 vikas 9847 
  def __repr__(self):
9848 
    L = ['%s=%r' % (key, value)
9849 
      for key, value in self.__dict__.iteritems()]
9850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9851 
 
9852 
  def __eq__(self, other):
9853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9854 
 
9855 
  def __ne__(self, other):
9856 
    return not (self == other)
9857 
 
9858 
class getTrackLogsByUser_args:
9859 
  """
9860 
  Attributes:
9861 
   - userId
9862 
  """
9863 
 
9864 
  thrift_spec = (
9865 
    None, # 0
9866 
    (1, TType.I64, 'userId', None, None, ), # 1
9867 
  )
9868 
 
9869 
  def __init__(self, userId=None,):
9870 
    self.userId = userId
9871 
 
9872 
  def read(self, iprot):
9873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9875 
      return
9876 
    iprot.readStructBegin()
9877 
    while True:
9878 
      (fname, ftype, fid) = iprot.readFieldBegin()
9879 
      if ftype == TType.STOP:
9880 
        break
9881 
      if fid == 1:
9882 
        if ftype == TType.I64:
9883 
          self.userId = iprot.readI64();
9884 
        else:
9885 
          iprot.skip(ftype)
9886 
      else:
9887 
        iprot.skip(ftype)
9888 
      iprot.readFieldEnd()
9889 
    iprot.readStructEnd()
9890 
 
9891 
  def write(self, oprot):
9892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9894 
      return
9895 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9896 
    if self.userId is not None:
1845 vikas 9897 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9898 
      oprot.writeI64(self.userId)
9899 
      oprot.writeFieldEnd()
9900 
    oprot.writeFieldStop()
9901 
    oprot.writeStructEnd()
9902 
 
3431 rajveer 9903 
  def validate(self):
9904 
    return
9905 
 
9906 
 
1845 vikas 9907 
  def __repr__(self):
9908 
    L = ['%s=%r' % (key, value)
9909 
      for key, value in self.__dict__.iteritems()]
9910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9911 
 
9912 
  def __eq__(self, other):
9913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9914 
 
9915 
  def __ne__(self, other):
9916 
    return not (self == other)
9917 
 
9918 
class getTrackLogsByUser_result:
9919 
  """
9920 
  Attributes:
9921 
   - success
9922 
   - utx
9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9927 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9928 
  )
9929 
 
9930 
  def __init__(self, success=None, utx=None,):
9931 
    self.success = success
9932 
    self.utx = utx
9933 
 
9934 
  def read(self, iprot):
9935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9937 
      return
9938 
    iprot.readStructBegin()
9939 
    while True:
9940 
      (fname, ftype, fid) = iprot.readFieldBegin()
9941 
      if ftype == TType.STOP:
9942 
        break
9943 
      if fid == 0:
9944 
        if ftype == TType.LIST:
9945 
          self.success = []
11592 amit.gupta 9946 
          (_etype142, _size139) = iprot.readListBegin()
9947 
          for _i143 in xrange(_size139):
9948 
            _elem144 = TrackLog()
9949 
            _elem144.read(iprot)
9950 
            self.success.append(_elem144)
1845 vikas 9951 
          iprot.readListEnd()
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      elif fid == 1:
9955 
        if ftype == TType.STRUCT:
1996 vikas 9956 
          self.utx = UserAffiliateException()
1845 vikas 9957 
          self.utx.read(iprot)
9958 
        else:
9959 
          iprot.skip(ftype)
9960 
      else:
9961 
        iprot.skip(ftype)
9962 
      iprot.readFieldEnd()
9963 
    iprot.readStructEnd()
9964 
 
9965 
  def write(self, oprot):
9966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9968 
      return
9969 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 9970 
    if self.success is not None:
1845 vikas 9971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9973 
      for iter145 in self.success:
9974 
        iter145.write(oprot)
1845 vikas 9975 
      oprot.writeListEnd()
9976 
      oprot.writeFieldEnd()
3431 rajveer 9977 
    if self.utx is not None:
1845 vikas 9978 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9979 
      self.utx.write(oprot)
9980 
      oprot.writeFieldEnd()
9981 
    oprot.writeFieldStop()
9982 
    oprot.writeStructEnd()
9983 
 
3431 rajveer 9984 
  def validate(self):
9985 
    return
9986 
 
9987 
 
1845 vikas 9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
9999 
class getTrackLogs_args:
10000 
  """
10001 
  Attributes:
10002 
   - userId
10003 
   - event
10004 
   - url
10005 
  """
10006 
 
10007 
  thrift_spec = (
10008 
    None, # 0
1996 vikas 10009 
    (1, TType.I64, 'userId', None, None, ), # 1
10010 
    (2, TType.STRING, 'event', None, None, ), # 2
10011 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10012 
  )
10013 
 
1996 vikas 10014 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10015 
    self.userId = userId
10016 
    self.event = event
10017 
    self.url = url
10018 
 
10019 
  def read(self, iprot):
10020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10022 
      return
10023 
    iprot.readStructBegin()
10024 
    while True:
10025 
      (fname, ftype, fid) = iprot.readFieldBegin()
10026 
      if ftype == TType.STOP:
10027 
        break
10028 
      if fid == 1:
10029 
        if ftype == TType.I64:
1996 vikas 10030 
          self.userId = iprot.readI64();
1845 vikas 10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      elif fid == 2:
10034 
        if ftype == TType.STRING:
10035 
          self.event = iprot.readString();
10036 
        else:
10037 
          iprot.skip(ftype)
1996 vikas 10038 
      elif fid == 3:
1845 vikas 10039 
        if ftype == TType.STRING:
10040 
          self.url = iprot.readString();
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      else:
10044 
        iprot.skip(ftype)
10045 
      iprot.readFieldEnd()
10046 
    iprot.readStructEnd()
10047 
 
10048 
  def write(self, oprot):
10049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10051 
      return
10052 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10053 
    if self.userId is not None:
1996 vikas 10054 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10055 
      oprot.writeI64(self.userId)
10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.event is not None:
1996 vikas 10058 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10059 
      oprot.writeString(self.event)
10060 
      oprot.writeFieldEnd()
3431 rajveer 10061 
    if self.url is not None:
1996 vikas 10062 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10063 
      oprot.writeString(self.url)
10064 
      oprot.writeFieldEnd()
10065 
    oprot.writeFieldStop()
10066 
    oprot.writeStructEnd()
10067 
 
3431 rajveer 10068 
  def validate(self):
10069 
    return
10070 
 
10071 
 
1845 vikas 10072 
  def __repr__(self):
10073 
    L = ['%s=%r' % (key, value)
10074 
      for key, value in self.__dict__.iteritems()]
10075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10076 
 
10077 
  def __eq__(self, other):
10078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10079 
 
10080 
  def __ne__(self, other):
10081 
    return not (self == other)
10082 
 
10083 
class getTrackLogs_result:
10084 
  """
10085 
  Attributes:
10086 
   - success
10087 
   - utx
10088 
  """
10089 
 
10090 
  thrift_spec = (
10091 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10092 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10093 
  )
10094 
 
10095 
  def __init__(self, success=None, utx=None,):
10096 
    self.success = success
10097 
    self.utx = utx
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 0:
10109 
        if ftype == TType.LIST:
10110 
          self.success = []
11592 amit.gupta 10111 
          (_etype149, _size146) = iprot.readListBegin()
10112 
          for _i150 in xrange(_size146):
10113 
            _elem151 = TrackLog()
10114 
            _elem151.read(iprot)
10115 
            self.success.append(_elem151)
1845 vikas 10116 
          iprot.readListEnd()
10117 
        else:
10118 
          iprot.skip(ftype)
10119 
      elif fid == 1:
10120 
        if ftype == TType.STRUCT:
1996 vikas 10121 
          self.utx = UserAffiliateException()
1845 vikas 10122 
          self.utx.read(iprot)
10123 
        else:
10124 
          iprot.skip(ftype)
10125 
      else:
10126 
        iprot.skip(ftype)
10127 
      iprot.readFieldEnd()
10128 
    iprot.readStructEnd()
10129 
 
10130 
  def write(self, oprot):
10131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10133 
      return
10134 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10135 
    if self.success is not None:
1845 vikas 10136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10138 
      for iter152 in self.success:
10139 
        iter152.write(oprot)
1845 vikas 10140 
      oprot.writeListEnd()
10141 
      oprot.writeFieldEnd()
3431 rajveer 10142 
    if self.utx is not None:
1845 vikas 10143 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10144 
      self.utx.write(oprot)
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
3431 rajveer 10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
1845 vikas 10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
559 chandransh 10164 
class getCurrentCart_args:
94 ashish 10165 
  """
10166 
  Attributes:
559 chandransh 10167 
   - userId
10168 
  """
10169 
 
10170 
  thrift_spec = (
10171 
    None, # 0
10172 
    (1, TType.I64, 'userId', None, None, ), # 1
10173 
  )
10174 
 
10175 
  def __init__(self, userId=None,):
10176 
    self.userId = userId
10177 
 
10178 
  def read(self, iprot):
10179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10181 
      return
10182 
    iprot.readStructBegin()
10183 
    while True:
10184 
      (fname, ftype, fid) = iprot.readFieldBegin()
10185 
      if ftype == TType.STOP:
10186 
        break
10187 
      if fid == 1:
10188 
        if ftype == TType.I64:
10189 
          self.userId = iprot.readI64();
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
10201 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10202 
    if self.userId is not None:
559 chandransh 10203 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10204 
      oprot.writeI64(self.userId)
10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
3431 rajveer 10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
559 chandransh 10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
10224 
class getCurrentCart_result:
10225 
  """
10226 
  Attributes:
94 ashish 10227 
   - success
559 chandransh 10228 
   - scx
94 ashish 10229 
  """
10230 
 
10231 
  thrift_spec = (
559 chandransh 10232 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10233 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10234 
  )
10235 
 
559 chandransh 10236 
  def __init__(self, success=None, scx=None,):
94 ashish 10237 
    self.success = success
559 chandransh 10238 
    self.scx = scx
94 ashish 10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 0:
559 chandransh 10250 
        if ftype == TType.STRUCT:
10251 
          self.success = Cart()
10252 
          self.success.read(iprot)
94 ashish 10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      elif fid == 1:
10256 
        if ftype == TType.STRUCT:
559 chandransh 10257 
          self.scx = ShoppingCartException()
10258 
          self.scx.read(iprot)
94 ashish 10259 
        else:
10260 
          iprot.skip(ftype)
10261 
      else:
10262 
        iprot.skip(ftype)
10263 
      iprot.readFieldEnd()
10264 
    iprot.readStructEnd()
10265 
 
10266 
  def write(self, oprot):
10267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10269 
      return
559 chandransh 10270 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10271 
    if self.success is not None:
559 chandransh 10272 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10273 
      self.success.write(oprot)
94 ashish 10274 
      oprot.writeFieldEnd()
3431 rajveer 10275 
    if self.scx is not None:
559 chandransh 10276 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10277 
      self.scx.write(oprot)
94 ashish 10278 
      oprot.writeFieldEnd()
10279 
    oprot.writeFieldStop()
10280 
    oprot.writeStructEnd()
10281 
 
3431 rajveer 10282 
  def validate(self):
10283 
    return
10284 
 
10285 
 
94 ashish 10286 
  def __repr__(self):
10287 
    L = ['%s=%r' % (key, value)
10288 
      for key, value in self.__dict__.iteritems()]
10289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10290 
 
10291 
  def __eq__(self, other):
10292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10293 
 
10294 
  def __ne__(self, other):
10295 
    return not (self == other)
10296 
 
559 chandransh 10297 
class getCart_args:
504 rajveer 10298 
  """
10299 
  Attributes:
559 chandransh 10300 
   - cartId
504 rajveer 10301 
  """
10302 
 
10303 
  thrift_spec = (
10304 
    None, # 0
559 chandransh 10305 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10306 
  )
10307 
 
559 chandransh 10308 
  def __init__(self, cartId=None,):
10309 
    self.cartId = cartId
504 rajveer 10310 
 
10311 
  def read(self, iprot):
10312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10314 
      return
10315 
    iprot.readStructBegin()
10316 
    while True:
10317 
      (fname, ftype, fid) = iprot.readFieldBegin()
10318 
      if ftype == TType.STOP:
10319 
        break
10320 
      if fid == 1:
10321 
        if ftype == TType.I64:
559 chandransh 10322 
          self.cartId = iprot.readI64();
504 rajveer 10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      else:
10326 
        iprot.skip(ftype)
10327 
      iprot.readFieldEnd()
10328 
    iprot.readStructEnd()
10329 
 
10330 
  def write(self, oprot):
10331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10333 
      return
559 chandransh 10334 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10335 
    if self.cartId is not None:
559 chandransh 10336 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10337 
      oprot.writeI64(self.cartId)
504 rajveer 10338 
      oprot.writeFieldEnd()
10339 
    oprot.writeFieldStop()
10340 
    oprot.writeStructEnd()
10341 
 
3431 rajveer 10342 
  def validate(self):
10343 
    return
10344 
 
10345 
 
504 rajveer 10346 
  def __repr__(self):
10347 
    L = ['%s=%r' % (key, value)
10348 
      for key, value in self.__dict__.iteritems()]
10349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10350 
 
10351 
  def __eq__(self, other):
10352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10353 
 
10354 
  def __ne__(self, other):
10355 
    return not (self == other)
10356 
 
559 chandransh 10357 
class getCart_result:
504 rajveer 10358 
  """
10359 
  Attributes:
10360 
   - success
559 chandransh 10361 
   - scx
504 rajveer 10362 
  """
10363 
 
10364 
  thrift_spec = (
559 chandransh 10365 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10366 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10367 
  )
10368 
 
559 chandransh 10369 
  def __init__(self, success=None, scx=None,):
504 rajveer 10370 
    self.success = success
559 chandransh 10371 
    self.scx = scx
504 rajveer 10372 
 
10373 
  def read(self, iprot):
10374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10376 
      return
10377 
    iprot.readStructBegin()
10378 
    while True:
10379 
      (fname, ftype, fid) = iprot.readFieldBegin()
10380 
      if ftype == TType.STOP:
10381 
        break
10382 
      if fid == 0:
559 chandransh 10383 
        if ftype == TType.STRUCT:
10384 
          self.success = Cart()
10385 
          self.success.read(iprot)
504 rajveer 10386 
        else:
10387 
          iprot.skip(ftype)
10388 
      elif fid == 1:
10389 
        if ftype == TType.STRUCT:
559 chandransh 10390 
          self.scx = ShoppingCartException()
10391 
          self.scx.read(iprot)
504 rajveer 10392 
        else:
10393 
          iprot.skip(ftype)
10394 
      else:
10395 
        iprot.skip(ftype)
10396 
      iprot.readFieldEnd()
10397 
    iprot.readStructEnd()
10398 
 
10399 
  def write(self, oprot):
10400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10402 
      return
559 chandransh 10403 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10404 
    if self.success is not None:
559 chandransh 10405 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10406 
      self.success.write(oprot)
504 rajveer 10407 
      oprot.writeFieldEnd()
3431 rajveer 10408 
    if self.scx is not None:
559 chandransh 10409 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10410 
      self.scx.write(oprot)
504 rajveer 10411 
      oprot.writeFieldEnd()
10412 
    oprot.writeFieldStop()
10413 
    oprot.writeStructEnd()
10414 
 
3431 rajveer 10415 
  def validate(self):
10416 
    return
10417 
 
10418 
 
504 rajveer 10419 
  def __repr__(self):
10420 
    L = ['%s=%r' % (key, value)
10421 
      for key, value in self.__dict__.iteritems()]
10422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10423 
 
10424 
  def __eq__(self, other):
10425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10426 
 
10427 
  def __ne__(self, other):
10428 
    return not (self == other)
10429 
 
559 chandransh 10430 
class getCartsByTime_args:
10431 
  """
10432 
  Attributes:
10433 
   - from_time
10434 
   - to_time
10435 
   - status
10436 
  """
10437 
 
10438 
  thrift_spec = (
10439 
    None, # 0
10440 
    (1, TType.I64, 'from_time', None, None, ), # 1
10441 
    (2, TType.I64, 'to_time', None, None, ), # 2
10442 
    (3, TType.I32, 'status', None, None, ), # 3
10443 
  )
10444 
 
10445 
  def __init__(self, from_time=None, to_time=None, status=None,):
10446 
    self.from_time = from_time
10447 
    self.to_time = to_time
10448 
    self.status = status
10449 
 
10450 
  def read(self, iprot):
10451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10453 
      return
10454 
    iprot.readStructBegin()
10455 
    while True:
10456 
      (fname, ftype, fid) = iprot.readFieldBegin()
10457 
      if ftype == TType.STOP:
10458 
        break
10459 
      if fid == 1:
94 ashish 10460 
        if ftype == TType.I64:
559 chandransh 10461 
          self.from_time = iprot.readI64();
94 ashish 10462 
        else:
10463 
          iprot.skip(ftype)
122 ashish 10464 
      elif fid == 2:
559 chandransh 10465 
        if ftype == TType.I64:
10466 
          self.to_time = iprot.readI64();
122 ashish 10467 
        else:
10468 
          iprot.skip(ftype)
559 chandransh 10469 
      elif fid == 3:
10470 
        if ftype == TType.I32:
10471 
          self.status = iprot.readI32();
10472 
        else:
10473 
          iprot.skip(ftype)
94 ashish 10474 
      else:
10475 
        iprot.skip(ftype)
10476 
      iprot.readFieldEnd()
10477 
    iprot.readStructEnd()
10478 
 
10479 
  def write(self, oprot):
10480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10482 
      return
559 chandransh 10483 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10484 
    if self.from_time is not None:
559 chandransh 10485 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10486 
      oprot.writeI64(self.from_time)
94 ashish 10487 
      oprot.writeFieldEnd()
3431 rajveer 10488 
    if self.to_time is not None:
559 chandransh 10489 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10490 
      oprot.writeI64(self.to_time)
122 ashish 10491 
      oprot.writeFieldEnd()
3431 rajveer 10492 
    if self.status is not None:
559 chandransh 10493 
      oprot.writeFieldBegin('status', TType.I32, 3)
10494 
      oprot.writeI32(self.status)
10495 
      oprot.writeFieldEnd()
94 ashish 10496 
    oprot.writeFieldStop()
10497 
    oprot.writeStructEnd()
10498 
 
3431 rajveer 10499 
  def validate(self):
10500 
    return
10501 
 
10502 
 
94 ashish 10503 
  def __repr__(self):
10504 
    L = ['%s=%r' % (key, value)
10505 
      for key, value in self.__dict__.iteritems()]
10506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10507 
 
10508 
  def __eq__(self, other):
10509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10510 
 
10511 
  def __ne__(self, other):
10512 
    return not (self == other)
10513 
 
559 chandransh 10514 
class getCartsByTime_result:
94 ashish 10515 
  """
10516 
  Attributes:
10517 
   - success
559 chandransh 10518 
   - scx
94 ashish 10519 
  """
10520 
 
10521 
  thrift_spec = (
559 chandransh 10522 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10523 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10524 
  )
10525 
 
559 chandransh 10526 
  def __init__(self, success=None, scx=None,):
94 ashish 10527 
    self.success = success
559 chandransh 10528 
    self.scx = scx
94 ashish 10529 
 
10530 
  def read(self, iprot):
10531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10533 
      return
10534 
    iprot.readStructBegin()
10535 
    while True:
10536 
      (fname, ftype, fid) = iprot.readFieldBegin()
10537 
      if ftype == TType.STOP:
10538 
        break
10539 
      if fid == 0:
559 chandransh 10540 
        if ftype == TType.LIST:
10541 
          self.success = []
11592 amit.gupta 10542 
          (_etype156, _size153) = iprot.readListBegin()
10543 
          for _i157 in xrange(_size153):
10544 
            _elem158 = Cart()
10545 
            _elem158.read(iprot)
10546 
            self.success.append(_elem158)
559 chandransh 10547 
          iprot.readListEnd()
94 ashish 10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      elif fid == 1:
10551 
        if ftype == TType.STRUCT:
559 chandransh 10552 
          self.scx = ShoppingCartException()
10553 
          self.scx.read(iprot)
94 ashish 10554 
        else:
10555 
          iprot.skip(ftype)
10556 
      else:
10557 
        iprot.skip(ftype)
10558 
      iprot.readFieldEnd()
10559 
    iprot.readStructEnd()
10560 
 
10561 
  def write(self, oprot):
10562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10564 
      return
559 chandransh 10565 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10566 
    if self.success is not None:
559 chandransh 10567 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10568 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10569 
      for iter159 in self.success:
10570 
        iter159.write(oprot)
559 chandransh 10571 
      oprot.writeListEnd()
94 ashish 10572 
      oprot.writeFieldEnd()
3431 rajveer 10573 
    if self.scx is not None:
559 chandransh 10574 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10575 
      self.scx.write(oprot)
94 ashish 10576 
      oprot.writeFieldEnd()
10577 
    oprot.writeFieldStop()
10578 
    oprot.writeStructEnd()
10579 
 
3431 rajveer 10580 
  def validate(self):
10581 
    return
10582 
 
10583 
 
94 ashish 10584 
  def __repr__(self):
10585 
    L = ['%s=%r' % (key, value)
10586 
      for key, value in self.__dict__.iteritems()]
10587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10588 
 
10589 
  def __eq__(self, other):
10590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10591 
 
10592 
  def __ne__(self, other):
10593 
    return not (self == other)
10594 
 
559 chandransh 10595 
class addItemToCart_args:
10596 
  """
10597 
  Attributes:
10598 
   - cartId
10599 
   - itemId
10600 
   - quantity
3557 rajveer 10601 
   - sourceId
559 chandransh 10602 
  """
10603 
 
10604 
  thrift_spec = (
10605 
    None, # 0
10606 
    (1, TType.I64, 'cartId', None, None, ), # 1
10607 
    (2, TType.I64, 'itemId', None, None, ), # 2
10608 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10609 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10610 
  )
10611 
 
3557 rajveer 10612 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10613 
    self.cartId = cartId
10614 
    self.itemId = itemId
10615 
    self.quantity = quantity
3557 rajveer 10616 
    self.sourceId = sourceId
559 chandransh 10617 
 
10618 
  def read(self, iprot):
10619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10621 
      return
10622 
    iprot.readStructBegin()
10623 
    while True:
10624 
      (fname, ftype, fid) = iprot.readFieldBegin()
10625 
      if ftype == TType.STOP:
10626 
        break
10627 
      if fid == 1:
10628 
        if ftype == TType.I64:
10629 
          self.cartId = iprot.readI64();
10630 
        else:
10631 
          iprot.skip(ftype)
10632 
      elif fid == 2:
10633 
        if ftype == TType.I64:
10634 
          self.itemId = iprot.readI64();
10635 
        else:
10636 
          iprot.skip(ftype)
10637 
      elif fid == 3:
10638 
        if ftype == TType.I64:
10639 
          self.quantity = iprot.readI64();
10640 
        else:
10641 
          iprot.skip(ftype)
3557 rajveer 10642 
      elif fid == 4:
10643 
        if ftype == TType.I64:
10644 
          self.sourceId = iprot.readI64();
10645 
        else:
10646 
          iprot.skip(ftype)
559 chandransh 10647 
      else:
10648 
        iprot.skip(ftype)
10649 
      iprot.readFieldEnd()
10650 
    iprot.readStructEnd()
10651 
 
10652 
  def write(self, oprot):
10653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10655 
      return
10656 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10657 
    if self.cartId is not None:
559 chandransh 10658 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10659 
      oprot.writeI64(self.cartId)
10660 
      oprot.writeFieldEnd()
3431 rajveer 10661 
    if self.itemId is not None:
559 chandransh 10662 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10663 
      oprot.writeI64(self.itemId)
10664 
      oprot.writeFieldEnd()
3431 rajveer 10665 
    if self.quantity is not None:
559 chandransh 10666 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10667 
      oprot.writeI64(self.quantity)
10668 
      oprot.writeFieldEnd()
3557 rajveer 10669 
    if self.sourceId is not None:
10670 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10671 
      oprot.writeI64(self.sourceId)
10672 
      oprot.writeFieldEnd()
559 chandransh 10673 
    oprot.writeFieldStop()
10674 
    oprot.writeStructEnd()
10675 
 
3431 rajveer 10676 
  def validate(self):
10677 
    return
10678 
 
10679 
 
559 chandransh 10680 
  def __repr__(self):
10681 
    L = ['%s=%r' % (key, value)
10682 
      for key, value in self.__dict__.iteritems()]
10683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10684 
 
10685 
  def __eq__(self, other):
10686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10687 
 
10688 
  def __ne__(self, other):
10689 
    return not (self == other)
10690 
 
10691 
class addItemToCart_result:
10692 
  """
10693 
  Attributes:
2035 rajveer 10694 
   - success
559 chandransh 10695 
   - scx
10696 
  """
10697 
 
10698 
  thrift_spec = (
2035 rajveer 10699 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10700 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10701 
  )
10702 
 
2035 rajveer 10703 
  def __init__(self, success=None, scx=None,):
10704 
    self.success = success
559 chandransh 10705 
    self.scx = scx
10706 
 
10707 
  def read(self, iprot):
10708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10710 
      return
10711 
    iprot.readStructBegin()
10712 
    while True:
10713 
      (fname, ftype, fid) = iprot.readFieldBegin()
10714 
      if ftype == TType.STOP:
10715 
        break
2035 rajveer 10716 
      if fid == 0:
10717 
        if ftype == TType.STRING:
10718 
          self.success = iprot.readString();
10719 
        else:
10720 
          iprot.skip(ftype)
10721 
      elif fid == 1:
559 chandransh 10722 
        if ftype == TType.STRUCT:
10723 
          self.scx = ShoppingCartException()
10724 
          self.scx.read(iprot)
10725 
        else:
10726 
          iprot.skip(ftype)
10727 
      else:
10728 
        iprot.skip(ftype)
10729 
      iprot.readFieldEnd()
10730 
    iprot.readStructEnd()
10731 
 
10732 
  def write(self, oprot):
10733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10735 
      return
10736 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10737 
    if self.success is not None:
2035 rajveer 10738 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10739 
      oprot.writeString(self.success)
10740 
      oprot.writeFieldEnd()
3431 rajveer 10741 
    if self.scx is not None:
559 chandransh 10742 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10743 
      self.scx.write(oprot)
10744 
      oprot.writeFieldEnd()
10745 
    oprot.writeFieldStop()
10746 
    oprot.writeStructEnd()
10747 
 
3431 rajveer 10748 
  def validate(self):
10749 
    return
10750 
 
10751 
 
559 chandransh 10752 
  def __repr__(self):
10753 
    L = ['%s=%r' % (key, value)
10754 
      for key, value in self.__dict__.iteritems()]
10755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10756 
 
10757 
  def __eq__(self, other):
10758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10759 
 
10760 
  def __ne__(self, other):
10761 
    return not (self == other)
10762 
 
10763 
class deleteItemFromCart_args:
10764 
  """
10765 
  Attributes:
10766 
   - cartId
10767 
   - itemId
10768 
  """
10769 
 
10770 
  thrift_spec = (
10771 
    None, # 0
10772 
    (1, TType.I64, 'cartId', None, None, ), # 1
10773 
    (2, TType.I64, 'itemId', None, None, ), # 2
10774 
  )
10775 
 
10776 
  def __init__(self, cartId=None, itemId=None,):
10777 
    self.cartId = cartId
10778 
    self.itemId = itemId
10779 
 
10780 
  def read(self, iprot):
10781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10783 
      return
10784 
    iprot.readStructBegin()
10785 
    while True:
10786 
      (fname, ftype, fid) = iprot.readFieldBegin()
10787 
      if ftype == TType.STOP:
10788 
        break
10789 
      if fid == 1:
10790 
        if ftype == TType.I64:
10791 
          self.cartId = iprot.readI64();
10792 
        else:
10793 
          iprot.skip(ftype)
10794 
      elif fid == 2:
10795 
        if ftype == TType.I64:
10796 
          self.itemId = iprot.readI64();
10797 
        else:
10798 
          iprot.skip(ftype)
10799 
      else:
10800 
        iprot.skip(ftype)
10801 
      iprot.readFieldEnd()
10802 
    iprot.readStructEnd()
10803 
 
10804 
  def write(self, oprot):
10805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10807 
      return
10808 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10809 
    if self.cartId is not None:
559 chandransh 10810 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10811 
      oprot.writeI64(self.cartId)
10812 
      oprot.writeFieldEnd()
3431 rajveer 10813 
    if self.itemId is not None:
559 chandransh 10814 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10815 
      oprot.writeI64(self.itemId)
10816 
      oprot.writeFieldEnd()
10817 
    oprot.writeFieldStop()
10818 
    oprot.writeStructEnd()
10819 
 
3431 rajveer 10820 
  def validate(self):
10821 
    return
10822 
 
10823 
 
559 chandransh 10824 
  def __repr__(self):
10825 
    L = ['%s=%r' % (key, value)
10826 
      for key, value in self.__dict__.iteritems()]
10827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10828 
 
10829 
  def __eq__(self, other):
10830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10831 
 
10832 
  def __ne__(self, other):
10833 
    return not (self == other)
10834 
 
10835 
class deleteItemFromCart_result:
10836 
  """
10837 
  Attributes:
10838 
   - scx
10839 
  """
10840 
 
10841 
  thrift_spec = (
10842 
    None, # 0
10843 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10844 
  )
10845 
 
10846 
  def __init__(self, scx=None,):
10847 
    self.scx = scx
10848 
 
10849 
  def read(self, iprot):
10850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10852 
      return
10853 
    iprot.readStructBegin()
10854 
    while True:
10855 
      (fname, ftype, fid) = iprot.readFieldBegin()
10856 
      if ftype == TType.STOP:
10857 
        break
10858 
      if fid == 1:
10859 
        if ftype == TType.STRUCT:
10860 
          self.scx = ShoppingCartException()
10861 
          self.scx.read(iprot)
10862 
        else:
10863 
          iprot.skip(ftype)
10864 
      else:
10865 
        iprot.skip(ftype)
10866 
      iprot.readFieldEnd()
10867 
    iprot.readStructEnd()
10868 
 
10869 
  def write(self, oprot):
10870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10872 
      return
10873 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10874 
    if self.scx is not None:
559 chandransh 10875 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10876 
      self.scx.write(oprot)
10877 
      oprot.writeFieldEnd()
10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
3431 rajveer 10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
559 chandransh 10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
10896 
class addAddressToCart_args:
10897 
  """
10898 
  Attributes:
10899 
   - cartId
10900 
   - addressId
10901 
  """
10902 
 
10903 
  thrift_spec = (
10904 
    None, # 0
10905 
    (1, TType.I64, 'cartId', None, None, ), # 1
10906 
    (2, TType.I64, 'addressId', None, None, ), # 2
10907 
  )
10908 
 
10909 
  def __init__(self, cartId=None, addressId=None,):
10910 
    self.cartId = cartId
10911 
    self.addressId = addressId
10912 
 
10913 
  def read(self, iprot):
10914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10916 
      return
10917 
    iprot.readStructBegin()
10918 
    while True:
10919 
      (fname, ftype, fid) = iprot.readFieldBegin()
10920 
      if ftype == TType.STOP:
10921 
        break
10922 
      if fid == 1:
10923 
        if ftype == TType.I64:
10924 
          self.cartId = iprot.readI64();
10925 
        else:
10926 
          iprot.skip(ftype)
10927 
      elif fid == 2:
10928 
        if ftype == TType.I64:
10929 
          self.addressId = iprot.readI64();
10930 
        else:
10931 
          iprot.skip(ftype)
10932 
      else:
10933 
        iprot.skip(ftype)
10934 
      iprot.readFieldEnd()
10935 
    iprot.readStructEnd()
10936 
 
10937 
  def write(self, oprot):
10938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10940 
      return
10941 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 10942 
    if self.cartId is not None:
559 chandransh 10943 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10944 
      oprot.writeI64(self.cartId)
10945 
      oprot.writeFieldEnd()
3431 rajveer 10946 
    if self.addressId is not None:
559 chandransh 10947 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10948 
      oprot.writeI64(self.addressId)
10949 
      oprot.writeFieldEnd()
10950 
    oprot.writeFieldStop()
10951 
    oprot.writeStructEnd()
10952 
 
3431 rajveer 10953 
  def validate(self):
10954 
    return
10955 
 
10956 
 
559 chandransh 10957 
  def __repr__(self):
10958 
    L = ['%s=%r' % (key, value)
10959 
      for key, value in self.__dict__.iteritems()]
10960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10961 
 
10962 
  def __eq__(self, other):
10963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10964 
 
10965 
  def __ne__(self, other):
10966 
    return not (self == other)
10967 
 
10968 
class addAddressToCart_result:
575 chandransh 10969 
  """
10970 
  Attributes:
10971 
   - scx
10972 
  """
559 chandransh 10973 
 
10974 
  thrift_spec = (
575 chandransh 10975 
    None, # 0
10976 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10977 
  )
10978 
 
575 chandransh 10979 
  def __init__(self, scx=None,):
10980 
    self.scx = scx
10981 
 
559 chandransh 10982 
  def read(self, iprot):
10983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10985 
      return
10986 
    iprot.readStructBegin()
10987 
    while True:
10988 
      (fname, ftype, fid) = iprot.readFieldBegin()
10989 
      if ftype == TType.STOP:
10990 
        break
575 chandransh 10991 
      if fid == 1:
10992 
        if ftype == TType.STRUCT:
10993 
          self.scx = ShoppingCartException()
10994 
          self.scx.read(iprot)
10995 
        else:
10996 
          iprot.skip(ftype)
559 chandransh 10997 
      else:
10998 
        iprot.skip(ftype)
10999 
      iprot.readFieldEnd()
11000 
    iprot.readStructEnd()
11001 
 
11002 
  def write(self, oprot):
11003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11005 
      return
11006 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11007 
    if self.scx is not None:
575 chandransh 11008 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11009 
      self.scx.write(oprot)
11010 
      oprot.writeFieldEnd()
559 chandransh 11011 
    oprot.writeFieldStop()
11012 
    oprot.writeStructEnd()
11013 
 
3431 rajveer 11014 
  def validate(self):
11015 
    return
11016 
 
11017 
 
559 chandransh 11018 
  def __repr__(self):
11019 
    L = ['%s=%r' % (key, value)
11020 
      for key, value in self.__dict__.iteritems()]
11021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11022 
 
11023 
  def __eq__(self, other):
11024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11025 
 
11026 
  def __ne__(self, other):
11027 
    return not (self == other)
11028 
 
5553 rajveer 11029 
class addStoreToCart_args:
11030 
  """
11031 
  Attributes:
11032 
   - cartId
11033 
   - storeId
11034 
  """
11035 
 
11036 
  thrift_spec = (
11037 
    None, # 0
11038 
    (1, TType.I64, 'cartId', None, None, ), # 1
11039 
    (2, TType.I64, 'storeId', None, None, ), # 2
11040 
  )
11041 
 
11042 
  def __init__(self, cartId=None, storeId=None,):
11043 
    self.cartId = cartId
11044 
    self.storeId = storeId
11045 
 
11046 
  def read(self, iprot):
11047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11049 
      return
11050 
    iprot.readStructBegin()
11051 
    while True:
11052 
      (fname, ftype, fid) = iprot.readFieldBegin()
11053 
      if ftype == TType.STOP:
11054 
        break
11055 
      if fid == 1:
11056 
        if ftype == TType.I64:
11057 
          self.cartId = iprot.readI64();
11058 
        else:
11059 
          iprot.skip(ftype)
11060 
      elif fid == 2:
11061 
        if ftype == TType.I64:
11062 
          self.storeId = iprot.readI64();
11063 
        else:
11064 
          iprot.skip(ftype)
11065 
      else:
11066 
        iprot.skip(ftype)
11067 
      iprot.readFieldEnd()
11068 
    iprot.readStructEnd()
11069 
 
11070 
  def write(self, oprot):
11071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11073 
      return
11074 
    oprot.writeStructBegin('addStoreToCart_args')
11075 
    if self.cartId is not None:
11076 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11077 
      oprot.writeI64(self.cartId)
11078 
      oprot.writeFieldEnd()
11079 
    if self.storeId is not None:
11080 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11081 
      oprot.writeI64(self.storeId)
11082 
      oprot.writeFieldEnd()
11083 
    oprot.writeFieldStop()
11084 
    oprot.writeStructEnd()
11085 
 
11086 
  def validate(self):
11087 
    return
11088 
 
11089 
 
11090 
  def __repr__(self):
11091 
    L = ['%s=%r' % (key, value)
11092 
      for key, value in self.__dict__.iteritems()]
11093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11094 
 
11095 
  def __eq__(self, other):
11096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11097 
 
11098 
  def __ne__(self, other):
11099 
    return not (self == other)
11100 
 
11101 
class addStoreToCart_result:
11102 
  """
11103 
  Attributes:
11104 
   - scx
11105 
  """
11106 
 
11107 
  thrift_spec = (
11108 
    None, # 0
11109 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11110 
  )
11111 
 
11112 
  def __init__(self, scx=None,):
11113 
    self.scx = scx
11114 
 
11115 
  def read(self, iprot):
11116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11118 
      return
11119 
    iprot.readStructBegin()
11120 
    while True:
11121 
      (fname, ftype, fid) = iprot.readFieldBegin()
11122 
      if ftype == TType.STOP:
11123 
        break
11124 
      if fid == 1:
11125 
        if ftype == TType.STRUCT:
11126 
          self.scx = ShoppingCartException()
11127 
          self.scx.read(iprot)
11128 
        else:
11129 
          iprot.skip(ftype)
11130 
      else:
11131 
        iprot.skip(ftype)
11132 
      iprot.readFieldEnd()
11133 
    iprot.readStructEnd()
11134 
 
11135 
  def write(self, oprot):
11136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11138 
      return
11139 
    oprot.writeStructBegin('addStoreToCart_result')
11140 
    if self.scx is not None:
11141 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11142 
      self.scx.write(oprot)
11143 
      oprot.writeFieldEnd()
11144 
    oprot.writeFieldStop()
11145 
    oprot.writeStructEnd()
11146 
 
11147 
  def validate(self):
11148 
    return
11149 
 
11150 
 
11151 
  def __repr__(self):
11152 
    L = ['%s=%r' % (key, value)
11153 
      for key, value in self.__dict__.iteritems()]
11154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11155 
 
11156 
  def __eq__(self, other):
11157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11158 
 
11159 
  def __ne__(self, other):
11160 
    return not (self == other)
11161 
 
1976 varun.gupt 11162 
class applyCouponToCart_args:
11163 
  """
11164 
  Attributes:
6922 anupam.sin 11165 
   - cart
1976 varun.gupt 11166 
   - couponCode
11167 
  """
11168 
 
11169 
  thrift_spec = (
11170 
    None, # 0
6922 anupam.sin 11171 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11172 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11173 
  )
11174 
 
6922 anupam.sin 11175 
  def __init__(self, cart=None, couponCode=None,):
11176 
    self.cart = cart
1976 varun.gupt 11177 
    self.couponCode = couponCode
11178 
 
11179 
  def read(self, iprot):
11180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11182 
      return
11183 
    iprot.readStructBegin()
11184 
    while True:
11185 
      (fname, ftype, fid) = iprot.readFieldBegin()
11186 
      if ftype == TType.STOP:
11187 
        break
11188 
      if fid == 1:
6922 anupam.sin 11189 
        if ftype == TType.STRUCT:
11190 
          self.cart = Cart()
11191 
          self.cart.read(iprot)
1976 varun.gupt 11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      elif fid == 2:
11195 
        if ftype == TType.STRING:
11196 
          self.couponCode = iprot.readString();
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      else:
11200 
        iprot.skip(ftype)
11201 
      iprot.readFieldEnd()
11202 
    iprot.readStructEnd()
11203 
 
11204 
  def write(self, oprot):
11205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11207 
      return
11208 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11209 
    if self.cart is not None:
11210 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11211 
      self.cart.write(oprot)
1976 varun.gupt 11212 
      oprot.writeFieldEnd()
3431 rajveer 11213 
    if self.couponCode is not None:
1976 varun.gupt 11214 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11215 
      oprot.writeString(self.couponCode)
11216 
      oprot.writeFieldEnd()
11217 
    oprot.writeFieldStop()
11218 
    oprot.writeStructEnd()
11219 
 
3431 rajveer 11220 
  def validate(self):
11221 
    return
11222 
 
11223 
 
1976 varun.gupt 11224 
  def __repr__(self):
11225 
    L = ['%s=%r' % (key, value)
11226 
      for key, value in self.__dict__.iteritems()]
11227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11228 
 
11229 
  def __eq__(self, other):
11230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11231 
 
11232 
  def __ne__(self, other):
11233 
    return not (self == other)
11234 
 
11235 
class applyCouponToCart_result:
11236 
  """
11237 
  Attributes:
11238 
   - scx
11239 
  """
11240 
 
11241 
  thrift_spec = (
11242 
    None, # 0
11243 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11244 
  )
11245 
 
11246 
  def __init__(self, scx=None,):
11247 
    self.scx = scx
11248 
 
11249 
  def read(self, iprot):
11250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11252 
      return
11253 
    iprot.readStructBegin()
11254 
    while True:
11255 
      (fname, ftype, fid) = iprot.readFieldBegin()
11256 
      if ftype == TType.STOP:
11257 
        break
11258 
      if fid == 1:
11259 
        if ftype == TType.STRUCT:
11260 
          self.scx = ShoppingCartException()
11261 
          self.scx.read(iprot)
11262 
        else:
11263 
          iprot.skip(ftype)
11264 
      else:
11265 
        iprot.skip(ftype)
11266 
      iprot.readFieldEnd()
11267 
    iprot.readStructEnd()
11268 
 
11269 
  def write(self, oprot):
11270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11272 
      return
11273 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11274 
    if self.scx is not None:
1976 varun.gupt 11275 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11276 
      self.scx.write(oprot)
11277 
      oprot.writeFieldEnd()
11278 
    oprot.writeFieldStop()
11279 
    oprot.writeStructEnd()
11280 
 
3431 rajveer 11281 
  def validate(self):
11282 
    return
11283 
 
11284 
 
1976 varun.gupt 11285 
  def __repr__(self):
11286 
    L = ['%s=%r' % (key, value)
11287 
      for key, value in self.__dict__.iteritems()]
11288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11289 
 
11290 
  def __eq__(self, other):
11291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11292 
 
11293 
  def __ne__(self, other):
11294 
    return not (self == other)
11295 
 
11296 
class removeCoupon_args:
11297 
  """
11298 
  Attributes:
11299 
   - cartId
11300 
  """
11301 
 
11302 
  thrift_spec = (
11303 
    None, # 0
11304 
    (1, TType.I64, 'cartId', None, None, ), # 1
11305 
  )
11306 
 
11307 
  def __init__(self, cartId=None,):
11308 
    self.cartId = cartId
11309 
 
11310 
  def read(self, iprot):
11311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11313 
      return
11314 
    iprot.readStructBegin()
11315 
    while True:
11316 
      (fname, ftype, fid) = iprot.readFieldBegin()
11317 
      if ftype == TType.STOP:
11318 
        break
11319 
      if fid == 1:
11320 
        if ftype == TType.I64:
11321 
          self.cartId = iprot.readI64();
11322 
        else:
11323 
          iprot.skip(ftype)
11324 
      else:
11325 
        iprot.skip(ftype)
11326 
      iprot.readFieldEnd()
11327 
    iprot.readStructEnd()
11328 
 
11329 
  def write(self, oprot):
11330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11332 
      return
11333 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11334 
    if self.cartId is not None:
1976 varun.gupt 11335 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11336 
      oprot.writeI64(self.cartId)
11337 
      oprot.writeFieldEnd()
11338 
    oprot.writeFieldStop()
11339 
    oprot.writeStructEnd()
11340 
 
3431 rajveer 11341 
  def validate(self):
11342 
    return
11343 
 
11344 
 
1976 varun.gupt 11345 
  def __repr__(self):
11346 
    L = ['%s=%r' % (key, value)
11347 
      for key, value in self.__dict__.iteritems()]
11348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11349 
 
11350 
  def __eq__(self, other):
11351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11352 
 
11353 
  def __ne__(self, other):
11354 
    return not (self == other)
11355 
 
11356 
class removeCoupon_result:
11357 
  """
11358 
  Attributes:
11359 
   - scx
11360 
  """
11361 
 
11362 
  thrift_spec = (
11363 
    None, # 0
11364 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11365 
  )
11366 
 
11367 
  def __init__(self, scx=None,):
11368 
    self.scx = scx
11369 
 
11370 
  def read(self, iprot):
11371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11373 
      return
11374 
    iprot.readStructBegin()
11375 
    while True:
11376 
      (fname, ftype, fid) = iprot.readFieldBegin()
11377 
      if ftype == TType.STOP:
11378 
        break
11379 
      if fid == 1:
11380 
        if ftype == TType.STRUCT:
11381 
          self.scx = ShoppingCartException()
11382 
          self.scx.read(iprot)
11383 
        else:
11384 
          iprot.skip(ftype)
11385 
      else:
11386 
        iprot.skip(ftype)
11387 
      iprot.readFieldEnd()
11388 
    iprot.readStructEnd()
11389 
 
11390 
  def write(self, oprot):
11391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11393 
      return
11394 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11395 
    if self.scx is not None:
1976 varun.gupt 11396 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11397 
      self.scx.write(oprot)
11398 
      oprot.writeFieldEnd()
11399 
    oprot.writeFieldStop()
11400 
    oprot.writeStructEnd()
11401 
 
3431 rajveer 11402 
  def validate(self):
11403 
    return
11404 
 
11405 
 
1976 varun.gupt 11406 
  def __repr__(self):
11407 
    L = ['%s=%r' % (key, value)
11408 
      for key, value in self.__dict__.iteritems()]
11409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11410 
 
11411 
  def __eq__(self, other):
11412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11413 
 
11414 
  def __ne__(self, other):
11415 
    return not (self == other)
11416 
 
3554 varun.gupt 11417 
class deleteDiscountsFromCart_args:
11418 
  """
11419 
  Attributes:
11420 
   - cartId
11421 
  """
11422 
 
11423 
  thrift_spec = (
11424 
    None, # 0
11425 
    (1, TType.I64, 'cartId', None, None, ), # 1
11426 
  )
11427 
 
11428 
  def __init__(self, cartId=None,):
11429 
    self.cartId = cartId
11430 
 
11431 
  def read(self, iprot):
11432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11434 
      return
11435 
    iprot.readStructBegin()
11436 
    while True:
11437 
      (fname, ftype, fid) = iprot.readFieldBegin()
11438 
      if ftype == TType.STOP:
11439 
        break
11440 
      if fid == 1:
11441 
        if ftype == TType.I64:
11442 
          self.cartId = iprot.readI64();
11443 
        else:
11444 
          iprot.skip(ftype)
11445 
      else:
11446 
        iprot.skip(ftype)
11447 
      iprot.readFieldEnd()
11448 
    iprot.readStructEnd()
11449 
 
11450 
  def write(self, oprot):
11451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11453 
      return
11454 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11455 
    if self.cartId is not None:
11456 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11457 
      oprot.writeI64(self.cartId)
11458 
      oprot.writeFieldEnd()
11459 
    oprot.writeFieldStop()
11460 
    oprot.writeStructEnd()
11461 
 
11462 
  def validate(self):
11463 
    return
11464 
 
11465 
 
11466 
  def __repr__(self):
11467 
    L = ['%s=%r' % (key, value)
11468 
      for key, value in self.__dict__.iteritems()]
11469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11470 
 
11471 
  def __eq__(self, other):
11472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11473 
 
11474 
  def __ne__(self, other):
11475 
    return not (self == other)
11476 
 
11477 
class deleteDiscountsFromCart_result:
11478 
  """
11479 
  Attributes:
11480 
   - scx
11481 
  """
11482 
 
11483 
  thrift_spec = (
11484 
    None, # 0
11485 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11486 
  )
11487 
 
11488 
  def __init__(self, scx=None,):
11489 
    self.scx = scx
11490 
 
11491 
  def read(self, iprot):
11492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11494 
      return
11495 
    iprot.readStructBegin()
11496 
    while True:
11497 
      (fname, ftype, fid) = iprot.readFieldBegin()
11498 
      if ftype == TType.STOP:
11499 
        break
11500 
      if fid == 1:
11501 
        if ftype == TType.STRUCT:
11502 
          self.scx = ShoppingCartException()
11503 
          self.scx.read(iprot)
11504 
        else:
11505 
          iprot.skip(ftype)
11506 
      else:
11507 
        iprot.skip(ftype)
11508 
      iprot.readFieldEnd()
11509 
    iprot.readStructEnd()
11510 
 
11511 
  def write(self, oprot):
11512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11514 
      return
11515 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11516 
    if self.scx is not None:
11517 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11518 
      self.scx.write(oprot)
11519 
      oprot.writeFieldEnd()
11520 
    oprot.writeFieldStop()
11521 
    oprot.writeStructEnd()
11522 
 
11523 
  def validate(self):
11524 
    return
11525 
 
11526 
 
11527 
  def __repr__(self):
11528 
    L = ['%s=%r' % (key, value)
11529 
      for key, value in self.__dict__.iteritems()]
11530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11531 
 
11532 
  def __eq__(self, other):
11533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11534 
 
11535 
  def __ne__(self, other):
11536 
    return not (self == other)
11537 
 
11538 
class saveDiscounts_args:
11539 
  """
11540 
  Attributes:
11541 
   - discounts
11542 
  """
11543 
 
11544 
  thrift_spec = (
11545 
    None, # 0
11546 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11547 
  )
11548 
 
11549 
  def __init__(self, discounts=None,):
11550 
    self.discounts = discounts
11551 
 
11552 
  def read(self, iprot):
11553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11555 
      return
11556 
    iprot.readStructBegin()
11557 
    while True:
11558 
      (fname, ftype, fid) = iprot.readFieldBegin()
11559 
      if ftype == TType.STOP:
11560 
        break
11561 
      if fid == 1:
11562 
        if ftype == TType.LIST:
11563 
          self.discounts = []
11592 amit.gupta 11564 
          (_etype163, _size160) = iprot.readListBegin()
11565 
          for _i164 in xrange(_size160):
11566 
            _elem165 = Discount()
11567 
            _elem165.read(iprot)
11568 
            self.discounts.append(_elem165)
3554 varun.gupt 11569 
          iprot.readListEnd()
11570 
        else:
11571 
          iprot.skip(ftype)
11572 
      else:
11573 
        iprot.skip(ftype)
11574 
      iprot.readFieldEnd()
11575 
    iprot.readStructEnd()
11576 
 
11577 
  def write(self, oprot):
11578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11580 
      return
11581 
    oprot.writeStructBegin('saveDiscounts_args')
11582 
    if self.discounts is not None:
11583 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11584 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11585 
      for iter166 in self.discounts:
11586 
        iter166.write(oprot)
3554 varun.gupt 11587 
      oprot.writeListEnd()
11588 
      oprot.writeFieldEnd()
11589 
    oprot.writeFieldStop()
11590 
    oprot.writeStructEnd()
11591 
 
11592 
  def validate(self):
11593 
    return
11594 
 
11595 
 
11596 
  def __repr__(self):
11597 
    L = ['%s=%r' % (key, value)
11598 
      for key, value in self.__dict__.iteritems()]
11599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11600 
 
11601 
  def __eq__(self, other):
11602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11603 
 
11604 
  def __ne__(self, other):
11605 
    return not (self == other)
11606 
 
11607 
class saveDiscounts_result:
11608 
  """
11609 
  Attributes:
11610 
   - scx
11611 
  """
11612 
 
11613 
  thrift_spec = (
11614 
    None, # 0
11615 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11616 
  )
11617 
 
11618 
  def __init__(self, scx=None,):
11619 
    self.scx = scx
11620 
 
11621 
  def read(self, iprot):
11622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11624 
      return
11625 
    iprot.readStructBegin()
11626 
    while True:
11627 
      (fname, ftype, fid) = iprot.readFieldBegin()
11628 
      if ftype == TType.STOP:
11629 
        break
11630 
      if fid == 1:
11631 
        if ftype == TType.STRUCT:
11632 
          self.scx = ShoppingCartException()
11633 
          self.scx.read(iprot)
11634 
        else:
11635 
          iprot.skip(ftype)
11636 
      else:
11637 
        iprot.skip(ftype)
11638 
      iprot.readFieldEnd()
11639 
    iprot.readStructEnd()
11640 
 
11641 
  def write(self, oprot):
11642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11644 
      return
11645 
    oprot.writeStructBegin('saveDiscounts_result')
11646 
    if self.scx is not None:
11647 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11648 
      self.scx.write(oprot)
11649 
      oprot.writeFieldEnd()
11650 
    oprot.writeFieldStop()
11651 
    oprot.writeStructEnd()
11652 
 
11653 
  def validate(self):
11654 
    return
11655 
 
11656 
 
11657 
  def __repr__(self):
11658 
    L = ['%s=%r' % (key, value)
11659 
      for key, value in self.__dict__.iteritems()]
11660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11661 
 
11662 
  def __eq__(self, other):
11663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11664 
 
11665 
  def __ne__(self, other):
11666 
    return not (self == other)
11667 
 
690 chandransh 11668 
class createOrders_args:
559 chandransh 11669 
  """
11670 
  Attributes:
11671 
   - cartId
2815 vikas 11672 
   - sessionSource
11673 
   - sessionStartTime
3858 vikas 11674 
   - firstSource
11675 
   - firstSourceTime
5326 rajveer 11676 
   - userId
6389 rajveer 11677 
   - schemeId
11526 amit.gupta 11678 
   - orderSource
559 chandransh 11679 
  """
11680 
 
11681 
  thrift_spec = (
11682 
    None, # 0
11683 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11684 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11685 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11686 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11687 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11688 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11689 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11690 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11691 
  )
11692 
 
11526 amit.gupta 11693 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11694 
    self.cartId = cartId
2815 vikas 11695 
    self.sessionSource = sessionSource
11696 
    self.sessionStartTime = sessionStartTime
3858 vikas 11697 
    self.firstSource = firstSource
11698 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11699 
    self.userId = userId
6389 rajveer 11700 
    self.schemeId = schemeId
11526 amit.gupta 11701 
    self.orderSource = orderSource
559 chandransh 11702 
 
11703 
  def read(self, iprot):
11704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11706 
      return
11707 
    iprot.readStructBegin()
11708 
    while True:
11709 
      (fname, ftype, fid) = iprot.readFieldBegin()
11710 
      if ftype == TType.STOP:
11711 
        break
11712 
      if fid == 1:
11713 
        if ftype == TType.I64:
11714 
          self.cartId = iprot.readI64();
11715 
        else:
11716 
          iprot.skip(ftype)
2815 vikas 11717 
      elif fid == 2:
11718 
        if ftype == TType.STRING:
11719 
          self.sessionSource = iprot.readString();
11720 
        else:
11721 
          iprot.skip(ftype)
11722 
      elif fid == 3:
11723 
        if ftype == TType.I64:
11724 
          self.sessionStartTime = iprot.readI64();
11725 
        else:
11726 
          iprot.skip(ftype)
3858 vikas 11727 
      elif fid == 4:
11728 
        if ftype == TType.STRING:
11729 
          self.firstSource = iprot.readString();
11730 
        else:
11731 
          iprot.skip(ftype)
11732 
      elif fid == 5:
11733 
        if ftype == TType.I64:
11734 
          self.firstSourceTime = iprot.readI64();
11735 
        else:
11736 
          iprot.skip(ftype)
5326 rajveer 11737 
      elif fid == 6:
11738 
        if ftype == TType.I64:
11739 
          self.userId = iprot.readI64();
11740 
        else:
11741 
          iprot.skip(ftype)
6389 rajveer 11742 
      elif fid == 7:
11743 
        if ftype == TType.I64:
11744 
          self.schemeId = iprot.readI64();
11745 
        else:
11746 
          iprot.skip(ftype)
11526 amit.gupta 11747 
      elif fid == 8:
11748 
        if ftype == TType.I64:
11749 
          self.orderSource = iprot.readI64();
11750 
        else:
11751 
          iprot.skip(ftype)
559 chandransh 11752 
      else:
11753 
        iprot.skip(ftype)
11754 
      iprot.readFieldEnd()
11755 
    iprot.readStructEnd()
11756 
 
11757 
  def write(self, oprot):
11758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11760 
      return
690 chandransh 11761 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11762 
    if self.cartId is not None:
559 chandransh 11763 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11764 
      oprot.writeI64(self.cartId)
11765 
      oprot.writeFieldEnd()
3431 rajveer 11766 
    if self.sessionSource is not None:
2815 vikas 11767 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11768 
      oprot.writeString(self.sessionSource)
11769 
      oprot.writeFieldEnd()
3431 rajveer 11770 
    if self.sessionStartTime is not None:
2815 vikas 11771 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11772 
      oprot.writeI64(self.sessionStartTime)
11773 
      oprot.writeFieldEnd()
3858 vikas 11774 
    if self.firstSource is not None:
11775 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11776 
      oprot.writeString(self.firstSource)
11777 
      oprot.writeFieldEnd()
11778 
    if self.firstSourceTime is not None:
11779 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11780 
      oprot.writeI64(self.firstSourceTime)
11781 
      oprot.writeFieldEnd()
5326 rajveer 11782 
    if self.userId is not None:
11783 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11784 
      oprot.writeI64(self.userId)
11785 
      oprot.writeFieldEnd()
6389 rajveer 11786 
    if self.schemeId is not None:
11787 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11788 
      oprot.writeI64(self.schemeId)
11789 
      oprot.writeFieldEnd()
11526 amit.gupta 11790 
    if self.orderSource is not None:
11791 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
11792 
      oprot.writeI64(self.orderSource)
11793 
      oprot.writeFieldEnd()
559 chandransh 11794 
    oprot.writeFieldStop()
11795 
    oprot.writeStructEnd()
11796 
 
3431 rajveer 11797 
  def validate(self):
11798 
    return
11799 
 
11800 
 
559 chandransh 11801 
  def __repr__(self):
11802 
    L = ['%s=%r' % (key, value)
11803 
      for key, value in self.__dict__.iteritems()]
11804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11805 
 
11806 
  def __eq__(self, other):
11807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11808 
 
11809 
  def __ne__(self, other):
11810 
    return not (self == other)
11811 
 
690 chandransh 11812 
class createOrders_result:
559 chandransh 11813 
  """
11814 
  Attributes:
94 ashish 11815 
   - success
559 chandransh 11816 
   - scx
94 ashish 11817 
  """
11818 
 
11819 
  thrift_spec = (
575 chandransh 11820 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11821 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11822 
  )
11823 
 
559 chandransh 11824 
  def __init__(self, success=None, scx=None,):
94 ashish 11825 
    self.success = success
559 chandransh 11826 
    self.scx = scx
94 ashish 11827 
 
11828 
  def read(self, iprot):
11829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11831 
      return
11832 
    iprot.readStructBegin()
11833 
    while True:
11834 
      (fname, ftype, fid) = iprot.readFieldBegin()
11835 
      if ftype == TType.STOP:
11836 
        break
11837 
      if fid == 0:
575 chandransh 11838 
        if ftype == TType.I64:
11839 
          self.success = iprot.readI64();
94 ashish 11840 
        else:
11841 
          iprot.skip(ftype)
11842 
      elif fid == 1:
11843 
        if ftype == TType.STRUCT:
559 chandransh 11844 
          self.scx = ShoppingCartException()
11845 
          self.scx.read(iprot)
94 ashish 11846 
        else:
11847 
          iprot.skip(ftype)
11848 
      else:
11849 
        iprot.skip(ftype)
11850 
      iprot.readFieldEnd()
11851 
    iprot.readStructEnd()
11852 
 
11853 
  def write(self, oprot):
11854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11856 
      return
690 chandransh 11857 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11858 
    if self.success is not None:
575 chandransh 11859 
      oprot.writeFieldBegin('success', TType.I64, 0)
11860 
      oprot.writeI64(self.success)
94 ashish 11861 
      oprot.writeFieldEnd()
3431 rajveer 11862 
    if self.scx is not None:
559 chandransh 11863 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11864 
      self.scx.write(oprot)
94 ashish 11865 
      oprot.writeFieldEnd()
11866 
    oprot.writeFieldStop()
11867 
    oprot.writeStructEnd()
11868 
 
3431 rajveer 11869 
  def validate(self):
11870 
    return
11871 
 
11872 
 
94 ashish 11873 
  def __repr__(self):
11874 
    L = ['%s=%r' % (key, value)
11875 
      for key, value in self.__dict__.iteritems()]
11876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11877 
 
11878 
  def __eq__(self, other):
11879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11880 
 
11881 
  def __ne__(self, other):
11882 
    return not (self == other)
11883 
 
559 chandransh 11884 
class validateCart_args:
94 ashish 11885 
  """
11886 
  Attributes:
559 chandransh 11887 
   - cartId
3557 rajveer 11888 
   - sourceId
94 ashish 11889 
  """
11890 
 
11891 
  thrift_spec = (
11892 
    None, # 0
559 chandransh 11893 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11894 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11895 
  )
11896 
 
3557 rajveer 11897 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11898 
    self.cartId = cartId
3557 rajveer 11899 
    self.sourceId = sourceId
94 ashish 11900 
 
11901 
  def read(self, iprot):
11902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11904 
      return
11905 
    iprot.readStructBegin()
11906 
    while True:
11907 
      (fname, ftype, fid) = iprot.readFieldBegin()
11908 
      if ftype == TType.STOP:
11909 
        break
11910 
      if fid == 1:
11911 
        if ftype == TType.I64:
559 chandransh 11912 
          self.cartId = iprot.readI64();
94 ashish 11913 
        else:
11914 
          iprot.skip(ftype)
3557 rajveer 11915 
      elif fid == 2:
11916 
        if ftype == TType.I64:
11917 
          self.sourceId = iprot.readI64();
11918 
        else:
11919 
          iprot.skip(ftype)
94 ashish 11920 
      else:
11921 
        iprot.skip(ftype)
11922 
      iprot.readFieldEnd()
11923 
    iprot.readStructEnd()
11924 
 
11925 
  def write(self, oprot):
11926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11928 
      return
559 chandransh 11929 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 11930 
    if self.cartId is not None:
559 chandransh 11931 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11932 
      oprot.writeI64(self.cartId)
94 ashish 11933 
      oprot.writeFieldEnd()
3557 rajveer 11934 
    if self.sourceId is not None:
11935 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11936 
      oprot.writeI64(self.sourceId)
11937 
      oprot.writeFieldEnd()
94 ashish 11938 
    oprot.writeFieldStop()
11939 
    oprot.writeStructEnd()
11940 
 
3431 rajveer 11941 
  def validate(self):
11942 
    return
11943 
 
11944 
 
94 ashish 11945 
  def __repr__(self):
11946 
    L = ['%s=%r' % (key, value)
11947 
      for key, value in self.__dict__.iteritems()]
11948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11949 
 
11950 
  def __eq__(self, other):
11951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11952 
 
11953 
  def __ne__(self, other):
11954 
    return not (self == other)
11955 
 
559 chandransh 11956 
class validateCart_result:
94 ashish 11957 
  """
11958 
  Attributes:
11959 
   - success
575 chandransh 11960 
   - scex
94 ashish 11961 
  """
11962 
 
11963 
  thrift_spec = (
6736 amit.gupta 11964 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 11965 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11966 
  )
11967 
 
575 chandransh 11968 
  def __init__(self, success=None, scex=None,):
94 ashish 11969 
    self.success = success
575 chandransh 11970 
    self.scex = scex
94 ashish 11971 
 
11972 
  def read(self, iprot):
11973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11975 
      return
11976 
    iprot.readStructBegin()
11977 
    while True:
11978 
      (fname, ftype, fid) = iprot.readFieldBegin()
11979 
      if ftype == TType.STOP:
11980 
        break
11981 
      if fid == 0:
6736 amit.gupta 11982 
        if ftype == TType.LIST:
11983 
          self.success = []
11592 amit.gupta 11984 
          (_etype170, _size167) = iprot.readListBegin()
11985 
          for _i171 in xrange(_size167):
11986 
            _elem172 = iprot.readString();
11987 
            self.success.append(_elem172)
6736 amit.gupta 11988 
          iprot.readListEnd()
94 ashish 11989 
        else:
11990 
          iprot.skip(ftype)
575 chandransh 11991 
      elif fid == 1:
11992 
        if ftype == TType.STRUCT:
11993 
          self.scex = ShoppingCartException()
11994 
          self.scex.read(iprot)
11995 
        else:
11996 
          iprot.skip(ftype)
94 ashish 11997 
      else:
11998 
        iprot.skip(ftype)
11999 
      iprot.readFieldEnd()
12000 
    iprot.readStructEnd()
12001 
 
12002 
  def write(self, oprot):
12003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12005 
      return
559 chandransh 12006 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12007 
    if self.success is not None:
6736 amit.gupta 12008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12009 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12010 
      for iter173 in self.success:
12011 
        oprot.writeString(iter173)
6736 amit.gupta 12012 
      oprot.writeListEnd()
94 ashish 12013 
      oprot.writeFieldEnd()
3431 rajveer 12014 
    if self.scex is not None:
575 chandransh 12015 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12016 
      self.scex.write(oprot)
12017 
      oprot.writeFieldEnd()
559 chandransh 12018 
    oprot.writeFieldStop()
12019 
    oprot.writeStructEnd()
12020 
 
3431 rajveer 12021 
  def validate(self):
12022 
    return
12023 
 
12024 
 
559 chandransh 12025 
  def __repr__(self):
12026 
    L = ['%s=%r' % (key, value)
12027 
      for key, value in self.__dict__.iteritems()]
12028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12029 
 
12030 
  def __eq__(self, other):
12031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12032 
 
12033 
  def __ne__(self, other):
12034 
    return not (self == other)
12035 
 
11980 amit.gupta 12036 
class validateCartWithDealerCoupon_args:
12037 
  """
12038 
  Attributes:
12039 
   - cartId
12040 
   - sourceId
12041 
   - dealCoupon
12042 
  """
12043 
 
12044 
  thrift_spec = (
12045 
    None, # 0
12046 
    (1, TType.I64, 'cartId', None, None, ), # 1
12047 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12048 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12049 
  )
12050 
 
12051 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12052 
    self.cartId = cartId
12053 
    self.sourceId = sourceId
12054 
    self.dealCoupon = dealCoupon
12055 
 
12056 
  def read(self, iprot):
12057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12059 
      return
12060 
    iprot.readStructBegin()
12061 
    while True:
12062 
      (fname, ftype, fid) = iprot.readFieldBegin()
12063 
      if ftype == TType.STOP:
12064 
        break
12065 
      if fid == 1:
12066 
        if ftype == TType.I64:
12067 
          self.cartId = iprot.readI64();
12068 
        else:
12069 
          iprot.skip(ftype)
12070 
      elif fid == 2:
12071 
        if ftype == TType.I64:
12072 
          self.sourceId = iprot.readI64();
12073 
        else:
12074 
          iprot.skip(ftype)
12075 
      elif fid == 3:
12076 
        if ftype == TType.STRING:
12077 
          self.dealCoupon = iprot.readString();
12078 
        else:
12079 
          iprot.skip(ftype)
12080 
      else:
12081 
        iprot.skip(ftype)
12082 
      iprot.readFieldEnd()
12083 
    iprot.readStructEnd()
12084 
 
12085 
  def write(self, oprot):
12086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12088 
      return
12089 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12090 
    if self.cartId is not None:
12091 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12092 
      oprot.writeI64(self.cartId)
12093 
      oprot.writeFieldEnd()
12094 
    if self.sourceId is not None:
12095 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12096 
      oprot.writeI64(self.sourceId)
12097 
      oprot.writeFieldEnd()
12098 
    if self.dealCoupon is not None:
12099 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12100 
      oprot.writeString(self.dealCoupon)
12101 
      oprot.writeFieldEnd()
12102 
    oprot.writeFieldStop()
12103 
    oprot.writeStructEnd()
12104 
 
12105 
  def validate(self):
12106 
    return
12107 
 
12108 
 
12109 
  def __repr__(self):
12110 
    L = ['%s=%r' % (key, value)
12111 
      for key, value in self.__dict__.iteritems()]
12112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12113 
 
12114 
  def __eq__(self, other):
12115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12116 
 
12117 
  def __ne__(self, other):
12118 
    return not (self == other)
12119 
 
12120 
class validateCartWithDealerCoupon_result:
12121 
  """
12122 
  Attributes:
12123 
   - success
12124 
   - scex
12125 
  """
12126 
 
12127 
  thrift_spec = (
12128 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12129 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12130 
  )
12131 
 
12132 
  def __init__(self, success=None, scex=None,):
12133 
    self.success = success
12134 
    self.scex = scex
12135 
 
12136 
  def read(self, iprot):
12137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12139 
      return
12140 
    iprot.readStructBegin()
12141 
    while True:
12142 
      (fname, ftype, fid) = iprot.readFieldBegin()
12143 
      if ftype == TType.STOP:
12144 
        break
12145 
      if fid == 0:
12146 
        if ftype == TType.LIST:
12147 
          self.success = []
12148 
          (_etype177, _size174) = iprot.readListBegin()
12149 
          for _i178 in xrange(_size174):
12150 
            _elem179 = iprot.readString();
12151 
            self.success.append(_elem179)
12152 
          iprot.readListEnd()
12153 
        else:
12154 
          iprot.skip(ftype)
12155 
      elif fid == 1:
12156 
        if ftype == TType.STRUCT:
12157 
          self.scex = ShoppingCartException()
12158 
          self.scex.read(iprot)
12159 
        else:
12160 
          iprot.skip(ftype)
12161 
      else:
12162 
        iprot.skip(ftype)
12163 
      iprot.readFieldEnd()
12164 
    iprot.readStructEnd()
12165 
 
12166 
  def write(self, oprot):
12167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12169 
      return
12170 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12171 
    if self.success is not None:
12172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12173 
      oprot.writeListBegin(TType.STRING, len(self.success))
12174 
      for iter180 in self.success:
12175 
        oprot.writeString(iter180)
12176 
      oprot.writeListEnd()
12177 
      oprot.writeFieldEnd()
12178 
    if self.scex is not None:
12179 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12180 
      self.scex.write(oprot)
12181 
      oprot.writeFieldEnd()
12182 
    oprot.writeFieldStop()
12183 
    oprot.writeStructEnd()
12184 
 
12185 
  def validate(self):
12186 
    return
12187 
 
12188 
 
12189 
  def __repr__(self):
12190 
    L = ['%s=%r' % (key, value)
12191 
      for key, value in self.__dict__.iteritems()]
12192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12193 
 
12194 
  def __eq__(self, other):
12195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12196 
 
12197 
  def __ne__(self, other):
12198 
    return not (self == other)
12199 
 
690 chandransh 12200 
class mergeCart_args:
575 chandransh 12201 
  """
12202 
  Attributes:
690 chandransh 12203 
   - fromCartId
12204 
   - toCartId
12205 
  """
12206 
 
12207 
  thrift_spec = (
12208 
    None, # 0
12209 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12210 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12211 
  )
12212 
 
12213 
  def __init__(self, fromCartId=None, toCartId=None,):
12214 
    self.fromCartId = fromCartId
12215 
    self.toCartId = toCartId
12216 
 
12217 
  def read(self, iprot):
12218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12220 
      return
12221 
    iprot.readStructBegin()
12222 
    while True:
12223 
      (fname, ftype, fid) = iprot.readFieldBegin()
12224 
      if ftype == TType.STOP:
12225 
        break
12226 
      if fid == 1:
12227 
        if ftype == TType.I64:
12228 
          self.fromCartId = iprot.readI64();
12229 
        else:
12230 
          iprot.skip(ftype)
12231 
      elif fid == 2:
12232 
        if ftype == TType.I64:
12233 
          self.toCartId = iprot.readI64();
12234 
        else:
12235 
          iprot.skip(ftype)
12236 
      else:
12237 
        iprot.skip(ftype)
12238 
      iprot.readFieldEnd()
12239 
    iprot.readStructEnd()
12240 
 
12241 
  def write(self, oprot):
12242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12244 
      return
12245 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12246 
    if self.fromCartId is not None:
690 chandransh 12247 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12248 
      oprot.writeI64(self.fromCartId)
12249 
      oprot.writeFieldEnd()
3431 rajveer 12250 
    if self.toCartId is not None:
690 chandransh 12251 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12252 
      oprot.writeI64(self.toCartId)
12253 
      oprot.writeFieldEnd()
12254 
    oprot.writeFieldStop()
12255 
    oprot.writeStructEnd()
12256 
 
3431 rajveer 12257 
  def validate(self):
12258 
    return
12259 
 
12260 
 
690 chandransh 12261 
  def __repr__(self):
12262 
    L = ['%s=%r' % (key, value)
12263 
      for key, value in self.__dict__.iteritems()]
12264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12265 
 
12266 
  def __eq__(self, other):
12267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12268 
 
12269 
  def __ne__(self, other):
12270 
    return not (self == other)
12271 
 
12272 
class mergeCart_result:
12273 
 
12274 
  thrift_spec = (
12275 
  )
12276 
 
12277 
  def read(self, iprot):
12278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12280 
      return
12281 
    iprot.readStructBegin()
12282 
    while True:
12283 
      (fname, ftype, fid) = iprot.readFieldBegin()
12284 
      if ftype == TType.STOP:
12285 
        break
12286 
      else:
12287 
        iprot.skip(ftype)
12288 
      iprot.readFieldEnd()
12289 
    iprot.readStructEnd()
12290 
 
12291 
  def write(self, oprot):
12292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12294 
      return
12295 
    oprot.writeStructBegin('mergeCart_result')
12296 
    oprot.writeFieldStop()
12297 
    oprot.writeStructEnd()
12298 
 
3431 rajveer 12299 
  def validate(self):
12300 
    return
12301 
 
12302 
 
690 chandransh 12303 
  def __repr__(self):
12304 
    L = ['%s=%r' % (key, value)
12305 
      for key, value in self.__dict__.iteritems()]
12306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12307 
 
12308 
  def __eq__(self, other):
12309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12310 
 
12311 
  def __ne__(self, other):
12312 
    return not (self == other)
12313 
 
12314 
class checkOut_args:
12315 
  """
12316 
  Attributes:
575 chandransh 12317 
   - cartId
12318 
  """
12319 
 
12320 
  thrift_spec = (
12321 
    None, # 0
12322 
    (1, TType.I64, 'cartId', None, None, ), # 1
12323 
  )
12324 
 
12325 
  def __init__(self, cartId=None,):
12326 
    self.cartId = cartId
12327 
 
12328 
  def read(self, iprot):
12329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12331 
      return
12332 
    iprot.readStructBegin()
12333 
    while True:
12334 
      (fname, ftype, fid) = iprot.readFieldBegin()
12335 
      if ftype == TType.STOP:
12336 
        break
12337 
      if fid == 1:
12338 
        if ftype == TType.I64:
12339 
          self.cartId = iprot.readI64();
12340 
        else:
12341 
          iprot.skip(ftype)
12342 
      else:
12343 
        iprot.skip(ftype)
12344 
      iprot.readFieldEnd()
12345 
    iprot.readStructEnd()
12346 
 
12347 
  def write(self, oprot):
12348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12350 
      return
690 chandransh 12351 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12352 
    if self.cartId is not None:
575 chandransh 12353 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12354 
      oprot.writeI64(self.cartId)
12355 
      oprot.writeFieldEnd()
12356 
    oprot.writeFieldStop()
12357 
    oprot.writeStructEnd()
12358 
 
3431 rajveer 12359 
  def validate(self):
12360 
    return
12361 
 
12362 
 
575 chandransh 12363 
  def __repr__(self):
12364 
    L = ['%s=%r' % (key, value)
12365 
      for key, value in self.__dict__.iteritems()]
12366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12367 
 
12368 
  def __eq__(self, other):
12369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12370 
 
12371 
  def __ne__(self, other):
12372 
    return not (self == other)
12373 
 
690 chandransh 12374 
class checkOut_result:
575 chandransh 12375 
  """
12376 
  Attributes:
12377 
   - success
12378 
   - scex
12379 
  """
12380 
 
12381 
  thrift_spec = (
12382 
    (0, TType.BOOL, 'success', None, None, ), # 0
12383 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12384 
  )
12385 
 
12386 
  def __init__(self, success=None, scex=None,):
12387 
    self.success = success
12388 
    self.scex = scex
12389 
 
12390 
  def read(self, iprot):
12391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12393 
      return
12394 
    iprot.readStructBegin()
12395 
    while True:
12396 
      (fname, ftype, fid) = iprot.readFieldBegin()
12397 
      if ftype == TType.STOP:
12398 
        break
12399 
      if fid == 0:
12400 
        if ftype == TType.BOOL:
12401 
          self.success = iprot.readBool();
12402 
        else:
12403 
          iprot.skip(ftype)
12404 
      elif fid == 1:
12405 
        if ftype == TType.STRUCT:
12406 
          self.scex = ShoppingCartException()
12407 
          self.scex.read(iprot)
12408 
        else:
12409 
          iprot.skip(ftype)
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
690 chandransh 12419 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12420 
    if self.success is not None:
575 chandransh 12421 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12422 
      oprot.writeBool(self.success)
12423 
      oprot.writeFieldEnd()
3431 rajveer 12424 
    if self.scex is not None:
575 chandransh 12425 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12426 
      self.scex.write(oprot)
12427 
      oprot.writeFieldEnd()
12428 
    oprot.writeFieldStop()
12429 
    oprot.writeStructEnd()
12430 
 
3431 rajveer 12431 
  def validate(self):
12432 
    return
12433 
 
12434 
 
575 chandransh 12435 
  def __repr__(self):
12436 
    L = ['%s=%r' % (key, value)
12437 
      for key, value in self.__dict__.iteritems()]
12438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12439 
 
12440 
  def __eq__(self, other):
12441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12442 
 
12443 
  def __ne__(self, other):
12444 
    return not (self == other)
12445 
 
690 chandransh 12446 
class resetCart_args:
559 chandransh 12447 
  """
12448 
  Attributes:
690 chandransh 12449 
   - cartId
12450 
   - items
559 chandransh 12451 
  """
12452 
 
12453 
  thrift_spec = (
12454 
    None, # 0
690 chandransh 12455 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12456 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12457 
  )
12458 
 
690 chandransh 12459 
  def __init__(self, cartId=None, items=None,):
12460 
    self.cartId = cartId
12461 
    self.items = items
559 chandransh 12462 
 
12463 
  def read(self, iprot):
12464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12466 
      return
12467 
    iprot.readStructBegin()
12468 
    while True:
12469 
      (fname, ftype, fid) = iprot.readFieldBegin()
12470 
      if ftype == TType.STOP:
12471 
        break
12472 
      if fid == 1:
12473 
        if ftype == TType.I64:
690 chandransh 12474 
          self.cartId = iprot.readI64();
559 chandransh 12475 
        else:
12476 
          iprot.skip(ftype)
12477 
      elif fid == 2:
690 chandransh 12478 
        if ftype == TType.MAP:
12479 
          self.items = {}
11980 amit.gupta 12480 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12481 
          for _i185 in xrange(_size181):
12482 
            _key186 = iprot.readI64();
12483 
            _val187 = iprot.readDouble();
12484 
            self.items[_key186] = _val187
690 chandransh 12485 
          iprot.readMapEnd()
559 chandransh 12486 
        else:
12487 
          iprot.skip(ftype)
12488 
      else:
12489 
        iprot.skip(ftype)
12490 
      iprot.readFieldEnd()
12491 
    iprot.readStructEnd()
12492 
 
12493 
  def write(self, oprot):
12494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12496 
      return
690 chandransh 12497 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12498 
    if self.cartId is not None:
690 chandransh 12499 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12500 
      oprot.writeI64(self.cartId)
94 ashish 12501 
      oprot.writeFieldEnd()
3431 rajveer 12502 
    if self.items is not None:
690 chandransh 12503 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12504 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12505 
      for kiter188,viter189 in self.items.items():
12506 
        oprot.writeI64(kiter188)
12507 
        oprot.writeDouble(viter189)
690 chandransh 12508 
      oprot.writeMapEnd()
559 chandransh 12509 
      oprot.writeFieldEnd()
94 ashish 12510 
    oprot.writeFieldStop()
12511 
    oprot.writeStructEnd()
12512 
 
3431 rajveer 12513 
  def validate(self):
12514 
    return
12515 
 
12516 
 
94 ashish 12517 
  def __repr__(self):
12518 
    L = ['%s=%r' % (key, value)
12519 
      for key, value in self.__dict__.iteritems()]
12520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12521 
 
12522 
  def __eq__(self, other):
12523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12524 
 
12525 
  def __ne__(self, other):
12526 
    return not (self == other)
12527 
 
690 chandransh 12528 
class resetCart_result:
12529 
  """
12530 
  Attributes:
12531 
   - success
12532 
   - scex
12533 
  """
559 chandransh 12534 
 
12535 
  thrift_spec = (
690 chandransh 12536 
    (0, TType.BOOL, 'success', None, None, ), # 0
12537 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12538 
  )
12539 
 
690 chandransh 12540 
  def __init__(self, success=None, scex=None,):
12541 
    self.success = success
12542 
    self.scex = scex
12543 
 
559 chandransh 12544 
  def read(self, iprot):
12545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12547 
      return
12548 
    iprot.readStructBegin()
12549 
    while True:
12550 
      (fname, ftype, fid) = iprot.readFieldBegin()
12551 
      if ftype == TType.STOP:
12552 
        break
690 chandransh 12553 
      if fid == 0:
12554 
        if ftype == TType.BOOL:
12555 
          self.success = iprot.readBool();
12556 
        else:
12557 
          iprot.skip(ftype)
12558 
      elif fid == 1:
12559 
        if ftype == TType.STRUCT:
12560 
          self.scex = ShoppingCartException()
12561 
          self.scex.read(iprot)
12562 
        else:
12563 
          iprot.skip(ftype)
559 chandransh 12564 
      else:
12565 
        iprot.skip(ftype)
12566 
      iprot.readFieldEnd()
12567 
    iprot.readStructEnd()
12568 
 
12569 
  def write(self, oprot):
12570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12572 
      return
690 chandransh 12573 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12574 
    if self.success is not None:
690 chandransh 12575 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12576 
      oprot.writeBool(self.success)
12577 
      oprot.writeFieldEnd()
3431 rajveer 12578 
    if self.scex is not None:
690 chandransh 12579 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12580 
      self.scex.write(oprot)
12581 
      oprot.writeFieldEnd()
559 chandransh 12582 
    oprot.writeFieldStop()
12583 
    oprot.writeStructEnd()
12584 
 
3431 rajveer 12585 
  def validate(self):
12586 
    return
12587 
 
12588 
 
559 chandransh 12589 
  def __repr__(self):
12590 
    L = ['%s=%r' % (key, value)
12591 
      for key, value in self.__dict__.iteritems()]
12592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12593 
 
12594 
  def __eq__(self, other):
12595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12596 
 
12597 
  def __ne__(self, other):
12598 
    return not (self == other)
12599 
 
2981 rajveer 12600 
class getUserCount_args:
94 ashish 12601 
  """
12602 
  Attributes:
2981 rajveer 12603 
   - userType
559 chandransh 12604 
  """
12605 
 
12606 
  thrift_spec = (
12607 
    None, # 0
2981 rajveer 12608 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12609 
  )
12610 
 
2981 rajveer 12611 
  def __init__(self, userType=None,):
12612 
    self.userType = userType
559 chandransh 12613 
 
12614 
  def read(self, iprot):
12615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12617 
      return
12618 
    iprot.readStructBegin()
12619 
    while True:
12620 
      (fname, ftype, fid) = iprot.readFieldBegin()
12621 
      if ftype == TType.STOP:
12622 
        break
12623 
      if fid == 1:
2981 rajveer 12624 
        if ftype == TType.I32:
12625 
          self.userType = iprot.readI32();
559 chandransh 12626 
        else:
12627 
          iprot.skip(ftype)
12628 
      else:
12629 
        iprot.skip(ftype)
12630 
      iprot.readFieldEnd()
12631 
    iprot.readStructEnd()
12632 
 
12633 
  def write(self, oprot):
12634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12636 
      return
2981 rajveer 12637 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12638 
    if self.userType is not None:
2981 rajveer 12639 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12640 
      oprot.writeI32(self.userType)
559 chandransh 12641 
      oprot.writeFieldEnd()
12642 
    oprot.writeFieldStop()
12643 
    oprot.writeStructEnd()
12644 
 
3431 rajveer 12645 
  def validate(self):
12646 
    return
12647 
 
12648 
 
559 chandransh 12649 
  def __repr__(self):
12650 
    L = ['%s=%r' % (key, value)
12651 
      for key, value in self.__dict__.iteritems()]
12652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12653 
 
12654 
  def __eq__(self, other):
12655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12656 
 
12657 
  def __ne__(self, other):
12658 
    return not (self == other)
12659 
 
2981 rajveer 12660 
class getUserCount_result:
94 ashish 12661 
  """
12662 
  Attributes:
12663 
   - success
12664 
  """
12665 
 
12666 
  thrift_spec = (
2981 rajveer 12667 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12668 
  )
12669 
 
2981 rajveer 12670 
  def __init__(self, success=None,):
94 ashish 12671 
    self.success = success
12672 
 
12673 
  def read(self, iprot):
12674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12676 
      return
12677 
    iprot.readStructBegin()
12678 
    while True:
12679 
      (fname, ftype, fid) = iprot.readFieldBegin()
12680 
      if ftype == TType.STOP:
12681 
        break
12682 
      if fid == 0:
2981 rajveer 12683 
        if ftype == TType.I64:
12684 
          self.success = iprot.readI64();
94 ashish 12685 
        else:
12686 
          iprot.skip(ftype)
12687 
      else:
12688 
        iprot.skip(ftype)
12689 
      iprot.readFieldEnd()
12690 
    iprot.readStructEnd()
12691 
 
12692 
  def write(self, oprot):
12693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12695 
      return
2981 rajveer 12696 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12697 
    if self.success is not None:
2981 rajveer 12698 
      oprot.writeFieldBegin('success', TType.I64, 0)
12699 
      oprot.writeI64(self.success)
94 ashish 12700 
      oprot.writeFieldEnd()
12701 
    oprot.writeFieldStop()
12702 
    oprot.writeStructEnd()
12703 
 
3431 rajveer 12704 
  def validate(self):
12705 
    return
12706 
 
12707 
 
94 ashish 12708 
  def __repr__(self):
12709 
    L = ['%s=%r' % (key, value)
12710 
      for key, value in self.__dict__.iteritems()]
12711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12712 
 
12713 
  def __eq__(self, other):
12714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12715 
 
12716 
  def __ne__(self, other):
12717 
    return not (self == other)
12718 
 
2981 rajveer 12719 
class getAllUsers_args:
94 ashish 12720 
  """
12721 
  Attributes:
2981 rajveer 12722 
   - userType
12723 
   - startDate
12724 
   - endDate
94 ashish 12725 
  """
12726 
 
12727 
  thrift_spec = (
12728 
    None, # 0
2981 rajveer 12729 
    (1, TType.I32, 'userType', None, None, ), # 1
12730 
    (2, TType.I64, 'startDate', None, None, ), # 2
12731 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12732 
  )
12733 
 
2981 rajveer 12734 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12735 
    self.userType = userType
12736 
    self.startDate = startDate
12737 
    self.endDate = endDate
94 ashish 12738 
 
12739 
  def read(self, iprot):
12740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12742 
      return
12743 
    iprot.readStructBegin()
12744 
    while True:
12745 
      (fname, ftype, fid) = iprot.readFieldBegin()
12746 
      if ftype == TType.STOP:
12747 
        break
12748 
      if fid == 1:
2981 rajveer 12749 
        if ftype == TType.I32:
12750 
          self.userType = iprot.readI32();
94 ashish 12751 
        else:
12752 
          iprot.skip(ftype)
12753 
      elif fid == 2:
559 chandransh 12754 
        if ftype == TType.I64:
2981 rajveer 12755 
          self.startDate = iprot.readI64();
94 ashish 12756 
        else:
12757 
          iprot.skip(ftype)
2981 rajveer 12758 
      elif fid == 3:
12759 
        if ftype == TType.I64:
12760 
          self.endDate = iprot.readI64();
12761 
        else:
12762 
          iprot.skip(ftype)
94 ashish 12763 
      else:
12764 
        iprot.skip(ftype)
12765 
      iprot.readFieldEnd()
12766 
    iprot.readStructEnd()
12767 
 
12768 
  def write(self, oprot):
12769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12771 
      return
2981 rajveer 12772 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12773 
    if self.userType is not None:
2981 rajveer 12774 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12775 
      oprot.writeI32(self.userType)
94 ashish 12776 
      oprot.writeFieldEnd()
3431 rajveer 12777 
    if self.startDate is not None:
2981 rajveer 12778 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12779 
      oprot.writeI64(self.startDate)
94 ashish 12780 
      oprot.writeFieldEnd()
3431 rajveer 12781 
    if self.endDate is not None:
2981 rajveer 12782 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12783 
      oprot.writeI64(self.endDate)
12784 
      oprot.writeFieldEnd()
94 ashish 12785 
    oprot.writeFieldStop()
12786 
    oprot.writeStructEnd()
12787 
 
3431 rajveer 12788 
  def validate(self):
12789 
    return
12790 
 
12791 
 
94 ashish 12792 
  def __repr__(self):
12793 
    L = ['%s=%r' % (key, value)
12794 
      for key, value in self.__dict__.iteritems()]
12795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12796 
 
12797 
  def __eq__(self, other):
12798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12799 
 
12800 
  def __ne__(self, other):
12801 
    return not (self == other)
12802 
 
2981 rajveer 12803 
class getAllUsers_result:
94 ashish 12804 
  """
12805 
  Attributes:
12806 
   - success
12807 
  """
12808 
 
12809 
  thrift_spec = (
2981 rajveer 12810 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12811 
  )
12812 
 
2981 rajveer 12813 
  def __init__(self, success=None,):
94 ashish 12814 
    self.success = success
12815 
 
12816 
  def read(self, iprot):
12817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12819 
      return
12820 
    iprot.readStructBegin()
12821 
    while True:
12822 
      (fname, ftype, fid) = iprot.readFieldBegin()
12823 
      if ftype == TType.STOP:
12824 
        break
12825 
      if fid == 0:
2981 rajveer 12826 
        if ftype == TType.LIST:
12827 
          self.success = []
11980 amit.gupta 12828 
          (_etype193, _size190) = iprot.readListBegin()
12829 
          for _i194 in xrange(_size190):
12830 
            _elem195 = User()
12831 
            _elem195.read(iprot)
12832 
            self.success.append(_elem195)
2981 rajveer 12833 
          iprot.readListEnd()
94 ashish 12834 
        else:
12835 
          iprot.skip(ftype)
12836 
      else:
12837 
        iprot.skip(ftype)
12838 
      iprot.readFieldEnd()
12839 
    iprot.readStructEnd()
12840 
 
12841 
  def write(self, oprot):
12842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12844 
      return
2981 rajveer 12845 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12846 
    if self.success is not None:
2981 rajveer 12847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12848 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 12849 
      for iter196 in self.success:
12850 
        iter196.write(oprot)
2981 rajveer 12851 
      oprot.writeListEnd()
94 ashish 12852 
      oprot.writeFieldEnd()
12853 
    oprot.writeFieldStop()
12854 
    oprot.writeStructEnd()
12855 
 
3431 rajveer 12856 
  def validate(self):
12857 
    return
12858 
 
12859 
 
94 ashish 12860 
  def __repr__(self):
12861 
    L = ['%s=%r' % (key, value)
12862 
      for key, value in self.__dict__.iteritems()]
12863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12864 
 
12865 
  def __eq__(self, other):
12866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12867 
 
12868 
  def __ne__(self, other):
12869 
    return not (self == other)
12870 
 
2981 rajveer 12871 
class getMyResearchItems_args:
559 chandransh 12872 
  """
12873 
  Attributes:
772 rajveer 12874 
   - userId
559 chandransh 12875 
  """
12876 
 
12877 
  thrift_spec = (
12878 
    None, # 0
772 rajveer 12879 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12880 
  )
12881 
 
772 rajveer 12882 
  def __init__(self, userId=None,):
12883 
    self.userId = userId
559 chandransh 12884 
 
12885 
  def read(self, iprot):
12886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12888 
      return
12889 
    iprot.readStructBegin()
12890 
    while True:
12891 
      (fname, ftype, fid) = iprot.readFieldBegin()
12892 
      if ftype == TType.STOP:
12893 
        break
12894 
      if fid == 1:
12895 
        if ftype == TType.I64:
772 rajveer 12896 
          self.userId = iprot.readI64();
559 chandransh 12897 
        else:
12898 
          iprot.skip(ftype)
12899 
      else:
12900 
        iprot.skip(ftype)
12901 
      iprot.readFieldEnd()
12902 
    iprot.readStructEnd()
12903 
 
12904 
  def write(self, oprot):
12905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12907 
      return
2981 rajveer 12908 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 12909 
    if self.userId is not None:
772 rajveer 12910 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12911 
      oprot.writeI64(self.userId)
559 chandransh 12912 
      oprot.writeFieldEnd()
12913 
    oprot.writeFieldStop()
12914 
    oprot.writeStructEnd()
12915 
 
3431 rajveer 12916 
  def validate(self):
12917 
    return
12918 
 
12919 
 
559 chandransh 12920 
  def __repr__(self):
12921 
    L = ['%s=%r' % (key, value)
12922 
      for key, value in self.__dict__.iteritems()]
12923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12924 
 
12925 
  def __eq__(self, other):
12926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12927 
 
12928 
  def __ne__(self, other):
12929 
    return not (self == other)
12930 
 
2981 rajveer 12931 
class getMyResearchItems_result:
559 chandransh 12932 
  """
12933 
  Attributes:
130 ashish 12934 
   - success
559 chandransh 12935 
   - scx
130 ashish 12936 
  """
12937 
 
12938 
  thrift_spec = (
2981 rajveer 12939 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12940 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12941 
  )
12942 
 
559 chandransh 12943 
  def __init__(self, success=None, scx=None,):
130 ashish 12944 
    self.success = success
559 chandransh 12945 
    self.scx = scx
130 ashish 12946 
 
12947 
  def read(self, iprot):
12948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12950 
      return
12951 
    iprot.readStructBegin()
12952 
    while True:
12953 
      (fname, ftype, fid) = iprot.readFieldBegin()
12954 
      if ftype == TType.STOP:
12955 
        break
12956 
      if fid == 0:
2981 rajveer 12957 
        if ftype == TType.LIST:
12958 
          self.success = []
11980 amit.gupta 12959 
          (_etype200, _size197) = iprot.readListBegin()
12960 
          for _i201 in xrange(_size197):
12961 
            _elem202 = iprot.readI64();
12962 
            self.success.append(_elem202)
2981 rajveer 12963 
          iprot.readListEnd()
130 ashish 12964 
        else:
12965 
          iprot.skip(ftype)
12966 
      elif fid == 1:
12967 
        if ftype == TType.STRUCT:
559 chandransh 12968 
          self.scx = WidgetException()
12969 
          self.scx.read(iprot)
130 ashish 12970 
        else:
12971 
          iprot.skip(ftype)
12972 
      else:
12973 
        iprot.skip(ftype)
12974 
      iprot.readFieldEnd()
12975 
    iprot.readStructEnd()
12976 
 
12977 
  def write(self, oprot):
12978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12980 
      return
2981 rajveer 12981 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 12982 
    if self.success is not None:
2981 rajveer 12983 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12984 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 12985 
      for iter203 in self.success:
12986 
        oprot.writeI64(iter203)
2981 rajveer 12987 
      oprot.writeListEnd()
130 ashish 12988 
      oprot.writeFieldEnd()
3431 rajveer 12989 
    if self.scx is not None:
559 chandransh 12990 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12991 
      self.scx.write(oprot)
130 ashish 12992 
      oprot.writeFieldEnd()
12993 
    oprot.writeFieldStop()
12994 
    oprot.writeStructEnd()
12995 
 
3431 rajveer 12996 
  def validate(self):
12997 
    return
12998 
 
12999 
 
130 ashish 13000 
  def __repr__(self):
13001 
    L = ['%s=%r' % (key, value)
13002 
      for key, value in self.__dict__.iteritems()]
13003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13004 
 
13005 
  def __eq__(self, other):
13006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13007 
 
13008 
  def __ne__(self, other):
13009 
    return not (self == other)
13010 
 
2981 rajveer 13011 
class updateMyResearch_args:
130 ashish 13012 
  """
13013 
  Attributes:
2981 rajveer 13014 
   - userId
13015 
   - itemId
130 ashish 13016 
  """
13017 
 
13018 
  thrift_spec = (
13019 
    None, # 0
2981 rajveer 13020 
    (1, TType.I64, 'userId', None, None, ), # 1
13021 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13022 
  )
13023 
 
2981 rajveer 13024 
  def __init__(self, userId=None, itemId=None,):
13025 
    self.userId = userId
13026 
    self.itemId = itemId
130 ashish 13027 
 
13028 
  def read(self, iprot):
13029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13031 
      return
13032 
    iprot.readStructBegin()
13033 
    while True:
13034 
      (fname, ftype, fid) = iprot.readFieldBegin()
13035 
      if ftype == TType.STOP:
13036 
        break
13037 
      if fid == 1:
559 chandransh 13038 
        if ftype == TType.I64:
2981 rajveer 13039 
          self.userId = iprot.readI64();
130 ashish 13040 
        else:
13041 
          iprot.skip(ftype)
13042 
      elif fid == 2:
559 chandransh 13043 
        if ftype == TType.I64:
2981 rajveer 13044 
          self.itemId = iprot.readI64();
559 chandransh 13045 
        else:
13046 
          iprot.skip(ftype)
130 ashish 13047 
      else:
13048 
        iprot.skip(ftype)
13049 
      iprot.readFieldEnd()
13050 
    iprot.readStructEnd()
13051 
 
13052 
  def write(self, oprot):
13053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13055 
      return
2981 rajveer 13056 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13057 
    if self.userId is not None:
2981 rajveer 13058 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13059 
      oprot.writeI64(self.userId)
130 ashish 13060 
      oprot.writeFieldEnd()
3431 rajveer 13061 
    if self.itemId is not None:
2981 rajveer 13062 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13063 
      oprot.writeI64(self.itemId)
130 ashish 13064 
      oprot.writeFieldEnd()
13065 
    oprot.writeFieldStop()
13066 
    oprot.writeStructEnd()
13067 
 
3431 rajveer 13068 
  def validate(self):
13069 
    return
13070 
 
13071 
 
130 ashish 13072 
  def __repr__(self):
13073 
    L = ['%s=%r' % (key, value)
13074 
      for key, value in self.__dict__.iteritems()]
13075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13076 
 
13077 
  def __eq__(self, other):
13078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13079 
 
13080 
  def __ne__(self, other):
13081 
    return not (self == other)
13082 
 
2981 rajveer 13083 
class updateMyResearch_result:
13084 
  """
13085 
  Attributes:
13086 
   - success
13087 
   - scx
13088 
  """
559 chandransh 13089 
 
13090 
  thrift_spec = (
2981 rajveer 13091 
    (0, TType.BOOL, 'success', None, None, ), # 0
13092 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13093 
  )
13094 
 
2981 rajveer 13095 
  def __init__(self, success=None, scx=None,):
13096 
    self.success = success
13097 
    self.scx = scx
13098 
 
559 chandransh 13099 
  def read(self, iprot):
13100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13102 
      return
13103 
    iprot.readStructBegin()
13104 
    while True:
13105 
      (fname, ftype, fid) = iprot.readFieldBegin()
13106 
      if ftype == TType.STOP:
13107 
        break
2981 rajveer 13108 
      if fid == 0:
13109 
        if ftype == TType.BOOL:
13110 
          self.success = iprot.readBool();
13111 
        else:
13112 
          iprot.skip(ftype)
13113 
      elif fid == 1:
13114 
        if ftype == TType.STRUCT:
13115 
          self.scx = WidgetException()
13116 
          self.scx.read(iprot)
13117 
        else:
13118 
          iprot.skip(ftype)
559 chandransh 13119 
      else:
13120 
        iprot.skip(ftype)
13121 
      iprot.readFieldEnd()
13122 
    iprot.readStructEnd()
13123 
 
13124 
  def write(self, oprot):
13125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13127 
      return
2981 rajveer 13128 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13129 
    if self.success is not None:
2981 rajveer 13130 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13131 
      oprot.writeBool(self.success)
13132 
      oprot.writeFieldEnd()
3431 rajveer 13133 
    if self.scx is not None:
2981 rajveer 13134 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13135 
      self.scx.write(oprot)
13136 
      oprot.writeFieldEnd()
559 chandransh 13137 
    oprot.writeFieldStop()
13138 
    oprot.writeStructEnd()
13139 
 
3431 rajveer 13140 
  def validate(self):
13141 
    return
13142 
 
13143 
 
559 chandransh 13144 
  def __repr__(self):
13145 
    L = ['%s=%r' % (key, value)
13146 
      for key, value in self.__dict__.iteritems()]
13147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13148 
 
13149 
  def __eq__(self, other):
13150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13151 
 
13152 
  def __ne__(self, other):
13153 
    return not (self == other)
13154 
 
2981 rajveer 13155 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13156 
  """
13157 
  Attributes:
2981 rajveer 13158 
   - userId
13159 
   - itemId
1596 ankur.sing 13160 
  """
559 chandransh 13161 
 
1596 ankur.sing 13162 
  thrift_spec = (
13163 
    None, # 0
2981 rajveer 13164 
    (1, TType.I64, 'userId', None, None, ), # 1
13165 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13166 
  )
13167 
 
2981 rajveer 13168 
  def __init__(self, userId=None, itemId=None,):
13169 
    self.userId = userId
13170 
    self.itemId = itemId
1596 ankur.sing 13171 
 
13172 
  def read(self, iprot):
13173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13175 
      return
13176 
    iprot.readStructBegin()
13177 
    while True:
13178 
      (fname, ftype, fid) = iprot.readFieldBegin()
13179 
      if ftype == TType.STOP:
13180 
        break
13181 
      if fid == 1:
2981 rajveer 13182 
        if ftype == TType.I64:
13183 
          self.userId = iprot.readI64();
1596 ankur.sing 13184 
        else:
13185 
          iprot.skip(ftype)
2981 rajveer 13186 
      elif fid == 2:
13187 
        if ftype == TType.I64:
13188 
          self.itemId = iprot.readI64();
13189 
        else:
13190 
          iprot.skip(ftype)
1596 ankur.sing 13191 
      else:
13192 
        iprot.skip(ftype)
13193 
      iprot.readFieldEnd()
13194 
    iprot.readStructEnd()
13195 
 
13196 
  def write(self, oprot):
13197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13199 
      return
2981 rajveer 13200 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13201 
    if self.userId is not None:
2981 rajveer 13202 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13203 
      oprot.writeI64(self.userId)
1596 ankur.sing 13204 
      oprot.writeFieldEnd()
3431 rajveer 13205 
    if self.itemId is not None:
2981 rajveer 13206 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13207 
      oprot.writeI64(self.itemId)
13208 
      oprot.writeFieldEnd()
1596 ankur.sing 13209 
    oprot.writeFieldStop()
13210 
    oprot.writeStructEnd()
13211 
 
3431 rajveer 13212 
  def validate(self):
13213 
    return
13214 
 
13215 
 
1596 ankur.sing 13216 
  def __repr__(self):
13217 
    L = ['%s=%r' % (key, value)
13218 
      for key, value in self.__dict__.iteritems()]
13219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13220 
 
13221 
  def __eq__(self, other):
13222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13223 
 
13224 
  def __ne__(self, other):
13225 
    return not (self == other)
13226 
 
2981 rajveer 13227 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13228 
  """
13229 
  Attributes:
2981 rajveer 13230 
   - scx
1596 ankur.sing 13231 
  """
13232 
 
13233 
  thrift_spec = (
2981 rajveer 13234 
    None, # 0
13235 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13236 
  )
13237 
 
2981 rajveer 13238 
  def __init__(self, scx=None,):
13239 
    self.scx = scx
1596 ankur.sing 13240 
 
13241 
  def read(self, iprot):
13242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13244 
      return
13245 
    iprot.readStructBegin()
13246 
    while True:
13247 
      (fname, ftype, fid) = iprot.readFieldBegin()
13248 
      if ftype == TType.STOP:
13249 
        break
2981 rajveer 13250 
      if fid == 1:
13251 
        if ftype == TType.STRUCT:
13252 
          self.scx = WidgetException()
13253 
          self.scx.read(iprot)
1596 ankur.sing 13254 
        else:
13255 
          iprot.skip(ftype)
13256 
      else:
13257 
        iprot.skip(ftype)
13258 
      iprot.readFieldEnd()
13259 
    iprot.readStructEnd()
13260 
 
13261 
  def write(self, oprot):
13262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13264 
      return
2981 rajveer 13265 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13266 
    if self.scx is not None:
2981 rajveer 13267 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13268 
      self.scx.write(oprot)
1596 ankur.sing 13269 
      oprot.writeFieldEnd()
13270 
    oprot.writeFieldStop()
13271 
    oprot.writeStructEnd()
13272 
 
3431 rajveer 13273 
  def validate(self):
13274 
    return
13275 
 
13276 
 
1596 ankur.sing 13277 
  def __repr__(self):
13278 
    L = ['%s=%r' % (key, value)
13279 
      for key, value in self.__dict__.iteritems()]
13280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13281 
 
13282 
  def __eq__(self, other):
13283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13284 
 
13285 
  def __ne__(self, other):
13286 
    return not (self == other)
13287 
 
2981 rajveer 13288 
class getBrowseHistoryItems_args:
1673 ankur.sing 13289 
  """
13290 
  Attributes:
2981 rajveer 13291 
   - userId
1673 ankur.sing 13292 
  """
1596 ankur.sing 13293 
 
1673 ankur.sing 13294 
  thrift_spec = (
13295 
    None, # 0
2981 rajveer 13296 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13297 
  )
13298 
 
2981 rajveer 13299 
  def __init__(self, userId=None,):
13300 
    self.userId = userId
1673 ankur.sing 13301 
 
13302 
  def read(self, iprot):
13303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13305 
      return
13306 
    iprot.readStructBegin()
13307 
    while True:
13308 
      (fname, ftype, fid) = iprot.readFieldBegin()
13309 
      if ftype == TType.STOP:
13310 
        break
13311 
      if fid == 1:
1891 ankur.sing 13312 
        if ftype == TType.I64:
2981 rajveer 13313 
          self.userId = iprot.readI64();
1891 ankur.sing 13314 
        else:
13315 
          iprot.skip(ftype)
1673 ankur.sing 13316 
      else:
13317 
        iprot.skip(ftype)
13318 
      iprot.readFieldEnd()
13319 
    iprot.readStructEnd()
13320 
 
13321 
  def write(self, oprot):
13322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13324 
      return
2981 rajveer 13325 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13326 
    if self.userId is not None:
2981 rajveer 13327 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13328 
      oprot.writeI64(self.userId)
1673 ankur.sing 13329 
      oprot.writeFieldEnd()
13330 
    oprot.writeFieldStop()
13331 
    oprot.writeStructEnd()
13332 
 
3431 rajveer 13333 
  def validate(self):
13334 
    return
13335 
 
13336 
 
1673 ankur.sing 13337 
  def __repr__(self):
13338 
    L = ['%s=%r' % (key, value)
13339 
      for key, value in self.__dict__.iteritems()]
13340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13341 
 
13342 
  def __eq__(self, other):
13343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13344 
 
13345 
  def __ne__(self, other):
13346 
    return not (self == other)
13347 
 
2981 rajveer 13348 
class getBrowseHistoryItems_result:
1673 ankur.sing 13349 
  """
13350 
  Attributes:
13351 
   - success
2981 rajveer 13352 
   - scx
1673 ankur.sing 13353 
  """
13354 
 
13355 
  thrift_spec = (
2981 rajveer 13356 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13357 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13358 
  )
13359 
 
2981 rajveer 13360 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13361 
    self.success = success
2981 rajveer 13362 
    self.scx = scx
1673 ankur.sing 13363 
 
13364 
  def read(self, iprot):
13365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13367 
      return
13368 
    iprot.readStructBegin()
13369 
    while True:
13370 
      (fname, ftype, fid) = iprot.readFieldBegin()
13371 
      if ftype == TType.STOP:
13372 
        break
13373 
      if fid == 0:
13374 
        if ftype == TType.LIST:
13375 
          self.success = []
11980 amit.gupta 13376 
          (_etype207, _size204) = iprot.readListBegin()
13377 
          for _i208 in xrange(_size204):
13378 
            _elem209 = iprot.readI64();
13379 
            self.success.append(_elem209)
1673 ankur.sing 13380 
          iprot.readListEnd()
13381 
        else:
13382 
          iprot.skip(ftype)
2981 rajveer 13383 
      elif fid == 1:
13384 
        if ftype == TType.STRUCT:
13385 
          self.scx = WidgetException()
13386 
          self.scx.read(iprot)
13387 
        else:
13388 
          iprot.skip(ftype)
1673 ankur.sing 13389 
      else:
13390 
        iprot.skip(ftype)
13391 
      iprot.readFieldEnd()
13392 
    iprot.readStructEnd()
13393 
 
13394 
  def write(self, oprot):
13395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13397 
      return
2981 rajveer 13398 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13399 
    if self.success is not None:
1673 ankur.sing 13400 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13401 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13402 
      for iter210 in self.success:
13403 
        oprot.writeI64(iter210)
1673 ankur.sing 13404 
      oprot.writeListEnd()
13405 
      oprot.writeFieldEnd()
3431 rajveer 13406 
    if self.scx is not None:
2981 rajveer 13407 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13408 
      self.scx.write(oprot)
2642 varun.gupt 13409 
      oprot.writeFieldEnd()
13410 
    oprot.writeFieldStop()
13411 
    oprot.writeStructEnd()
13412 
 
3431 rajveer 13413 
  def validate(self):
13414 
    return
13415 
 
13416 
 
2642 varun.gupt 13417 
  def __repr__(self):
13418 
    L = ['%s=%r' % (key, value)
13419 
      for key, value in self.__dict__.iteritems()]
13420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13421 
 
13422 
  def __eq__(self, other):
13423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13424 
 
13425 
  def __ne__(self, other):
13426 
    return not (self == other)
13427 
 
2981 rajveer 13428 
class updateBrowseHistory_args:
2642 varun.gupt 13429 
  """
13430 
  Attributes:
2981 rajveer 13431 
   - userId
13432 
   - itemId
2642 varun.gupt 13433 
  """
13434 
 
13435 
  thrift_spec = (
13436 
    None, # 0
2981 rajveer 13437 
    (1, TType.I64, 'userId', None, None, ), # 1
13438 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13439 
  )
13440 
 
2981 rajveer 13441 
  def __init__(self, userId=None, itemId=None,):
13442 
    self.userId = userId
13443 
    self.itemId = itemId
2642 varun.gupt 13444 
 
13445 
  def read(self, iprot):
13446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13448 
      return
13449 
    iprot.readStructBegin()
13450 
    while True:
13451 
      (fname, ftype, fid) = iprot.readFieldBegin()
13452 
      if ftype == TType.STOP:
13453 
        break
13454 
      if fid == 1:
13455 
        if ftype == TType.I64:
2981 rajveer 13456 
          self.userId = iprot.readI64();
2642 varun.gupt 13457 
        else:
13458 
          iprot.skip(ftype)
13459 
      elif fid == 2:
13460 
        if ftype == TType.I64:
2981 rajveer 13461 
          self.itemId = iprot.readI64();
2642 varun.gupt 13462 
        else:
13463 
          iprot.skip(ftype)
13464 
      else:
13465 
        iprot.skip(ftype)
13466 
      iprot.readFieldEnd()
13467 
    iprot.readStructEnd()
13468 
 
13469 
  def write(self, oprot):
13470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13472 
      return
2981 rajveer 13473 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13474 
    if self.userId is not None:
2981 rajveer 13475 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13476 
      oprot.writeI64(self.userId)
2642 varun.gupt 13477 
      oprot.writeFieldEnd()
3431 rajveer 13478 
    if self.itemId is not None:
2981 rajveer 13479 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13480 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13481 
      oprot.writeFieldEnd()
13482 
    oprot.writeFieldStop()
13483 
    oprot.writeStructEnd()
13484 
 
3431 rajveer 13485 
  def validate(self):
13486 
    return
13487 
 
13488 
 
2642 varun.gupt 13489 
  def __repr__(self):
13490 
    L = ['%s=%r' % (key, value)
13491 
      for key, value in self.__dict__.iteritems()]
13492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13493 
 
13494 
  def __eq__(self, other):
13495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13496 
 
13497 
  def __ne__(self, other):
13498 
    return not (self == other)
13499 
 
2981 rajveer 13500 
class updateBrowseHistory_result:
2642 varun.gupt 13501 
 
13502 
  thrift_spec = (
13503 
  )
13504 
 
13505 
  def read(self, iprot):
13506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13508 
      return
13509 
    iprot.readStructBegin()
13510 
    while True:
13511 
      (fname, ftype, fid) = iprot.readFieldBegin()
13512 
      if ftype == TType.STOP:
13513 
        break
13514 
      else:
13515 
        iprot.skip(ftype)
13516 
      iprot.readFieldEnd()
13517 
    iprot.readStructEnd()
13518 
 
13519 
  def write(self, oprot):
13520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13522 
      return
2981 rajveer 13523 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13524 
    oprot.writeFieldStop()
13525 
    oprot.writeStructEnd()
13526 
 
3431 rajveer 13527 
  def validate(self):
13528 
    return
13529 
 
13530 
 
2642 varun.gupt 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 
 
3385 varun.gupt 13542 
class getCartsWithCouponCount_args:
13543 
  """
13544 
  Attributes:
13545 
   - couponCode
13546 
  """
2642 varun.gupt 13547 
 
3385 varun.gupt 13548 
  thrift_spec = (
13549 
    None, # 0
13550 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13551 
  )
13552 
 
13553 
  def __init__(self, couponCode=None,):
13554 
    self.couponCode = couponCode
13555 
 
13556 
  def read(self, iprot):
13557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13559 
      return
13560 
    iprot.readStructBegin()
13561 
    while True:
13562 
      (fname, ftype, fid) = iprot.readFieldBegin()
13563 
      if ftype == TType.STOP:
13564 
        break
13565 
      if fid == 1:
13566 
        if ftype == TType.STRING:
13567 
          self.couponCode = iprot.readString();
13568 
        else:
13569 
          iprot.skip(ftype)
13570 
      else:
13571 
        iprot.skip(ftype)
13572 
      iprot.readFieldEnd()
13573 
    iprot.readStructEnd()
13574 
 
13575 
  def write(self, oprot):
13576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13578 
      return
13579 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13580 
    if self.couponCode is not None:
3385 varun.gupt 13581 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13582 
      oprot.writeString(self.couponCode)
13583 
      oprot.writeFieldEnd()
13584 
    oprot.writeFieldStop()
13585 
    oprot.writeStructEnd()
13586 
 
3431 rajveer 13587 
  def validate(self):
13588 
    return
13589 
 
13590 
 
3385 varun.gupt 13591 
  def __repr__(self):
13592 
    L = ['%s=%r' % (key, value)
13593 
      for key, value in self.__dict__.iteritems()]
13594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13595 
 
13596 
  def __eq__(self, other):
13597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13598 
 
13599 
  def __ne__(self, other):
13600 
    return not (self == other)
13601 
 
13602 
class getCartsWithCouponCount_result:
13603 
  """
13604 
  Attributes:
13605 
   - success
13606 
  """
13607 
 
13608 
  thrift_spec = (
13609 
    (0, TType.I64, 'success', None, None, ), # 0
13610 
  )
13611 
 
13612 
  def __init__(self, success=None,):
13613 
    self.success = success
13614 
 
13615 
  def read(self, iprot):
13616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13618 
      return
13619 
    iprot.readStructBegin()
13620 
    while True:
13621 
      (fname, ftype, fid) = iprot.readFieldBegin()
13622 
      if ftype == TType.STOP:
13623 
        break
13624 
      if fid == 0:
13625 
        if ftype == TType.I64:
13626 
          self.success = iprot.readI64();
13627 
        else:
13628 
          iprot.skip(ftype)
13629 
      else:
13630 
        iprot.skip(ftype)
13631 
      iprot.readFieldEnd()
13632 
    iprot.readStructEnd()
13633 
 
13634 
  def write(self, oprot):
13635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13637 
      return
13638 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13639 
    if self.success is not None:
3385 varun.gupt 13640 
      oprot.writeFieldBegin('success', TType.I64, 0)
13641 
      oprot.writeI64(self.success)
13642 
      oprot.writeFieldEnd()
13643 
    oprot.writeFieldStop()
13644 
    oprot.writeStructEnd()
13645 
 
3431 rajveer 13646 
  def validate(self):
13647 
    return
13648 
 
13649 
 
3385 varun.gupt 13650 
  def __repr__(self):
13651 
    L = ['%s=%r' % (key, value)
13652 
      for key, value in self.__dict__.iteritems()]
13653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13654 
 
13655 
  def __eq__(self, other):
13656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13657 
 
13658 
  def __ne__(self, other):
13659 
    return not (self == other)
3499 mandeep.dh 13660 
 
13661 
class increaseTrustLevel_args:
13662 
  """
13663 
  Attributes:
13664 
   - userId
13665 
   - trustLevelDelta
13666 
  """
13667 
 
13668 
  thrift_spec = (
13669 
    None, # 0
13670 
    (1, TType.I64, 'userId', None, None, ), # 1
13671 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13672 
  )
13673 
 
13674 
  def __init__(self, userId=None, trustLevelDelta=None,):
13675 
    self.userId = userId
13676 
    self.trustLevelDelta = trustLevelDelta
13677 
 
13678 
  def read(self, iprot):
13679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13681 
      return
13682 
    iprot.readStructBegin()
13683 
    while True:
13684 
      (fname, ftype, fid) = iprot.readFieldBegin()
13685 
      if ftype == TType.STOP:
13686 
        break
13687 
      if fid == 1:
13688 
        if ftype == TType.I64:
13689 
          self.userId = iprot.readI64();
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      elif fid == 2:
13693 
        if ftype == TType.DOUBLE:
13694 
          self.trustLevelDelta = iprot.readDouble();
13695 
        else:
13696 
          iprot.skip(ftype)
13697 
      else:
13698 
        iprot.skip(ftype)
13699 
      iprot.readFieldEnd()
13700 
    iprot.readStructEnd()
13701 
 
13702 
  def write(self, oprot):
13703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13705 
      return
13706 
    oprot.writeStructBegin('increaseTrustLevel_args')
13707 
    if self.userId is not None:
13708 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13709 
      oprot.writeI64(self.userId)
13710 
      oprot.writeFieldEnd()
13711 
    if self.trustLevelDelta is not None:
13712 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13713 
      oprot.writeDouble(self.trustLevelDelta)
13714 
      oprot.writeFieldEnd()
13715 
    oprot.writeFieldStop()
13716 
    oprot.writeStructEnd()
13717 
 
13718 
  def validate(self):
13719 
    return
13720 
 
13721 
 
13722 
  def __repr__(self):
13723 
    L = ['%s=%r' % (key, value)
13724 
      for key, value in self.__dict__.iteritems()]
13725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13726 
 
13727 
  def __eq__(self, other):
13728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13729 
 
13730 
  def __ne__(self, other):
13731 
    return not (self == other)
4668 varun.gupt 13732 
 
5407 amar.kumar 13733 
class getTrustLevel_args:
13734 
  """
13735 
  Attributes:
13736 
   - userId
13737 
  """
13738 
 
13739 
  thrift_spec = (
13740 
    None, # 0
13741 
    (1, TType.I64, 'userId', None, None, ), # 1
13742 
  )
13743 
 
13744 
  def __init__(self, userId=None,):
13745 
    self.userId = userId
13746 
 
13747 
  def read(self, iprot):
13748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13750 
      return
13751 
    iprot.readStructBegin()
13752 
    while True:
13753 
      (fname, ftype, fid) = iprot.readFieldBegin()
13754 
      if ftype == TType.STOP:
13755 
        break
13756 
      if fid == 1:
13757 
        if ftype == TType.I64:
13758 
          self.userId = iprot.readI64();
13759 
        else:
13760 
          iprot.skip(ftype)
13761 
      else:
13762 
        iprot.skip(ftype)
13763 
      iprot.readFieldEnd()
13764 
    iprot.readStructEnd()
13765 
 
13766 
  def write(self, oprot):
13767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13769 
      return
13770 
    oprot.writeStructBegin('getTrustLevel_args')
13771 
    if self.userId is not None:
13772 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13773 
      oprot.writeI64(self.userId)
13774 
      oprot.writeFieldEnd()
13775 
    oprot.writeFieldStop()
13776 
    oprot.writeStructEnd()
13777 
 
13778 
  def validate(self):
13779 
    return
13780 
 
13781 
 
13782 
  def __repr__(self):
13783 
    L = ['%s=%r' % (key, value)
13784 
      for key, value in self.__dict__.iteritems()]
13785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13786 
 
13787 
  def __eq__(self, other):
13788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13789 
 
13790 
  def __ne__(self, other):
13791 
    return not (self == other)
13792 
 
13793 
class getTrustLevel_result:
13794 
  """
13795 
  Attributes:
13796 
   - success
13797 
  """
13798 
 
13799 
  thrift_spec = (
13800 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13801 
  )
13802 
 
13803 
  def __init__(self, success=None,):
13804 
    self.success = success
13805 
 
13806 
  def read(self, iprot):
13807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13809 
      return
13810 
    iprot.readStructBegin()
13811 
    while True:
13812 
      (fname, ftype, fid) = iprot.readFieldBegin()
13813 
      if ftype == TType.STOP:
13814 
        break
13815 
      if fid == 0:
13816 
        if ftype == TType.DOUBLE:
13817 
          self.success = iprot.readDouble();
13818 
        else:
13819 
          iprot.skip(ftype)
13820 
      else:
13821 
        iprot.skip(ftype)
13822 
      iprot.readFieldEnd()
13823 
    iprot.readStructEnd()
13824 
 
13825 
  def write(self, oprot):
13826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13828 
      return
13829 
    oprot.writeStructBegin('getTrustLevel_result')
13830 
    if self.success is not None:
13831 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13832 
      oprot.writeDouble(self.success)
13833 
      oprot.writeFieldEnd()
13834 
    oprot.writeFieldStop()
13835 
    oprot.writeStructEnd()
13836 
 
13837 
  def validate(self):
13838 
    return
13839 
 
13840 
 
13841 
  def __repr__(self):
13842 
    L = ['%s=%r' % (key, value)
13843 
      for key, value in self.__dict__.iteritems()]
13844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13845 
 
13846 
  def __eq__(self, other):
13847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13848 
 
13849 
  def __ne__(self, other):
13850 
    return not (self == other)
13851 
 
4668 varun.gupt 13852 
class showCODOption_args:
13853 
  """
13854 
  Attributes:
13855 
   - cartId
13856 
   - sourceId
13857 
   - pincode
13858 
  """
13859 
 
13860 
  thrift_spec = (
13861 
    None, # 0
13862 
    (1, TType.I64, 'cartId', None, None, ), # 1
13863 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13864 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13865 
  )
13866 
 
13867 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13868 
    self.cartId = cartId
13869 
    self.sourceId = sourceId
13870 
    self.pincode = pincode
13871 
 
13872 
  def read(self, iprot):
13873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13875 
      return
13876 
    iprot.readStructBegin()
13877 
    while True:
13878 
      (fname, ftype, fid) = iprot.readFieldBegin()
13879 
      if ftype == TType.STOP:
13880 
        break
13881 
      if fid == 1:
13882 
        if ftype == TType.I64:
13883 
          self.cartId = iprot.readI64();
13884 
        else:
13885 
          iprot.skip(ftype)
13886 
      elif fid == 2:
13887 
        if ftype == TType.I64:
13888 
          self.sourceId = iprot.readI64();
13889 
        else:
13890 
          iprot.skip(ftype)
13891 
      elif fid == 3:
13892 
        if ftype == TType.STRING:
13893 
          self.pincode = iprot.readString();
13894 
        else:
13895 
          iprot.skip(ftype)
13896 
      else:
13897 
        iprot.skip(ftype)
13898 
      iprot.readFieldEnd()
13899 
    iprot.readStructEnd()
13900 
 
13901 
  def write(self, oprot):
13902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13904 
      return
13905 
    oprot.writeStructBegin('showCODOption_args')
13906 
    if self.cartId is not None:
13907 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13908 
      oprot.writeI64(self.cartId)
13909 
      oprot.writeFieldEnd()
13910 
    if self.sourceId is not None:
13911 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13912 
      oprot.writeI64(self.sourceId)
13913 
      oprot.writeFieldEnd()
13914 
    if self.pincode is not None:
13915 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
13916 
      oprot.writeString(self.pincode)
13917 
      oprot.writeFieldEnd()
13918 
    oprot.writeFieldStop()
13919 
    oprot.writeStructEnd()
13920 
 
13921 
  def validate(self):
13922 
    return
13923 
 
13924 
 
13925 
  def __repr__(self):
13926 
    L = ['%s=%r' % (key, value)
13927 
      for key, value in self.__dict__.iteritems()]
13928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13929 
 
13930 
  def __eq__(self, other):
13931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13932 
 
13933 
  def __ne__(self, other):
13934 
    return not (self == other)
13935 
 
13936 
class showCODOption_result:
13937 
  """
13938 
  Attributes:
13939 
   - success
13940 
  """
13941 
 
13942 
  thrift_spec = (
13943 
    (0, TType.BOOL, 'success', None, None, ), # 0
13944 
  )
13945 
 
13946 
  def __init__(self, success=None,):
13947 
    self.success = success
13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 0:
13959 
        if ftype == TType.BOOL:
13960 
          self.success = iprot.readBool();
13961 
        else:
13962 
          iprot.skip(ftype)
13963 
      else:
13964 
        iprot.skip(ftype)
13965 
      iprot.readFieldEnd()
13966 
    iprot.readStructEnd()
13967 
 
13968 
  def write(self, oprot):
13969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13971 
      return
13972 
    oprot.writeStructBegin('showCODOption_result')
13973 
    if self.success is not None:
13974 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13975 
      oprot.writeBool(self.success)
13976 
      oprot.writeFieldEnd()
13977 
    oprot.writeFieldStop()
13978 
    oprot.writeStructEnd()
13979 
 
13980 
  def validate(self):
13981 
    return
13982 
 
13983 
 
13984 
  def __repr__(self):
13985 
    L = ['%s=%r' % (key, value)
13986 
      for key, value in self.__dict__.iteritems()]
13987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13988 
 
13989 
  def __eq__(self, other):
13990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13991 
 
13992 
  def __ne__(self, other):
13993 
    return not (self == other)
5623 anupam.sin 13994 
 
13995 
class getUserEmails_args:
13996 
  """
13997 
  Attributes:
13998 
   - startDate
13999 
   - endDate
14000 
  """
14001 
 
14002 
  thrift_spec = (
14003 
    None, # 0
14004 
    (1, TType.I64, 'startDate', None, None, ), # 1
14005 
    (2, TType.I64, 'endDate', None, None, ), # 2
14006 
  )
14007 
 
14008 
  def __init__(self, startDate=None, endDate=None,):
14009 
    self.startDate = startDate
14010 
    self.endDate = endDate
14011 
 
14012 
  def read(self, iprot):
14013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14015 
      return
14016 
    iprot.readStructBegin()
14017 
    while True:
14018 
      (fname, ftype, fid) = iprot.readFieldBegin()
14019 
      if ftype == TType.STOP:
14020 
        break
14021 
      if fid == 1:
14022 
        if ftype == TType.I64:
14023 
          self.startDate = iprot.readI64();
14024 
        else:
14025 
          iprot.skip(ftype)
14026 
      elif fid == 2:
14027 
        if ftype == TType.I64:
14028 
          self.endDate = iprot.readI64();
14029 
        else:
14030 
          iprot.skip(ftype)
14031 
      else:
14032 
        iprot.skip(ftype)
14033 
      iprot.readFieldEnd()
14034 
    iprot.readStructEnd()
14035 
 
14036 
  def write(self, oprot):
14037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14039 
      return
14040 
    oprot.writeStructBegin('getUserEmails_args')
14041 
    if self.startDate is not None:
14042 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14043 
      oprot.writeI64(self.startDate)
14044 
      oprot.writeFieldEnd()
14045 
    if self.endDate is not None:
14046 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14047 
      oprot.writeI64(self.endDate)
14048 
      oprot.writeFieldEnd()
14049 
    oprot.writeFieldStop()
14050 
    oprot.writeStructEnd()
14051 
 
14052 
  def validate(self):
14053 
    return
14054 
 
14055 
 
14056 
  def __repr__(self):
14057 
    L = ['%s=%r' % (key, value)
14058 
      for key, value in self.__dict__.iteritems()]
14059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14060 
 
14061 
  def __eq__(self, other):
14062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14063 
 
14064 
  def __ne__(self, other):
14065 
    return not (self == other)
14066 
 
14067 
class getUserEmails_result:
14068 
  """
14069 
  Attributes:
14070 
   - success
14071 
  """
14072 
 
14073 
  thrift_spec = (
14074 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14075 
  )
14076 
 
14077 
  def __init__(self, success=None,):
14078 
    self.success = success
14079 
 
14080 
  def read(self, iprot):
14081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14083 
      return
14084 
    iprot.readStructBegin()
14085 
    while True:
14086 
      (fname, ftype, fid) = iprot.readFieldBegin()
14087 
      if ftype == TType.STOP:
14088 
        break
14089 
      if fid == 0:
14090 
        if ftype == TType.LIST:
14091 
          self.success = []
11980 amit.gupta 14092 
          (_etype214, _size211) = iprot.readListBegin()
14093 
          for _i215 in xrange(_size211):
14094 
            _elem216 = iprot.readString();
14095 
            self.success.append(_elem216)
5623 anupam.sin 14096 
          iprot.readListEnd()
14097 
        else:
14098 
          iprot.skip(ftype)
14099 
      else:
14100 
        iprot.skip(ftype)
14101 
      iprot.readFieldEnd()
14102 
    iprot.readStructEnd()
14103 
 
14104 
  def write(self, oprot):
14105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14107 
      return
14108 
    oprot.writeStructBegin('getUserEmails_result')
14109 
    if self.success is not None:
14110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14111 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14112 
      for iter217 in self.success:
14113 
        oprot.writeString(iter217)
5623 anupam.sin 14114 
      oprot.writeListEnd()
14115 
      oprot.writeFieldEnd()
14116 
    oprot.writeFieldStop()
14117 
    oprot.writeStructEnd()
14118 
 
14119 
  def validate(self):
14120 
    return
14121 
 
14122 
 
14123 
  def __repr__(self):
14124 
    L = ['%s=%r' % (key, value)
14125 
      for key, value in self.__dict__.iteritems()]
14126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14127 
 
14128 
  def __eq__(self, other):
14129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14130 
 
14131 
  def __ne__(self, other):
14132 
    return not (self == other)
6821 amar.kumar 14133 
 
6903 anupam.sin 14134 
class insureItem_args:
14135 
  """
14136 
  Attributes:
14137 
   - itemId
14138 
   - cartId
14139 
   - toInsure
9299 kshitij.so 14140 
   - insurerType
6903 anupam.sin 14141 
  """
14142 
 
14143 
  thrift_spec = (
14144 
    None, # 0
14145 
    (1, TType.I64, 'itemId', None, None, ), # 1
14146 
    (2, TType.I64, 'cartId', None, None, ), # 2
14147 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14148 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14149 
  )
14150 
 
9299 kshitij.so 14151 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14152 
    self.itemId = itemId
14153 
    self.cartId = cartId
14154 
    self.toInsure = toInsure
9299 kshitij.so 14155 
    self.insurerType = insurerType
6903 anupam.sin 14156 
 
14157 
  def read(self, iprot):
14158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14160 
      return
14161 
    iprot.readStructBegin()
14162 
    while True:
14163 
      (fname, ftype, fid) = iprot.readFieldBegin()
14164 
      if ftype == TType.STOP:
14165 
        break
14166 
      if fid == 1:
14167 
        if ftype == TType.I64:
14168 
          self.itemId = iprot.readI64();
14169 
        else:
14170 
          iprot.skip(ftype)
14171 
      elif fid == 2:
14172 
        if ftype == TType.I64:
14173 
          self.cartId = iprot.readI64();
14174 
        else:
14175 
          iprot.skip(ftype)
14176 
      elif fid == 3:
14177 
        if ftype == TType.BOOL:
14178 
          self.toInsure = iprot.readBool();
14179 
        else:
14180 
          iprot.skip(ftype)
9299 kshitij.so 14181 
      elif fid == 4:
14182 
        if ftype == TType.I32:
14183 
          self.insurerType = iprot.readI32();
14184 
        else:
14185 
          iprot.skip(ftype)
6903 anupam.sin 14186 
      else:
14187 
        iprot.skip(ftype)
14188 
      iprot.readFieldEnd()
14189 
    iprot.readStructEnd()
14190 
 
14191 
  def write(self, oprot):
14192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14194 
      return
14195 
    oprot.writeStructBegin('insureItem_args')
14196 
    if self.itemId is not None:
14197 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14198 
      oprot.writeI64(self.itemId)
14199 
      oprot.writeFieldEnd()
14200 
    if self.cartId is not None:
14201 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14202 
      oprot.writeI64(self.cartId)
14203 
      oprot.writeFieldEnd()
14204 
    if self.toInsure is not None:
14205 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14206 
      oprot.writeBool(self.toInsure)
14207 
      oprot.writeFieldEnd()
9299 kshitij.so 14208 
    if self.insurerType is not None:
14209 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14210 
      oprot.writeI32(self.insurerType)
14211 
      oprot.writeFieldEnd()
6903 anupam.sin 14212 
    oprot.writeFieldStop()
14213 
    oprot.writeStructEnd()
14214 
 
14215 
  def validate(self):
14216 
    return
14217 
 
14218 
 
14219 
  def __repr__(self):
14220 
    L = ['%s=%r' % (key, value)
14221 
      for key, value in self.__dict__.iteritems()]
14222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14223 
 
14224 
  def __eq__(self, other):
14225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14226 
 
14227 
  def __ne__(self, other):
14228 
    return not (self == other)
14229 
 
14230 
class insureItem_result:
14231 
  """
14232 
  Attributes:
14233 
   - success
14234 
  """
14235 
 
14236 
  thrift_spec = (
14237 
    (0, TType.BOOL, 'success', None, None, ), # 0
14238 
  )
14239 
 
14240 
  def __init__(self, success=None,):
14241 
    self.success = success
14242 
 
14243 
  def read(self, iprot):
14244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14246 
      return
14247 
    iprot.readStructBegin()
14248 
    while True:
14249 
      (fname, ftype, fid) = iprot.readFieldBegin()
14250 
      if ftype == TType.STOP:
14251 
        break
14252 
      if fid == 0:
14253 
        if ftype == TType.BOOL:
14254 
          self.success = iprot.readBool();
14255 
        else:
14256 
          iprot.skip(ftype)
14257 
      else:
14258 
        iprot.skip(ftype)
14259 
      iprot.readFieldEnd()
14260 
    iprot.readStructEnd()
14261 
 
14262 
  def write(self, oprot):
14263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14265 
      return
14266 
    oprot.writeStructBegin('insureItem_result')
14267 
    if self.success is not None:
14268 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14269 
      oprot.writeBool(self.success)
14270 
      oprot.writeFieldEnd()
14271 
    oprot.writeFieldStop()
14272 
    oprot.writeStructEnd()
14273 
 
14274 
  def validate(self):
14275 
    return
14276 
 
14277 
 
14278 
  def __repr__(self):
14279 
    L = ['%s=%r' % (key, value)
14280 
      for key, value in self.__dict__.iteritems()]
14281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14282 
 
14283 
  def __eq__(self, other):
14284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14285 
 
14286 
  def __ne__(self, other):
14287 
    return not (self == other)
14288 
 
14289 
class cancelInsurance_args:
14290 
  """
14291 
  Attributes:
14292 
   - cartId
14293 
  """
14294 
 
14295 
  thrift_spec = (
14296 
    None, # 0
14297 
    (1, TType.I64, 'cartId', None, None, ), # 1
14298 
  )
14299 
 
14300 
  def __init__(self, cartId=None,):
14301 
    self.cartId = cartId
14302 
 
14303 
  def read(self, iprot):
14304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14306 
      return
14307 
    iprot.readStructBegin()
14308 
    while True:
14309 
      (fname, ftype, fid) = iprot.readFieldBegin()
14310 
      if ftype == TType.STOP:
14311 
        break
14312 
      if fid == 1:
14313 
        if ftype == TType.I64:
14314 
          self.cartId = iprot.readI64();
14315 
        else:
14316 
          iprot.skip(ftype)
14317 
      else:
14318 
        iprot.skip(ftype)
14319 
      iprot.readFieldEnd()
14320 
    iprot.readStructEnd()
14321 
 
14322 
  def write(self, oprot):
14323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14325 
      return
14326 
    oprot.writeStructBegin('cancelInsurance_args')
14327 
    if self.cartId is not None:
14328 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14329 
      oprot.writeI64(self.cartId)
14330 
      oprot.writeFieldEnd()
14331 
    oprot.writeFieldStop()
14332 
    oprot.writeStructEnd()
14333 
 
14334 
  def validate(self):
14335 
    return
14336 
 
14337 
 
14338 
  def __repr__(self):
14339 
    L = ['%s=%r' % (key, value)
14340 
      for key, value in self.__dict__.iteritems()]
14341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14342 
 
14343 
  def __eq__(self, other):
14344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14345 
 
14346 
  def __ne__(self, other):
14347 
    return not (self == other)
14348 
 
14349 
class cancelInsurance_result:
14350 
  """
14351 
  Attributes:
14352 
   - success
14353 
  """
14354 
 
14355 
  thrift_spec = (
14356 
    (0, TType.BOOL, 'success', None, None, ), # 0
14357 
  )
14358 
 
14359 
  def __init__(self, success=None,):
14360 
    self.success = success
14361 
 
14362 
  def read(self, iprot):
14363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14365 
      return
14366 
    iprot.readStructBegin()
14367 
    while True:
14368 
      (fname, ftype, fid) = iprot.readFieldBegin()
14369 
      if ftype == TType.STOP:
14370 
        break
14371 
      if fid == 0:
14372 
        if ftype == TType.BOOL:
14373 
          self.success = iprot.readBool();
14374 
        else:
14375 
          iprot.skip(ftype)
14376 
      else:
14377 
        iprot.skip(ftype)
14378 
      iprot.readFieldEnd()
14379 
    iprot.readStructEnd()
14380 
 
14381 
  def write(self, oprot):
14382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14384 
      return
14385 
    oprot.writeStructBegin('cancelInsurance_result')
14386 
    if self.success is not None:
14387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14388 
      oprot.writeBool(self.success)
14389 
      oprot.writeFieldEnd()
14390 
    oprot.writeFieldStop()
14391 
    oprot.writeStructEnd()
14392 
 
14393 
  def validate(self):
14394 
    return
14395 
 
14396 
 
14397 
  def __repr__(self):
14398 
    L = ['%s=%r' % (key, value)
14399 
      for key, value in self.__dict__.iteritems()]
14400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14401 
 
14402 
  def __eq__(self, other):
14403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14404 
 
14405 
  def __ne__(self, other):
14406 
    return not (self == other)
14407 
 
14408 
class storeInsuranceSpecificDetails_args:
14409 
  """
14410 
  Attributes:
14411 
   - addressId
14412 
   - dob
14413 
   - guardianName
14414 
  """
14415 
 
14416 
  thrift_spec = (
14417 
    None, # 0
14418 
    (1, TType.I64, 'addressId', None, None, ), # 1
14419 
    (2, TType.STRING, 'dob', None, None, ), # 2
14420 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14421 
  )
14422 
 
14423 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14424 
    self.addressId = addressId
14425 
    self.dob = dob
14426 
    self.guardianName = guardianName
14427 
 
14428 
  def read(self, iprot):
14429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14431 
      return
14432 
    iprot.readStructBegin()
14433 
    while True:
14434 
      (fname, ftype, fid) = iprot.readFieldBegin()
14435 
      if ftype == TType.STOP:
14436 
        break
14437 
      if fid == 1:
14438 
        if ftype == TType.I64:
14439 
          self.addressId = iprot.readI64();
14440 
        else:
14441 
          iprot.skip(ftype)
14442 
      elif fid == 2:
14443 
        if ftype == TType.STRING:
14444 
          self.dob = iprot.readString();
14445 
        else:
14446 
          iprot.skip(ftype)
14447 
      elif fid == 3:
14448 
        if ftype == TType.STRING:
14449 
          self.guardianName = iprot.readString();
14450 
        else:
14451 
          iprot.skip(ftype)
14452 
      else:
14453 
        iprot.skip(ftype)
14454 
      iprot.readFieldEnd()
14455 
    iprot.readStructEnd()
14456 
 
14457 
  def write(self, oprot):
14458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14460 
      return
14461 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14462 
    if self.addressId is not None:
14463 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14464 
      oprot.writeI64(self.addressId)
14465 
      oprot.writeFieldEnd()
14466 
    if self.dob is not None:
14467 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14468 
      oprot.writeString(self.dob)
14469 
      oprot.writeFieldEnd()
14470 
    if self.guardianName is not None:
14471 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14472 
      oprot.writeString(self.guardianName)
14473 
      oprot.writeFieldEnd()
14474 
    oprot.writeFieldStop()
14475 
    oprot.writeStructEnd()
14476 
 
14477 
  def validate(self):
14478 
    return
14479 
 
14480 
 
14481 
  def __repr__(self):
14482 
    L = ['%s=%r' % (key, value)
14483 
      for key, value in self.__dict__.iteritems()]
14484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14485 
 
14486 
  def __eq__(self, other):
14487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14488 
 
14489 
  def __ne__(self, other):
14490 
    return not (self == other)
14491 
 
14492 
class storeInsuranceSpecificDetails_result:
14493 
  """
14494 
  Attributes:
14495 
   - success
14496 
  """
14497 
 
14498 
  thrift_spec = (
14499 
    (0, TType.BOOL, 'success', None, None, ), # 0
14500 
  )
14501 
 
14502 
  def __init__(self, success=None,):
14503 
    self.success = success
14504 
 
14505 
  def read(self, iprot):
14506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14508 
      return
14509 
    iprot.readStructBegin()
14510 
    while True:
14511 
      (fname, ftype, fid) = iprot.readFieldBegin()
14512 
      if ftype == TType.STOP:
14513 
        break
14514 
      if fid == 0:
14515 
        if ftype == TType.BOOL:
14516 
          self.success = iprot.readBool();
14517 
        else:
14518 
          iprot.skip(ftype)
14519 
      else:
14520 
        iprot.skip(ftype)
14521 
      iprot.readFieldEnd()
14522 
    iprot.readStructEnd()
14523 
 
14524 
  def write(self, oprot):
14525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14527 
      return
14528 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14529 
    if self.success is not None:
14530 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14531 
      oprot.writeBool(self.success)
14532 
      oprot.writeFieldEnd()
14533 
    oprot.writeFieldStop()
14534 
    oprot.writeStructEnd()
14535 
 
14536 
  def validate(self):
14537 
    return
14538 
 
14539 
 
14540 
  def __repr__(self):
14541 
    L = ['%s=%r' % (key, value)
14542 
      for key, value in self.__dict__.iteritems()]
14543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14544 
 
14545 
  def __eq__(self, other):
14546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14547 
 
14548 
  def __ne__(self, other):
14549 
    return not (self == other)
14550 
 
14551 
class isInsuranceDetailPresent_args:
14552 
  """
14553 
  Attributes:
14554 
   - addressId
14555 
  """
14556 
 
14557 
  thrift_spec = (
14558 
    None, # 0
14559 
    (1, TType.I64, 'addressId', None, None, ), # 1
14560 
  )
14561 
 
14562 
  def __init__(self, addressId=None,):
14563 
    self.addressId = addressId
14564 
 
14565 
  def read(self, iprot):
14566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14568 
      return
14569 
    iprot.readStructBegin()
14570 
    while True:
14571 
      (fname, ftype, fid) = iprot.readFieldBegin()
14572 
      if ftype == TType.STOP:
14573 
        break
14574 
      if fid == 1:
14575 
        if ftype == TType.I64:
14576 
          self.addressId = iprot.readI64();
14577 
        else:
14578 
          iprot.skip(ftype)
14579 
      else:
14580 
        iprot.skip(ftype)
14581 
      iprot.readFieldEnd()
14582 
    iprot.readStructEnd()
14583 
 
14584 
  def write(self, oprot):
14585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14587 
      return
14588 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14589 
    if self.addressId is not None:
14590 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14591 
      oprot.writeI64(self.addressId)
14592 
      oprot.writeFieldEnd()
14593 
    oprot.writeFieldStop()
14594 
    oprot.writeStructEnd()
14595 
 
14596 
  def validate(self):
14597 
    return
14598 
 
14599 
 
14600 
  def __repr__(self):
14601 
    L = ['%s=%r' % (key, value)
14602 
      for key, value in self.__dict__.iteritems()]
14603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14604 
 
14605 
  def __eq__(self, other):
14606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14607 
 
14608 
  def __ne__(self, other):
14609 
    return not (self == other)
14610 
 
14611 
class isInsuranceDetailPresent_result:
14612 
  """
14613 
  Attributes:
14614 
   - success
14615 
  """
14616 
 
14617 
  thrift_spec = (
14618 
    (0, TType.BOOL, 'success', None, None, ), # 0
14619 
  )
14620 
 
14621 
  def __init__(self, success=None,):
14622 
    self.success = success
14623 
 
14624 
  def read(self, iprot):
14625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14627 
      return
14628 
    iprot.readStructBegin()
14629 
    while True:
14630 
      (fname, ftype, fid) = iprot.readFieldBegin()
14631 
      if ftype == TType.STOP:
14632 
        break
14633 
      if fid == 0:
14634 
        if ftype == TType.BOOL:
14635 
          self.success = iprot.readBool();
14636 
        else:
14637 
          iprot.skip(ftype)
14638 
      else:
14639 
        iprot.skip(ftype)
14640 
      iprot.readFieldEnd()
14641 
    iprot.readStructEnd()
14642 
 
14643 
  def write(self, oprot):
14644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14646 
      return
14647 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14648 
    if self.success is not None:
14649 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14650 
      oprot.writeBool(self.success)
14651 
      oprot.writeFieldEnd()
14652 
    oprot.writeFieldStop()
14653 
    oprot.writeStructEnd()
14654 
 
14655 
  def validate(self):
14656 
    return
14657 
 
14658 
 
14659 
  def __repr__(self):
14660 
    L = ['%s=%r' % (key, value)
14661 
      for key, value in self.__dict__.iteritems()]
14662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14663 
 
14664 
  def __eq__(self, other):
14665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14666 
 
14667 
  def __ne__(self, other):
14668 
    return not (self == other)
14669 
 
9791 rajveer 14670 
class getProductsAddedToCart_args:
6821 amar.kumar 14671 
  """
14672 
  Attributes:
14673 
   - startDate
14674 
   - endDate
14675 
  """
14676 
 
14677 
  thrift_spec = (
14678 
    None, # 0
9791 rajveer 14679 
    (1, TType.I64, 'startDate', None, None, ), # 1
14680 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14681 
  )
14682 
 
9791 rajveer 14683 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14684 
    self.startDate = startDate
14685 
    self.endDate = endDate
14686 
 
14687 
  def read(self, iprot):
14688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14690 
      return
14691 
    iprot.readStructBegin()
14692 
    while True:
14693 
      (fname, ftype, fid) = iprot.readFieldBegin()
14694 
      if ftype == TType.STOP:
14695 
        break
14696 
      if fid == 1:
14697 
        if ftype == TType.I64:
9791 rajveer 14698 
          self.startDate = iprot.readI64();
6821 amar.kumar 14699 
        else:
14700 
          iprot.skip(ftype)
14701 
      elif fid == 2:
14702 
        if ftype == TType.I64:
14703 
          self.endDate = iprot.readI64();
14704 
        else:
14705 
          iprot.skip(ftype)
14706 
      else:
14707 
        iprot.skip(ftype)
14708 
      iprot.readFieldEnd()
14709 
    iprot.readStructEnd()
14710 
 
14711 
  def write(self, oprot):
14712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14714 
      return
9791 rajveer 14715 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14716 
    if self.startDate is not None:
9791 rajveer 14717 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14718 
      oprot.writeI64(self.startDate)
14719 
      oprot.writeFieldEnd()
14720 
    if self.endDate is not None:
9791 rajveer 14721 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14722 
      oprot.writeI64(self.endDate)
14723 
      oprot.writeFieldEnd()
14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
14741 
 
9791 rajveer 14742 
class getProductsAddedToCart_result:
6821 amar.kumar 14743 
  """
14744 
  Attributes:
14745 
   - success
14746 
  """
14747 
 
14748 
  thrift_spec = (
9791 rajveer 14749 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14750 
  )
14751 
 
14752 
  def __init__(self, success=None,):
14753 
    self.success = success
14754 
 
14755 
  def read(self, iprot):
14756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14758 
      return
14759 
    iprot.readStructBegin()
14760 
    while True:
14761 
      (fname, ftype, fid) = iprot.readFieldBegin()
14762 
      if ftype == TType.STOP:
14763 
        break
14764 
      if fid == 0:
9791 rajveer 14765 
        if ftype == TType.LIST:
14766 
          self.success = []
11980 amit.gupta 14767 
          (_etype221, _size218) = iprot.readListBegin()
14768 
          for _i222 in xrange(_size218):
14769 
            _elem223 = iprot.readI64();
14770 
            self.success.append(_elem223)
9791 rajveer 14771 
          iprot.readListEnd()
6821 amar.kumar 14772 
        else:
14773 
          iprot.skip(ftype)
14774 
      else:
14775 
        iprot.skip(ftype)
14776 
      iprot.readFieldEnd()
14777 
    iprot.readStructEnd()
14778 
 
14779 
  def write(self, oprot):
14780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14782 
      return
9791 rajveer 14783 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14784 
    if self.success is not None:
9791 rajveer 14785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14786 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14787 
      for iter224 in self.success:
14788 
        oprot.writeI64(iter224)
9791 rajveer 14789 
      oprot.writeListEnd()
6821 amar.kumar 14790 
      oprot.writeFieldEnd()
14791 
    oprot.writeFieldStop()
14792 
    oprot.writeStructEnd()
14793 
 
14794 
  def validate(self):
14795 
    return
14796 
 
14797 
 
14798 
  def __repr__(self):
14799 
    L = ['%s=%r' % (key, value)
14800 
      for key, value in self.__dict__.iteritems()]
14801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14802 
 
14803 
  def __eq__(self, other):
14804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14805 
 
14806 
  def __ne__(self, other):
14807 
    return not (self == other)
11592 amit.gupta 14808 
 
14809 
class validateCartPlus_args:
14810 
  """
14811 
  Attributes:
14812 
   - cartId
14813 
   - sourceId
11980 amit.gupta 14814 
   - dealerCoupon
11592 amit.gupta 14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    None, # 0
14819 
    (1, TType.I64, 'cartId', None, None, ), # 1
14820 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 14821 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 14822 
  )
14823 
 
11980 amit.gupta 14824 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 14825 
    self.cartId = cartId
14826 
    self.sourceId = sourceId
11980 amit.gupta 14827 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 14828 
 
14829 
  def read(self, iprot):
14830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14832 
      return
14833 
    iprot.readStructBegin()
14834 
    while True:
14835 
      (fname, ftype, fid) = iprot.readFieldBegin()
14836 
      if ftype == TType.STOP:
14837 
        break
14838 
      if fid == 1:
14839 
        if ftype == TType.I64:
14840 
          self.cartId = iprot.readI64();
14841 
        else:
14842 
          iprot.skip(ftype)
14843 
      elif fid == 2:
14844 
        if ftype == TType.I64:
14845 
          self.sourceId = iprot.readI64();
14846 
        else:
14847 
          iprot.skip(ftype)
11980 amit.gupta 14848 
      elif fid == 3:
14849 
        if ftype == TType.STRING:
14850 
          self.dealerCoupon = iprot.readString();
14851 
        else:
14852 
          iprot.skip(ftype)
11592 amit.gupta 14853 
      else:
14854 
        iprot.skip(ftype)
14855 
      iprot.readFieldEnd()
14856 
    iprot.readStructEnd()
14857 
 
14858 
  def write(self, oprot):
14859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14861 
      return
14862 
    oprot.writeStructBegin('validateCartPlus_args')
14863 
    if self.cartId is not None:
14864 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14865 
      oprot.writeI64(self.cartId)
14866 
      oprot.writeFieldEnd()
14867 
    if self.sourceId is not None:
14868 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14869 
      oprot.writeI64(self.sourceId)
14870 
      oprot.writeFieldEnd()
11980 amit.gupta 14871 
    if self.dealerCoupon is not None:
14872 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
14873 
      oprot.writeString(self.dealerCoupon)
14874 
      oprot.writeFieldEnd()
11592 amit.gupta 14875 
    oprot.writeFieldStop()
14876 
    oprot.writeStructEnd()
14877 
 
14878 
  def validate(self):
14879 
    return
14880 
 
14881 
 
14882 
  def __repr__(self):
14883 
    L = ['%s=%r' % (key, value)
14884 
      for key, value in self.__dict__.iteritems()]
14885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14886 
 
14887 
  def __eq__(self, other):
14888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14889 
 
14890 
  def __ne__(self, other):
14891 
    return not (self == other)
14892 
 
14893 
class validateCartPlus_result:
14894 
  """
14895 
  Attributes:
14896 
   - success
14897 
   - scex
14898 
  """
14899 
 
14900 
  thrift_spec = (
14901 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
14902 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
14903 
  )
14904 
 
14905 
  def __init__(self, success=None, scex=None,):
14906 
    self.success = success
14907 
    self.scex = scex
14908 
 
14909 
  def read(self, iprot):
14910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14912 
      return
14913 
    iprot.readStructBegin()
14914 
    while True:
14915 
      (fname, ftype, fid) = iprot.readFieldBegin()
14916 
      if ftype == TType.STOP:
14917 
        break
14918 
      if fid == 0:
14919 
        if ftype == TType.STRUCT:
14920 
          self.success = CartPlus()
14921 
          self.success.read(iprot)
14922 
        else:
14923 
          iprot.skip(ftype)
14924 
      elif fid == 1:
14925 
        if ftype == TType.STRUCT:
14926 
          self.scex = ShoppingCartException()
14927 
          self.scex.read(iprot)
14928 
        else:
14929 
          iprot.skip(ftype)
14930 
      else:
14931 
        iprot.skip(ftype)
14932 
      iprot.readFieldEnd()
14933 
    iprot.readStructEnd()
14934 
 
14935 
  def write(self, oprot):
14936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14938 
      return
14939 
    oprot.writeStructBegin('validateCartPlus_result')
14940 
    if self.success is not None:
14941 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14942 
      self.success.write(oprot)
14943 
      oprot.writeFieldEnd()
14944 
    if self.scex is not None:
14945 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
14946 
      self.scex.write(oprot)
14947 
      oprot.writeFieldEnd()
14948 
    oprot.writeFieldStop()
14949 
    oprot.writeStructEnd()
14950 
 
14951 
  def validate(self):
14952 
    return
14953 
 
14954 
 
14955 
  def __repr__(self):
14956 
    L = ['%s=%r' % (key, value)
14957 
      for key, value in self.__dict__.iteritems()]
14958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14959 
 
14960 
  def __eq__(self, other):
14961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14962 
 
14963 
  def __ne__(self, other):
14964 
    return not (self == other)
11679 vikram.rag 14965 
 
14966 
class isPrivateDealUser_args:
14967 
  """
14968 
  Attributes:
14969 
   - userId
14970 
  """
14971 
 
14972 
  thrift_spec = (
14973 
    None, # 0
14974 
    (1, TType.I64, 'userId', None, None, ), # 1
14975 
  )
14976 
 
14977 
  def __init__(self, userId=None,):
14978 
    self.userId = userId
14979 
 
14980 
  def read(self, iprot):
14981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14983 
      return
14984 
    iprot.readStructBegin()
14985 
    while True:
14986 
      (fname, ftype, fid) = iprot.readFieldBegin()
14987 
      if ftype == TType.STOP:
14988 
        break
14989 
      if fid == 1:
14990 
        if ftype == TType.I64:
14991 
          self.userId = iprot.readI64();
14992 
        else:
14993 
          iprot.skip(ftype)
14994 
      else:
14995 
        iprot.skip(ftype)
14996 
      iprot.readFieldEnd()
14997 
    iprot.readStructEnd()
14998 
 
14999 
  def write(self, oprot):
15000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15002 
      return
15003 
    oprot.writeStructBegin('isPrivateDealUser_args')
15004 
    if self.userId is not None:
15005 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15006 
      oprot.writeI64(self.userId)
15007 
      oprot.writeFieldEnd()
15008 
    oprot.writeFieldStop()
15009 
    oprot.writeStructEnd()
15010 
 
15011 
  def validate(self):
15012 
    return
15013 
 
15014 
 
15015 
  def __repr__(self):
15016 
    L = ['%s=%r' % (key, value)
15017 
      for key, value in self.__dict__.iteritems()]
15018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15019 
 
15020 
  def __eq__(self, other):
15021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15022 
 
15023 
  def __ne__(self, other):
15024 
    return not (self == other)
15025 
 
15026 
class isPrivateDealUser_result:
15027 
  """
15028 
  Attributes:
15029 
   - success
15030 
  """
15031 
 
15032 
  thrift_spec = (
15033 
    (0, TType.BOOL, 'success', None, None, ), # 0
15034 
  )
15035 
 
15036 
  def __init__(self, success=None,):
15037 
    self.success = success
15038 
 
15039 
  def read(self, iprot):
15040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15042 
      return
15043 
    iprot.readStructBegin()
15044 
    while True:
15045 
      (fname, ftype, fid) = iprot.readFieldBegin()
15046 
      if ftype == TType.STOP:
15047 
        break
15048 
      if fid == 0:
15049 
        if ftype == TType.BOOL:
15050 
          self.success = iprot.readBool();
15051 
        else:
15052 
          iprot.skip(ftype)
15053 
      else:
15054 
        iprot.skip(ftype)
15055 
      iprot.readFieldEnd()
15056 
    iprot.readStructEnd()
15057 
 
15058 
  def write(self, oprot):
15059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15061 
      return
15062 
    oprot.writeStructBegin('isPrivateDealUser_result')
15063 
    if self.success is not None:
15064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15065 
      oprot.writeBool(self.success)
15066 
      oprot.writeFieldEnd()
15067 
    oprot.writeFieldStop()
15068 
    oprot.writeStructEnd()
15069 
 
15070 
  def validate(self):
15071 
    return
15072 
 
15073 
 
15074 
  def __repr__(self):
15075 
    L = ['%s=%r' % (key, value)
15076 
      for key, value in self.__dict__.iteritems()]
15077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15078 
 
15079 
  def __eq__(self, other):
15080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15081 
 
15082 
  def __ne__(self, other):
15083 
    return not (self == other)
11890 kshitij.so 15084 
 
15085 
class addPrivateDealUser_args:
15086 
  """
15087 
  Attributes:
15088 
   - userId
15089 
  """
15090 
 
15091 
  thrift_spec = (
15092 
    None, # 0
15093 
    (1, TType.I64, 'userId', None, None, ), # 1
15094 
  )
15095 
 
15096 
  def __init__(self, userId=None,):
15097 
    self.userId = userId
15098 
 
15099 
  def read(self, iprot):
15100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15102 
      return
15103 
    iprot.readStructBegin()
15104 
    while True:
15105 
      (fname, ftype, fid) = iprot.readFieldBegin()
15106 
      if ftype == TType.STOP:
15107 
        break
15108 
      if fid == 1:
15109 
        if ftype == TType.I64:
15110 
          self.userId = iprot.readI64();
15111 
        else:
15112 
          iprot.skip(ftype)
15113 
      else:
15114 
        iprot.skip(ftype)
15115 
      iprot.readFieldEnd()
15116 
    iprot.readStructEnd()
15117 
 
15118 
  def write(self, oprot):
15119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15121 
      return
15122 
    oprot.writeStructBegin('addPrivateDealUser_args')
15123 
    if self.userId is not None:
15124 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15125 
      oprot.writeI64(self.userId)
15126 
      oprot.writeFieldEnd()
15127 
    oprot.writeFieldStop()
15128 
    oprot.writeStructEnd()
15129 
 
15130 
  def validate(self):
15131 
    return
15132 
 
15133 
 
15134 
  def __repr__(self):
15135 
    L = ['%s=%r' % (key, value)
15136 
      for key, value in self.__dict__.iteritems()]
15137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15138 
 
15139 
  def __eq__(self, other):
15140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15141 
 
15142 
  def __ne__(self, other):
15143 
    return not (self == other)
15144 
 
15145 
class addPrivateDealUser_result:
15146 
  """
15147 
  Attributes:
15148 
   - success
15149 
  """
15150 
 
15151 
  thrift_spec = (
15152 
    (0, TType.BOOL, 'success', None, None, ), # 0
15153 
  )
15154 
 
15155 
  def __init__(self, success=None,):
15156 
    self.success = success
15157 
 
15158 
  def read(self, iprot):
15159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15161 
      return
15162 
    iprot.readStructBegin()
15163 
    while True:
15164 
      (fname, ftype, fid) = iprot.readFieldBegin()
15165 
      if ftype == TType.STOP:
15166 
        break
15167 
      if fid == 0:
15168 
        if ftype == TType.BOOL:
15169 
          self.success = iprot.readBool();
15170 
        else:
15171 
          iprot.skip(ftype)
15172 
      else:
15173 
        iprot.skip(ftype)
15174 
      iprot.readFieldEnd()
15175 
    iprot.readStructEnd()
15176 
 
15177 
  def write(self, oprot):
15178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15180 
      return
15181 
    oprot.writeStructBegin('addPrivateDealUser_result')
15182 
    if self.success is not None:
15183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15184 
      oprot.writeBool(self.success)
15185 
      oprot.writeFieldEnd()
15186 
    oprot.writeFieldStop()
15187 
    oprot.writeStructEnd()
15188 
 
15189 
  def validate(self):
15190 
    return
15191 
 
15192 
 
15193 
  def __repr__(self):
15194 
    L = ['%s=%r' % (key, value)
15195 
      for key, value in self.__dict__.iteritems()]
15196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15197 
 
15198 
  def __eq__(self, other):
15199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15200 
 
15201 
  def __ne__(self, other):
15202 
    return not (self == other)
15203 
 
15204 
class changePrivateDealUserStatus_args:
15205 
  """
15206 
  Attributes:
15207 
   - userId
15208 
   - isActive
15209 
  """
15210 
 
15211 
  thrift_spec = (
15212 
    None, # 0
15213 
    (1, TType.I64, 'userId', None, None, ), # 1
15214 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15215 
  )
15216 
 
15217 
  def __init__(self, userId=None, isActive=None,):
15218 
    self.userId = userId
15219 
    self.isActive = isActive
15220 
 
15221 
  def read(self, iprot):
15222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15224 
      return
15225 
    iprot.readStructBegin()
15226 
    while True:
15227 
      (fname, ftype, fid) = iprot.readFieldBegin()
15228 
      if ftype == TType.STOP:
15229 
        break
15230 
      if fid == 1:
15231 
        if ftype == TType.I64:
15232 
          self.userId = iprot.readI64();
15233 
        else:
15234 
          iprot.skip(ftype)
15235 
      elif fid == 2:
15236 
        if ftype == TType.BOOL:
15237 
          self.isActive = iprot.readBool();
15238 
        else:
15239 
          iprot.skip(ftype)
15240 
      else:
15241 
        iprot.skip(ftype)
15242 
      iprot.readFieldEnd()
15243 
    iprot.readStructEnd()
15244 
 
15245 
  def write(self, oprot):
15246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15248 
      return
15249 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15250 
    if self.userId is not None:
15251 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15252 
      oprot.writeI64(self.userId)
15253 
      oprot.writeFieldEnd()
15254 
    if self.isActive is not None:
15255 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15256 
      oprot.writeBool(self.isActive)
15257 
      oprot.writeFieldEnd()
15258 
    oprot.writeFieldStop()
15259 
    oprot.writeStructEnd()
15260 
 
15261 
  def validate(self):
15262 
    return
15263 
 
15264 
 
15265 
  def __repr__(self):
15266 
    L = ['%s=%r' % (key, value)
15267 
      for key, value in self.__dict__.iteritems()]
15268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15269 
 
15270 
  def __eq__(self, other):
15271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15272 
 
15273 
  def __ne__(self, other):
15274 
    return not (self == other)
15275 
 
15276 
class changePrivateDealUserStatus_result:
15277 
  """
15278 
  Attributes:
15279 
   - success
15280 
  """
15281 
 
15282 
  thrift_spec = (
15283 
    (0, TType.BOOL, 'success', None, None, ), # 0
15284 
  )
15285 
 
15286 
  def __init__(self, success=None,):
15287 
    self.success = success
15288 
 
15289 
  def read(self, iprot):
15290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15292 
      return
15293 
    iprot.readStructBegin()
15294 
    while True:
15295 
      (fname, ftype, fid) = iprot.readFieldBegin()
15296 
      if ftype == TType.STOP:
15297 
        break
15298 
      if fid == 0:
15299 
        if ftype == TType.BOOL:
15300 
          self.success = iprot.readBool();
15301 
        else:
15302 
          iprot.skip(ftype)
15303 
      else:
15304 
        iprot.skip(ftype)
15305 
      iprot.readFieldEnd()
15306 
    iprot.readStructEnd()
15307 
 
15308 
  def write(self, oprot):
15309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15311 
      return
15312 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15313 
    if self.success is not None:
15314 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15315 
      oprot.writeBool(self.success)
15316 
      oprot.writeFieldEnd()
15317 
    oprot.writeFieldStop()
15318 
    oprot.writeStructEnd()
15319 
 
15320 
  def validate(self):
15321 
    return
15322 
 
15323 
 
15324 
  def __repr__(self):
15325 
    L = ['%s=%r' % (key, value)
15326 
      for key, value in self.__dict__.iteritems()]
15327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15328 
 
15329 
  def __eq__(self, other):
15330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15331 
 
15332 
  def __ne__(self, other):
15333 
    return not (self == other)
15334 
 
15335 
class getPrivateDealUser_args:
15336 
  """
15337 
  Attributes:
15338 
   - userId
15339 
  """
15340 
 
15341 
  thrift_spec = (
15342 
    None, # 0
15343 
    (1, TType.I64, 'userId', None, None, ), # 1
15344 
  )
15345 
 
15346 
  def __init__(self, userId=None,):
15347 
    self.userId = userId
15348 
 
15349 
  def read(self, iprot):
15350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15352 
      return
15353 
    iprot.readStructBegin()
15354 
    while True:
15355 
      (fname, ftype, fid) = iprot.readFieldBegin()
15356 
      if ftype == TType.STOP:
15357 
        break
15358 
      if fid == 1:
15359 
        if ftype == TType.I64:
15360 
          self.userId = iprot.readI64();
15361 
        else:
15362 
          iprot.skip(ftype)
15363 
      else:
15364 
        iprot.skip(ftype)
15365 
      iprot.readFieldEnd()
15366 
    iprot.readStructEnd()
15367 
 
15368 
  def write(self, oprot):
15369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15371 
      return
15372 
    oprot.writeStructBegin('getPrivateDealUser_args')
15373 
    if self.userId is not None:
15374 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15375 
      oprot.writeI64(self.userId)
15376 
      oprot.writeFieldEnd()
15377 
    oprot.writeFieldStop()
15378 
    oprot.writeStructEnd()
15379 
 
15380 
  def validate(self):
15381 
    return
15382 
 
15383 
 
15384 
  def __repr__(self):
15385 
    L = ['%s=%r' % (key, value)
15386 
      for key, value in self.__dict__.iteritems()]
15387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15388 
 
15389 
  def __eq__(self, other):
15390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15391 
 
15392 
  def __ne__(self, other):
15393 
    return not (self == other)
15394 
 
15395 
class getPrivateDealUser_result:
15396 
  """
15397 
  Attributes:
15398 
   - success
15399 
  """
15400 
 
15401 
  thrift_spec = (
15402 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15403 
  )
15404 
 
15405 
  def __init__(self, success=None,):
15406 
    self.success = success
15407 
 
15408 
  def read(self, iprot):
15409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15411 
      return
15412 
    iprot.readStructBegin()
15413 
    while True:
15414 
      (fname, ftype, fid) = iprot.readFieldBegin()
15415 
      if ftype == TType.STOP:
15416 
        break
15417 
      if fid == 0:
15418 
        if ftype == TType.STRUCT:
15419 
          self.success = PrivateDealUser()
15420 
          self.success.read(iprot)
15421 
        else:
15422 
          iprot.skip(ftype)
15423 
      else:
15424 
        iprot.skip(ftype)
15425 
      iprot.readFieldEnd()
15426 
    iprot.readStructEnd()
15427 
 
15428 
  def write(self, oprot):
15429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15431 
      return
15432 
    oprot.writeStructBegin('getPrivateDealUser_result')
15433 
    if self.success is not None:
15434 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15435 
      self.success.write(oprot)
15436 
      oprot.writeFieldEnd()
15437 
    oprot.writeFieldStop()
15438 
    oprot.writeStructEnd()
15439 
 
15440 
  def validate(self):
15441 
    return
15442 
 
15443 
 
15444 
  def __repr__(self):
15445 
    L = ['%s=%r' % (key, value)
15446 
      for key, value in self.__dict__.iteritems()]
15447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15448 
 
15449 
  def __eq__(self, other):
15450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15451 
 
15452 
  def __ne__(self, other):
15453 
    return not (self == other)
12696 amit.gupta 15454 
 
15455 
class registerCounter_args:
15456 
  """
15457 
  Attributes:
15458 
   - counter
15459 
   - userId
15460 
  """
15461 
 
15462 
  thrift_spec = (
15463 
    None, # 0
15464 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15465 
    (2, TType.I64, 'userId', None, None, ), # 2
15466 
  )
15467 
 
15468 
  def __init__(self, counter=None, userId=None,):
15469 
    self.counter = counter
15470 
    self.userId = userId
15471 
 
15472 
  def read(self, iprot):
15473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15475 
      return
15476 
    iprot.readStructBegin()
15477 
    while True:
15478 
      (fname, ftype, fid) = iprot.readFieldBegin()
15479 
      if ftype == TType.STOP:
15480 
        break
15481 
      if fid == 1:
15482 
        if ftype == TType.STRUCT:
15483 
          self.counter = Counter()
15484 
          self.counter.read(iprot)
15485 
        else:
15486 
          iprot.skip(ftype)
15487 
      elif fid == 2:
15488 
        if ftype == TType.I64:
15489 
          self.userId = iprot.readI64();
15490 
        else:
15491 
          iprot.skip(ftype)
15492 
      else:
15493 
        iprot.skip(ftype)
15494 
      iprot.readFieldEnd()
15495 
    iprot.readStructEnd()
15496 
 
15497 
  def write(self, oprot):
15498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15500 
      return
15501 
    oprot.writeStructBegin('registerCounter_args')
15502 
    if self.counter is not None:
15503 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15504 
      self.counter.write(oprot)
15505 
      oprot.writeFieldEnd()
15506 
    if self.userId is not None:
15507 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15508 
      oprot.writeI64(self.userId)
15509 
      oprot.writeFieldEnd()
15510 
    oprot.writeFieldStop()
15511 
    oprot.writeStructEnd()
15512 
 
15513 
  def validate(self):
15514 
    return
15515 
 
15516 
 
15517 
  def __repr__(self):
15518 
    L = ['%s=%r' % (key, value)
15519 
      for key, value in self.__dict__.iteritems()]
15520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15521 
 
15522 
  def __eq__(self, other):
15523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15524 
 
15525 
  def __ne__(self, other):
15526 
    return not (self == other)
15527 
 
15528 
class registerCounter_result:
15529 
  """
15530 
  Attributes:
15531 
   - success
15532 
  """
15533 
 
15534 
  thrift_spec = (
15535 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15536 
  )
15537 
 
15538 
  def __init__(self, success=None,):
15539 
    self.success = success
15540 
 
15541 
  def read(self, iprot):
15542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15544 
      return
15545 
    iprot.readStructBegin()
15546 
    while True:
15547 
      (fname, ftype, fid) = iprot.readFieldBegin()
15548 
      if ftype == TType.STOP:
15549 
        break
15550 
      if fid == 0:
15551 
        if ftype == TType.MAP:
15552 
          self.success = {}
15553 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15554 
          for _i229 in xrange(_size225):
15555 
            _key230 = iprot.readString();
15556 
            _val231 = iprot.readString();
15557 
            self.success[_key230] = _val231
15558 
          iprot.readMapEnd()
15559 
        else:
15560 
          iprot.skip(ftype)
15561 
      else:
15562 
        iprot.skip(ftype)
15563 
      iprot.readFieldEnd()
15564 
    iprot.readStructEnd()
15565 
 
15566 
  def write(self, oprot):
15567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15569 
      return
15570 
    oprot.writeStructBegin('registerCounter_result')
15571 
    if self.success is not None:
15572 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15573 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15574 
      for kiter232,viter233 in self.success.items():
15575 
        oprot.writeString(kiter232)
15576 
        oprot.writeString(viter233)
15577 
      oprot.writeMapEnd()
15578 
      oprot.writeFieldEnd()
15579 
    oprot.writeFieldStop()
15580 
    oprot.writeStructEnd()
15581 
 
15582 
  def validate(self):
15583 
    return
15584 
 
15585 
 
15586 
  def __repr__(self):
15587 
    L = ['%s=%r' % (key, value)
15588 
      for key, value in self.__dict__.iteritems()]
15589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15590 
 
15591 
  def __eq__(self, other):
15592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15593 
 
15594 
  def __ne__(self, other):
15595 
    return not (self == other)
12722 amit.gupta 15596 
 
15597 
class searchCounter_args:
15598 
  """
15599 
  Attributes:
15600 
   - type1
15601 
   - searchString
15602 
  """
15603 
 
15604 
  thrift_spec = (
15605 
    None, # 0
15606 
    (1, TType.STRING, 'type1', None, None, ), # 1
15607 
    (2, TType.STRING, 'searchString', None, None, ), # 2
15608 
  )
15609 
 
15610 
  def __init__(self, type1=None, searchString=None,):
15611 
    self.type1 = type1
15612 
    self.searchString = searchString
15613 
 
15614 
  def read(self, iprot):
15615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15617 
      return
15618 
    iprot.readStructBegin()
15619 
    while True:
15620 
      (fname, ftype, fid) = iprot.readFieldBegin()
15621 
      if ftype == TType.STOP:
15622 
        break
15623 
      if fid == 1:
15624 
        if ftype == TType.STRING:
15625 
          self.type1 = iprot.readString();
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      elif fid == 2:
15629 
        if ftype == TType.STRING:
15630 
          self.searchString = iprot.readString();
15631 
        else:
15632 
          iprot.skip(ftype)
15633 
      else:
15634 
        iprot.skip(ftype)
15635 
      iprot.readFieldEnd()
15636 
    iprot.readStructEnd()
15637 
 
15638 
  def write(self, oprot):
15639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15641 
      return
15642 
    oprot.writeStructBegin('searchCounter_args')
15643 
    if self.type1 is not None:
15644 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
15645 
      oprot.writeString(self.type1)
15646 
      oprot.writeFieldEnd()
15647 
    if self.searchString is not None:
15648 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
15649 
      oprot.writeString(self.searchString)
15650 
      oprot.writeFieldEnd()
15651 
    oprot.writeFieldStop()
15652 
    oprot.writeStructEnd()
15653 
 
15654 
  def validate(self):
15655 
    return
15656 
 
15657 
 
15658 
  def __repr__(self):
15659 
    L = ['%s=%r' % (key, value)
15660 
      for key, value in self.__dict__.iteritems()]
15661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15662 
 
15663 
  def __eq__(self, other):
15664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15665 
 
15666 
  def __ne__(self, other):
15667 
    return not (self == other)
15668 
 
15669 
class searchCounter_result:
15670 
  """
15671 
  Attributes:
15672 
   - success
15673 
  """
15674 
 
15675 
  thrift_spec = (
15676 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
15677 
  )
15678 
 
15679 
  def __init__(self, success=None,):
15680 
    self.success = success
15681 
 
15682 
  def read(self, iprot):
15683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15685 
      return
15686 
    iprot.readStructBegin()
15687 
    while True:
15688 
      (fname, ftype, fid) = iprot.readFieldBegin()
15689 
      if ftype == TType.STOP:
15690 
        break
15691 
      if fid == 0:
15692 
        if ftype == TType.LIST:
15693 
          self.success = []
15694 
          (_etype237, _size234) = iprot.readListBegin()
15695 
          for _i238 in xrange(_size234):
15696 
            _elem239 = Counter()
15697 
            _elem239.read(iprot)
15698 
            self.success.append(_elem239)
15699 
          iprot.readListEnd()
15700 
        else:
15701 
          iprot.skip(ftype)
15702 
      else:
15703 
        iprot.skip(ftype)
15704 
      iprot.readFieldEnd()
15705 
    iprot.readStructEnd()
15706 
 
15707 
  def write(self, oprot):
15708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15710 
      return
15711 
    oprot.writeStructBegin('searchCounter_result')
15712 
    if self.success is not None:
15713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15715 
      for iter240 in self.success:
15716 
        iter240.write(oprot)
15717 
      oprot.writeListEnd()
15718 
      oprot.writeFieldEnd()
15719 
    oprot.writeFieldStop()
15720 
    oprot.writeStructEnd()
15721 
 
15722 
  def validate(self):
15723 
    return
15724 
 
15725 
 
15726 
  def __repr__(self):
15727 
    L = ['%s=%r' % (key, value)
15728 
      for key, value in self.__dict__.iteritems()]
15729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15730 
 
15731 
  def __eq__(self, other):
15732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15733 
 
15734 
  def __ne__(self, other):
15735 
    return not (self == other)
15736 
 
15737 
class getAllUsersByCounter_args:
15738 
  """
15739 
  Attributes:
15740 
   - counterId
15741 
  """
15742 
 
15743 
  thrift_spec = (
15744 
    None, # 0
15745 
    (1, TType.I64, 'counterId', None, None, ), # 1
15746 
  )
15747 
 
15748 
  def __init__(self, counterId=None,):
15749 
    self.counterId = counterId
15750 
 
15751 
  def read(self, iprot):
15752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15754 
      return
15755 
    iprot.readStructBegin()
15756 
    while True:
15757 
      (fname, ftype, fid) = iprot.readFieldBegin()
15758 
      if ftype == TType.STOP:
15759 
        break
15760 
      if fid == 1:
15761 
        if ftype == TType.I64:
15762 
          self.counterId = iprot.readI64();
15763 
        else:
15764 
          iprot.skip(ftype)
15765 
      else:
15766 
        iprot.skip(ftype)
15767 
      iprot.readFieldEnd()
15768 
    iprot.readStructEnd()
15769 
 
15770 
  def write(self, oprot):
15771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15773 
      return
15774 
    oprot.writeStructBegin('getAllUsersByCounter_args')
15775 
    if self.counterId is not None:
15776 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
15777 
      oprot.writeI64(self.counterId)
15778 
      oprot.writeFieldEnd()
15779 
    oprot.writeFieldStop()
15780 
    oprot.writeStructEnd()
15781 
 
15782 
  def validate(self):
15783 
    return
15784 
 
15785 
 
15786 
  def __repr__(self):
15787 
    L = ['%s=%r' % (key, value)
15788 
      for key, value in self.__dict__.iteritems()]
15789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15790 
 
15791 
  def __eq__(self, other):
15792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15793 
 
15794 
  def __ne__(self, other):
15795 
    return not (self == other)
15796 
 
15797 
class getAllUsersByCounter_result:
15798 
  """
15799 
  Attributes:
15800 
   - success
15801 
  """
15802 
 
15803 
  thrift_spec = (
15804 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
15805 
  )
15806 
 
15807 
  def __init__(self, success=None,):
15808 
    self.success = success
15809 
 
15810 
  def read(self, iprot):
15811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15813 
      return
15814 
    iprot.readStructBegin()
15815 
    while True:
15816 
      (fname, ftype, fid) = iprot.readFieldBegin()
15817 
      if ftype == TType.STOP:
15818 
        break
15819 
      if fid == 0:
15820 
        if ftype == TType.LIST:
15821 
          self.success = []
15822 
          (_etype244, _size241) = iprot.readListBegin()
15823 
          for _i245 in xrange(_size241):
15824 
            _elem246 = User()
15825 
            _elem246.read(iprot)
15826 
            self.success.append(_elem246)
15827 
          iprot.readListEnd()
15828 
        else:
15829 
          iprot.skip(ftype)
15830 
      else:
15831 
        iprot.skip(ftype)
15832 
      iprot.readFieldEnd()
15833 
    iprot.readStructEnd()
15834 
 
15835 
  def write(self, oprot):
15836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15838 
      return
15839 
    oprot.writeStructBegin('getAllUsersByCounter_result')
15840 
    if self.success is not None:
15841 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15842 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15843 
      for iter247 in self.success:
15844 
        iter247.write(oprot)
15845 
      oprot.writeListEnd()
15846 
      oprot.writeFieldEnd()
15847 
    oprot.writeFieldStop()
15848 
    oprot.writeStructEnd()
15849 
 
15850 
  def validate(self):
15851 
    return
15852 
 
15853 
 
15854 
  def __repr__(self):
15855 
    L = ['%s=%r' % (key, value)
15856 
      for key, value in self.__dict__.iteritems()]
15857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15858 
 
15859 
  def __eq__(self, other):
15860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15861 
 
15862 
  def __ne__(self, other):
15863 
    return not (self == other)