Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
12722 amit.gupta 713 
  def getAllUsersByCounter(self, counterId):
714 
    """
715 
    Parameters:
716 
     - counterId
717 
    """
718 
    pass
719 
 
15251 manish.sha 720 
  def getActiveAccessTokenForUser(self, userId, source):
721 
    """
722 
    Parameters:
723 
     - userId
724 
     - source
725 
    """
726 
    pass
12722 amit.gupta 727 
 
15251 manish.sha 728 
  def validateAccessToken(self, accessToken):
729 
    """
730 
    Parameters:
731 
     - accessToken
732 
    """
733 
    pass
734 
 
17782 amit.gupta 735 
  def addItemsToCart(self, cartId, itemQty, couponCode):
736 
    """
737 
    Parameters:
738 
     - cartId
739 
     - itemQty
740 
     - couponCode
741 
    """
742 
    pass
15251 manish.sha 743 
 
17782 amit.gupta 744 
  def validateCartNew(self, cartId, pinCode, sourceId):
745 
    """
746 
    Parameters:
747 
     - cartId
748 
     - pinCode
749 
     - sourceId
750 
    """
751 
    pass
752 
 
18644 manish.sha 753 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 754 
    """
755 
    Parameters:
756 
     - userId
757 
    """
758 
    pass
17782 amit.gupta 759 
 
18530 manish.sha 760 
  def getBillingAddressForUser(self, userId):
761 
    """
762 
    Parameters:
763 
     - userId
764 
    """
765 
    pass
766 
 
18590 manish.sha 767 
  def isCreditorAssigned(self, userId):
768 
    """
769 
    Parameters:
770 
     - userId
771 
    """
772 
    pass
18530 manish.sha 773 
 
18735 manish.sha 774 
  def isTaxInvoiceEnabledUser(self, userId):
775 
    """
776 
    Parameters:
777 
     - userId
778 
    """
779 
    pass
18590 manish.sha 780 
 
18764 kshitij.so 781 
  def getCartByValue(self, cartIds):
782 
    """
783 
    Parameters:
784 
     - cartIds
785 
    """
786 
    pass
18735 manish.sha 787 
 
18764 kshitij.so 788 
 
3376 rajveer 789 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 790 
  """
791 
  service
792 
  """
793 
  def __init__(self, iprot, oprot=None):
3376 rajveer 794 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 795 
 
559 chandransh 796 
  def createAnonymousUser(self, jsessionId):
94 ashish 797 
    """
798 
    Parameters:
559 chandransh 799 
     - jsessionId
94 ashish 800 
    """
559 chandransh 801 
    self.send_createAnonymousUser(jsessionId)
802 
    return self.recv_createAnonymousUser()
94 ashish 803 
 
559 chandransh 804 
  def send_createAnonymousUser(self, jsessionId):
805 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
806 
    args = createAnonymousUser_args()
807 
    args.jsessionId = jsessionId
94 ashish 808 
    args.write(self._oprot)
809 
    self._oprot.writeMessageEnd()
810 
    self._oprot.trans.flush()
811 
 
559 chandransh 812 
  def recv_createAnonymousUser(self, ):
94 ashish 813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
814 
    if mtype == TMessageType.EXCEPTION:
815 
      x = TApplicationException()
816 
      x.read(self._iprot)
817 
      self._iprot.readMessageEnd()
818 
      raise x
559 chandransh 819 
    result = createAnonymousUser_result()
94 ashish 820 
    result.read(self._iprot)
821 
    self._iprot.readMessageEnd()
3431 rajveer 822 
    if result.success is not None:
94 ashish 823 
      return result.success
3431 rajveer 824 
    if result.ucex is not None:
559 chandransh 825 
      raise result.ucex
826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 827 
 
559 chandransh 828 
  def getUserById(self, userId):
94 ashish 829 
    """
830 
    Parameters:
831 
     - userId
832 
    """
559 chandransh 833 
    self.send_getUserById(userId)
834 
    return self.recv_getUserById()
94 ashish 835 
 
559 chandransh 836 
  def send_getUserById(self, userId):
837 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
838 
    args = getUserById_args()
94 ashish 839 
    args.userId = userId
840 
    args.write(self._oprot)
841 
    self._oprot.writeMessageEnd()
842 
    self._oprot.trans.flush()
843 
 
559 chandransh 844 
  def recv_getUserById(self, ):
94 ashish 845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
846 
    if mtype == TMessageType.EXCEPTION:
847 
      x = TApplicationException()
848 
      x.read(self._iprot)
849 
      self._iprot.readMessageEnd()
850 
      raise x
559 chandransh 851 
    result = getUserById_result()
94 ashish 852 
    result.read(self._iprot)
853 
    self._iprot.readMessageEnd()
3431 rajveer 854 
    if result.success is not None:
94 ashish 855 
      return result.success
3431 rajveer 856 
    if result.ucex is not None:
559 chandransh 857 
      raise result.ucex
858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 859 
 
5326 rajveer 860 
  def getUserByCartId(self, cartId):
861 
    """
862 
    Parameters:
863 
     - cartId
864 
    """
865 
    self.send_getUserByCartId(cartId)
866 
    return self.recv_getUserByCartId()
867 
 
868 
  def send_getUserByCartId(self, cartId):
869 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
870 
    args = getUserByCartId_args()
871 
    args.cartId = cartId
872 
    args.write(self._oprot)
873 
    self._oprot.writeMessageEnd()
874 
    self._oprot.trans.flush()
875 
 
876 
  def recv_getUserByCartId(self, ):
877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
878 
    if mtype == TMessageType.EXCEPTION:
879 
      x = TApplicationException()
880 
      x.read(self._iprot)
881 
      self._iprot.readMessageEnd()
882 
      raise x
883 
    result = getUserByCartId_result()
884 
    result.read(self._iprot)
885 
    self._iprot.readMessageEnd()
886 
    if result.success is not None:
887 
      return result.success
888 
    if result.ucex is not None:
889 
      raise result.ucex
890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
891 
 
1491 vikas 892 
  def getUserByEmail(self, email):
893 
    """
894 
    Parameters:
895 
     - email
896 
    """
897 
    self.send_getUserByEmail(email)
898 
    return self.recv_getUserByEmail()
899 
 
900 
  def send_getUserByEmail(self, email):
901 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
902 
    args = getUserByEmail_args()
903 
    args.email = email
904 
    args.write(self._oprot)
905 
    self._oprot.writeMessageEnd()
906 
    self._oprot.trans.flush()
907 
 
908 
  def recv_getUserByEmail(self, ):
909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
910 
    if mtype == TMessageType.EXCEPTION:
911 
      x = TApplicationException()
912 
      x.read(self._iprot)
913 
      self._iprot.readMessageEnd()
914 
      raise x
915 
    result = getUserByEmail_result()
916 
    result.read(self._iprot)
917 
    self._iprot.readMessageEnd()
3431 rajveer 918 
    if result.success is not None:
1491 vikas 919 
      return result.success
3431 rajveer 920 
    if result.ucex is not None:
1491 vikas 921 
      raise result.ucex
922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
923 
 
3032 mandeep.dh 924 
  def getUserByMobileNumber(self, mobileNumber):
925 
    """
926 
    Parameters:
927 
     - mobileNumber
928 
    """
929 
    self.send_getUserByMobileNumber(mobileNumber)
930 
    return self.recv_getUserByMobileNumber()
931 
 
932 
  def send_getUserByMobileNumber(self, mobileNumber):
933 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
934 
    args = getUserByMobileNumber_args()
935 
    args.mobileNumber = mobileNumber
936 
    args.write(self._oprot)
937 
    self._oprot.writeMessageEnd()
938 
    self._oprot.trans.flush()
939 
 
940 
  def recv_getUserByMobileNumber(self, ):
941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
942 
    if mtype == TMessageType.EXCEPTION:
943 
      x = TApplicationException()
944 
      x.read(self._iprot)
945 
      self._iprot.readMessageEnd()
946 
      raise x
947 
    result = getUserByMobileNumber_result()
948 
    result.read(self._iprot)
949 
    self._iprot.readMessageEnd()
3431 rajveer 950 
    if result.success is not None:
3032 mandeep.dh 951 
      return result.success
3431 rajveer 952 
    if result.ucex is not None:
3032 mandeep.dh 953 
      raise result.ucex
954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
955 
 
559 chandransh 956 
  def createUser(self, user):
94 ashish 957 
    """
958 
    Parameters:
559 chandransh 959 
     - user
94 ashish 960 
    """
559 chandransh 961 
    self.send_createUser(user)
962 
    return self.recv_createUser()
94 ashish 963 
 
559 chandransh 964 
  def send_createUser(self, user):
965 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
966 
    args = createUser_args()
967 
    args.user = user
94 ashish 968 
    args.write(self._oprot)
969 
    self._oprot.writeMessageEnd()
970 
    self._oprot.trans.flush()
971 
 
559 chandransh 972 
  def recv_createUser(self, ):
94 ashish 973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
974 
    if mtype == TMessageType.EXCEPTION:
975 
      x = TApplicationException()
976 
      x.read(self._iprot)
977 
      self._iprot.readMessageEnd()
978 
      raise x
559 chandransh 979 
    result = createUser_result()
94 ashish 980 
    result.read(self._iprot)
981 
    self._iprot.readMessageEnd()
3431 rajveer 982 
    if result.success is not None:
94 ashish 983 
      return result.success
3431 rajveer 984 
    if result.ucex is not None:
559 chandransh 985 
      raise result.ucex
986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 987 
 
559 chandransh 988 
  def updateUser(self, user):
94 ashish 989 
    """
990 
    Parameters:
559 chandransh 991 
     - user
94 ashish 992 
    """
559 chandransh 993 
    self.send_updateUser(user)
994 
    return self.recv_updateUser()
94 ashish 995 
 
559 chandransh 996 
  def send_updateUser(self, user):
997 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
998 
    args = updateUser_args()
999 
    args.user = user
94 ashish 1000 
    args.write(self._oprot)
1001 
    self._oprot.writeMessageEnd()
1002 
    self._oprot.trans.flush()
1003 
 
559 chandransh 1004 
  def recv_updateUser(self, ):
94 ashish 1005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1006 
    if mtype == TMessageType.EXCEPTION:
1007 
      x = TApplicationException()
1008 
      x.read(self._iprot)
1009 
      self._iprot.readMessageEnd()
1010 
      raise x
559 chandransh 1011 
    result = updateUser_result()
94 ashish 1012 
    result.read(self._iprot)
1013 
    self._iprot.readMessageEnd()
3431 rajveer 1014 
    if result.success is not None:
94 ashish 1015 
      return result.success
3431 rajveer 1016 
    if result.ucex is not None:
559 chandransh 1017 
      raise result.ucex
1018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1019 
 
559 chandransh 1020 
  def authenticateUser(self, email, password):
94 ashish 1021 
    """
1022 
    Parameters:
1023 
     - email
1024 
     - password
1025 
    """
559 chandransh 1026 
    self.send_authenticateUser(email, password)
122 ashish 1027 
    return self.recv_authenticateUser()
1028 
 
559 chandransh 1029 
  def send_authenticateUser(self, email, password):
122 ashish 1030 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1031 
    args = authenticateUser_args()
559 chandransh 1032 
    args.email = email
122 ashish 1033 
    args.password = password
1034 
    args.write(self._oprot)
1035 
    self._oprot.writeMessageEnd()
1036 
    self._oprot.trans.flush()
1037 
 
1038 
  def recv_authenticateUser(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 = authenticateUser_result()
1046 
    result.read(self._iprot)
1047 
    self._iprot.readMessageEnd()
3431 rajveer 1048 
    if result.success is not None:
122 ashish 1049 
      return result.success
3431 rajveer 1050 
    if result.auex is not None:
559 chandransh 1051 
      raise result.auex
122 ashish 1052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1053 
 
94 ashish 1054 
  def userExists(self, email):
1055 
    """
1056 
    Parameters:
1057 
     - email
1058 
    """
1059 
    self.send_userExists(email)
1060 
    return self.recv_userExists()
1061 
 
1062 
  def send_userExists(self, email):
1063 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1064 
    args = userExists_args()
1065 
    args.email = email
1066 
    args.write(self._oprot)
1067 
    self._oprot.writeMessageEnd()
1068 
    self._oprot.trans.flush()
1069 
 
1070 
  def recv_userExists(self, ):
1071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1072 
    if mtype == TMessageType.EXCEPTION:
1073 
      x = TApplicationException()
1074 
      x.read(self._iprot)
1075 
      self._iprot.readMessageEnd()
1076 
      raise x
1077 
    result = userExists_result()
1078 
    result.read(self._iprot)
1079 
    self._iprot.readMessageEnd()
3431 rajveer 1080 
    if result.success is not None:
94 ashish 1081 
      return result.success
3431 rajveer 1082 
    if result.ucx is not None:
94 ashish 1083 
      raise result.ucx
1084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1085 
 
567 rajveer 1086 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1087 
    """
1088 
    Parameters:
1089 
     - userId
1090 
     - address
513 rajveer 1091 
     - setDefault
94 ashish 1092 
    """
567 rajveer 1093 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1094 
    return self.recv_addAddressForUser()
1095 
 
567 rajveer 1096 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1097 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1098 
    args = addAddressForUser_args()
559 chandransh 1099 
    args.userId = userId
94 ashish 1100 
    args.address = address
513 rajveer 1101 
    args.setDefault = setDefault
94 ashish 1102 
    args.write(self._oprot)
1103 
    self._oprot.writeMessageEnd()
1104 
    self._oprot.trans.flush()
1105 
 
1106 
  def recv_addAddressForUser(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 = addAddressForUser_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, "addAddressForUser failed: unknown result");
1121 
 
1122 
  def removeAddressForUser(self, userid, addressId):
1123 
    """
1124 
    Parameters:
1125 
     - userid
1126 
     - addressId
1127 
    """
1128 
    self.send_removeAddressForUser(userid, addressId)
1129 
    return self.recv_removeAddressForUser()
1130 
 
1131 
  def send_removeAddressForUser(self, userid, addressId):
1132 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1133 
    args = removeAddressForUser_args()
1134 
    args.userid = userid
1135 
    args.addressId = addressId
1136 
    args.write(self._oprot)
1137 
    self._oprot.writeMessageEnd()
1138 
    self._oprot.trans.flush()
1139 
 
1140 
  def recv_removeAddressForUser(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 = removeAddressForUser_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, "removeAddressForUser failed: unknown result");
1155 
 
1156 
  def setUserAsLoggedIn(self, userId, timestamp):
1157 
    """
1158 
    Parameters:
1159 
     - userId
1160 
     - timestamp
1161 
    """
1162 
    self.send_setUserAsLoggedIn(userId, timestamp)
1163 
    return self.recv_setUserAsLoggedIn()
1164 
 
1165 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1166 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1167 
    args = setUserAsLoggedIn_args()
1168 
    args.userId = userId
1169 
    args.timestamp = timestamp
1170 
    args.write(self._oprot)
1171 
    self._oprot.writeMessageEnd()
1172 
    self._oprot.trans.flush()
1173 
 
1174 
  def recv_setUserAsLoggedIn(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 = setUserAsLoggedIn_result()
1182 
    result.read(self._iprot)
1183 
    self._iprot.readMessageEnd()
3431 rajveer 1184 
    if result.success is not None:
94 ashish 1185 
      return result.success
3431 rajveer 1186 
    if result.ucx is not None:
94 ashish 1187 
      raise result.ucx
1188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1189 
 
1190 
  def setUserAsLoggedOut(self, userid, timestamp):
1191 
    """
1192 
    Parameters:
1193 
     - userid
1194 
     - timestamp
1195 
    """
1196 
    self.send_setUserAsLoggedOut(userid, timestamp)
1197 
    return self.recv_setUserAsLoggedOut()
1198 
 
1199 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1200 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1201 
    args = setUserAsLoggedOut_args()
1202 
    args.userid = userid
1203 
    args.timestamp = timestamp
1204 
    args.write(self._oprot)
1205 
    self._oprot.writeMessageEnd()
1206 
    self._oprot.trans.flush()
1207 
 
1208 
  def recv_setUserAsLoggedOut(self, ):
1209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1210 
    if mtype == TMessageType.EXCEPTION:
1211 
      x = TApplicationException()
1212 
      x.read(self._iprot)
1213 
      self._iprot.readMessageEnd()
1214 
      raise x
1215 
    result = setUserAsLoggedOut_result()
1216 
    result.read(self._iprot)
1217 
    self._iprot.readMessageEnd()
3431 rajveer 1218 
    if result.success is not None:
94 ashish 1219 
      return result.success
3431 rajveer 1220 
    if result.ucx is not None:
94 ashish 1221 
      raise result.ucx
1222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1223 
 
504 rajveer 1224 
  def setDefaultAddress(self, userid, addressId):
1225 
    """
1226 
    Parameters:
1227 
     - userid
1228 
     - addressId
1229 
    """
1230 
    self.send_setDefaultAddress(userid, addressId)
1231 
    return self.recv_setDefaultAddress()
1232 
 
1233 
  def send_setDefaultAddress(self, userid, addressId):
1234 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1235 
    args = setDefaultAddress_args()
1236 
    args.userid = userid
1237 
    args.addressId = addressId
1238 
    args.write(self._oprot)
1239 
    self._oprot.writeMessageEnd()
1240 
    self._oprot.trans.flush()
1241 
 
1242 
  def recv_setDefaultAddress(self, ):
1243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1244 
    if mtype == TMessageType.EXCEPTION:
1245 
      x = TApplicationException()
1246 
      x.read(self._iprot)
1247 
      self._iprot.readMessageEnd()
1248 
      raise x
1249 
    result = setDefaultAddress_result()
1250 
    result.read(self._iprot)
1251 
    self._iprot.readMessageEnd()
3431 rajveer 1252 
    if result.success is not None:
504 rajveer 1253 
      return result.success
3431 rajveer 1254 
    if result.ucx is not None:
504 rajveer 1255 
      raise result.ucx
1256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1257 
 
594 rajveer 1258 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1259 
    """
1260 
    Parameters:
1261 
     - userid
594 rajveer 1262 
     - oldPassword
1263 
     - newPassword
94 ashish 1264 
    """
594 rajveer 1265 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1266 
    return self.recv_updatePassword()
1267 
 
594 rajveer 1268 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1269 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1270 
    args = updatePassword_args()
1271 
    args.userid = userid
594 rajveer 1272 
    args.oldPassword = oldPassword
1273 
    args.newPassword = newPassword
94 ashish 1274 
    args.write(self._oprot)
1275 
    self._oprot.writeMessageEnd()
1276 
    self._oprot.trans.flush()
1277 
 
1278 
  def recv_updatePassword(self, ):
1279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1280 
    if mtype == TMessageType.EXCEPTION:
1281 
      x = TApplicationException()
1282 
      x.read(self._iprot)
1283 
      self._iprot.readMessageEnd()
1284 
      raise x
1285 
    result = updatePassword_result()
1286 
    result.read(self._iprot)
1287 
    self._iprot.readMessageEnd()
3431 rajveer 1288 
    if result.success is not None:
94 ashish 1289 
      return result.success
3431 rajveer 1290 
    if result.ucx is not None:
94 ashish 1291 
      raise result.ucx
1292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1293 
 
884 rajveer 1294 
  def forgotPassword(self, email, newPassword):
581 rajveer 1295 
    """
1296 
    Parameters:
1297 
     - email
884 rajveer 1298 
     - newPassword
581 rajveer 1299 
    """
884 rajveer 1300 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1301 
    return self.recv_forgotPassword()
1302 
 
884 rajveer 1303 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1304 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1305 
    args = forgotPassword_args()
1306 
    args.email = email
884 rajveer 1307 
    args.newPassword = newPassword
581 rajveer 1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_forgotPassword(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = forgotPassword_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
3431 rajveer 1322 
    if result.success is not None:
581 rajveer 1323 
      return result.success
3431 rajveer 1324 
    if result.ucx is not None:
581 rajveer 1325 
      raise result.ucx
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1327 
 
594 rajveer 1328 
  def getAllAddressesForUser(self, userId):
1329 
    """
1330 
    Parameters:
1331 
     - userId
1332 
    """
1333 
    self.send_getAllAddressesForUser(userId)
1334 
    return self.recv_getAllAddressesForUser()
1335 
 
1336 
  def send_getAllAddressesForUser(self, userId):
1337 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1338 
    args = getAllAddressesForUser_args()
1339 
    args.userId = userId
1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
1344 
  def recv_getAllAddressesForUser(self, ):
1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
1351 
    result = getAllAddressesForUser_result()
1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
3431 rajveer 1354 
    if result.success is not None:
594 rajveer 1355 
      return result.success
3431 rajveer 1356 
    if result.ucx is not None:
594 rajveer 1357 
      raise result.ucx
1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1359 
 
1894 vikas 1360 
  def getAddressById(self, addressId):
1361 
    """
1362 
    Parameters:
1363 
     - addressId
1364 
    """
1365 
    self.send_getAddressById(addressId)
1366 
    return self.recv_getAddressById()
1367 
 
1368 
  def send_getAddressById(self, addressId):
1369 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1370 
    args = getAddressById_args()
1371 
    args.addressId = addressId
1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
1376 
  def recv_getAddressById(self, ):
1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
1383 
    result = getAddressById_result()
1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
3431 rajveer 1386 
    if result.success is not None:
1894 vikas 1387 
      return result.success
3431 rajveer 1388 
    if result.ucx is not None:
1894 vikas 1389 
      raise result.ucx
1390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1391 
 
594 rajveer 1392 
  def getDefaultAddressId(self, userId):
1393 
    """
1394 
    Parameters:
1395 
     - userId
1396 
    """
1397 
    self.send_getDefaultAddressId(userId)
1398 
    return self.recv_getDefaultAddressId()
1399 
 
1400 
  def send_getDefaultAddressId(self, userId):
1401 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1402 
    args = getDefaultAddressId_args()
1403 
    args.userId = userId
1404 
    args.write(self._oprot)
1405 
    self._oprot.writeMessageEnd()
1406 
    self._oprot.trans.flush()
1407 
 
1408 
  def recv_getDefaultAddressId(self, ):
1409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1410 
    if mtype == TMessageType.EXCEPTION:
1411 
      x = TApplicationException()
1412 
      x.read(self._iprot)
1413 
      self._iprot.readMessageEnd()
1414 
      raise x
1415 
    result = getDefaultAddressId_result()
1416 
    result.read(self._iprot)
1417 
    self._iprot.readMessageEnd()
3431 rajveer 1418 
    if result.success is not None:
594 rajveer 1419 
      return result.success
3431 rajveer 1420 
    if result.ucx is not None:
594 rajveer 1421 
      raise result.ucx
1422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1423 
 
785 rajveer 1424 
  def getDefaultPincode(self, userId):
1425 
    """
1426 
    Parameters:
1427 
     - userId
1428 
    """
1429 
    self.send_getDefaultPincode(userId)
1430 
    return self.recv_getDefaultPincode()
1431 
 
1432 
  def send_getDefaultPincode(self, userId):
1433 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1434 
    args = getDefaultPincode_args()
1435 
    args.userId = userId
1436 
    args.write(self._oprot)
1437 
    self._oprot.writeMessageEnd()
1438 
    self._oprot.trans.flush()
1439 
 
1440 
  def recv_getDefaultPincode(self, ):
1441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1442 
    if mtype == TMessageType.EXCEPTION:
1443 
      x = TApplicationException()
1444 
      x.read(self._iprot)
1445 
      self._iprot.readMessageEnd()
1446 
      raise x
1447 
    result = getDefaultPincode_result()
1448 
    result.read(self._iprot)
1449 
    self._iprot.readMessageEnd()
3431 rajveer 1450 
    if result.success is not None:
785 rajveer 1451 
      return result.success
3431 rajveer 1452 
    if result.ucx is not None:
785 rajveer 1453 
      raise result.ucx
1454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1455 
 
1274 varun.gupt 1456 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1457 
    """
1458 
    Parameters:
1459 
     - userId
1460 
     - replyTo
1461 
     - communicationType
1462 
     - orderId
1463 
     - airwaybillNo
1464 
     - productName
1465 
     - subject
1466 
     - message
1467 
    """
1468 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1469 
    return self.recv_saveUserCommunication()
1470 
 
1471 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1472 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1473 
    args = saveUserCommunication_args()
1474 
    args.userId = userId
1475 
    args.replyTo = replyTo
1476 
    args.communicationType = communicationType
1477 
    args.orderId = orderId
1478 
    args.airwaybillNo = airwaybillNo
1479 
    args.productName = productName
1480 
    args.subject = subject
1481 
    args.message = message
1482 
    args.write(self._oprot)
1483 
    self._oprot.writeMessageEnd()
1484 
    self._oprot.trans.flush()
1485 
 
1486 
  def recv_saveUserCommunication(self, ):
1487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1488 
    if mtype == TMessageType.EXCEPTION:
1489 
      x = TApplicationException()
1490 
      x.read(self._iprot)
1491 
      self._iprot.readMessageEnd()
1492 
      raise x
1493 
    result = saveUserCommunication_result()
1494 
    result.read(self._iprot)
1495 
    self._iprot.readMessageEnd()
3431 rajveer 1496 
    if result.success is not None:
1274 varun.gupt 1497 
      return result.success
3431 rajveer 1498 
    if result.ucx is not None:
1274 varun.gupt 1499 
      raise result.ucx
1500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1501 
 
1590 varun.gupt 1502 
  def getUserCommunicationById(self, id):
1503 
    """
1504 
    Parameters:
1505 
     - id
1506 
    """
1507 
    self.send_getUserCommunicationById(id)
1508 
    return self.recv_getUserCommunicationById()
1509 
 
1510 
  def send_getUserCommunicationById(self, id):
1511 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1512 
    args = getUserCommunicationById_args()
1513 
    args.id = id
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_getUserCommunicationById(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = getUserCommunicationById_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
3431 rajveer 1528 
    if result.success is not None:
1590 varun.gupt 1529 
      return result.success
3431 rajveer 1530 
    if result.ucx is not None:
1590 varun.gupt 1531 
      raise result.ucx
1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1533 
 
1534 
  def getUserCommunicationByUser(self, userId):
1535 
    """
1536 
    Parameters:
1537 
     - userId
1538 
    """
1539 
    self.send_getUserCommunicationByUser(userId)
1540 
    return self.recv_getUserCommunicationByUser()
1541 
 
1542 
  def send_getUserCommunicationByUser(self, userId):
1543 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1544 
    args = getUserCommunicationByUser_args()
1545 
    args.userId = userId
1546 
    args.write(self._oprot)
1547 
    self._oprot.writeMessageEnd()
1548 
    self._oprot.trans.flush()
1549 
 
1550 
  def recv_getUserCommunicationByUser(self, ):
1551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1552 
    if mtype == TMessageType.EXCEPTION:
1553 
      x = TApplicationException()
1554 
      x.read(self._iprot)
1555 
      self._iprot.readMessageEnd()
1556 
      raise x
1557 
    result = getUserCommunicationByUser_result()
1558 
    result.read(self._iprot)
1559 
    self._iprot.readMessageEnd()
3431 rajveer 1560 
    if result.success is not None:
1590 varun.gupt 1561 
      return result.success
3431 rajveer 1562 
    if result.ucx is not None:
1590 varun.gupt 1563 
      raise result.ucx
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1565 
 
1566 
  def getAllUserCommunications(self, ):
1567 
    self.send_getAllUserCommunications()
1568 
    return self.recv_getAllUserCommunications()
1569 
 
1570 
  def send_getAllUserCommunications(self, ):
1571 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1572 
    args = getAllUserCommunications_args()
1573 
    args.write(self._oprot)
1574 
    self._oprot.writeMessageEnd()
1575 
    self._oprot.trans.flush()
1576 
 
1577 
  def recv_getAllUserCommunications(self, ):
1578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1579 
    if mtype == TMessageType.EXCEPTION:
1580 
      x = TApplicationException()
1581 
      x.read(self._iprot)
1582 
      self._iprot.readMessageEnd()
1583 
      raise x
1584 
    result = getAllUserCommunications_result()
1585 
    result.read(self._iprot)
1586 
    self._iprot.readMessageEnd()
3431 rajveer 1587 
    if result.success is not None:
1590 varun.gupt 1588 
      return result.success
3431 rajveer 1589 
    if result.ucx is not None:
1590 varun.gupt 1590 
      raise result.ucx
1591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1592 
 
5407 amar.kumar 1593 
  def removeUserCommunication(self, id):
1594 
    """
1595 
    Parameters:
1596 
     - id
1597 
    """
1598 
    self.send_removeUserCommunication(id)
1599 
    self.recv_removeUserCommunication()
1600 
 
1601 
  def send_removeUserCommunication(self, id):
1602 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1603 
    args = removeUserCommunication_args()
1604 
    args.id = id
1605 
    args.write(self._oprot)
1606 
    self._oprot.writeMessageEnd()
1607 
    self._oprot.trans.flush()
1608 
 
1609 
  def recv_removeUserCommunication(self, ):
1610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1611 
    if mtype == TMessageType.EXCEPTION:
1612 
      x = TApplicationException()
1613 
      x.read(self._iprot)
1614 
      self._iprot.readMessageEnd()
1615 
      raise x
1616 
    result = removeUserCommunication_result()
1617 
    result.read(self._iprot)
1618 
    self._iprot.readMessageEnd()
1619 
    if result.ucx is not None:
1620 
      raise result.ucx
1621 
    return
1622 
 
1859 vikas 1623 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1624 
    """
1625 
    Parameters:
1626 
     - name
1859 vikas 1627 
     - addedOn
1845 vikas 1628 
    """
1859 vikas 1629 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1630 
    return self.recv_createMasterAffiliate()
1631 
 
1859 vikas 1632 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1633 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1634 
    args = createMasterAffiliate_args()
1635 
    args.name = name
1859 vikas 1636 
    args.addedOn = addedOn
1845 vikas 1637 
    args.write(self._oprot)
1638 
    self._oprot.writeMessageEnd()
1639 
    self._oprot.trans.flush()
1640 
 
1641 
  def recv_createMasterAffiliate(self, ):
1642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1643 
    if mtype == TMessageType.EXCEPTION:
1644 
      x = TApplicationException()
1645 
      x.read(self._iprot)
1646 
      self._iprot.readMessageEnd()
1647 
      raise x
1648 
    result = createMasterAffiliate_result()
1649 
    result.read(self._iprot)
1650 
    self._iprot.readMessageEnd()
3431 rajveer 1651 
    if result.success is not None:
1845 vikas 1652 
      return result.success
3431 rajveer 1653 
    if result.utx is not None:
1845 vikas 1654 
      raise result.utx
1655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1656 
 
1899 vikas 1657 
  def getAllMasterAffiliates(self, ):
1658 
    self.send_getAllMasterAffiliates()
1659 
    return self.recv_getAllMasterAffiliates()
1660 
 
1661 
  def send_getAllMasterAffiliates(self, ):
1662 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1663 
    args = getAllMasterAffiliates_args()
1664 
    args.write(self._oprot)
1665 
    self._oprot.writeMessageEnd()
1666 
    self._oprot.trans.flush()
1667 
 
1668 
  def recv_getAllMasterAffiliates(self, ):
1669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1670 
    if mtype == TMessageType.EXCEPTION:
1671 
      x = TApplicationException()
1672 
      x.read(self._iprot)
1673 
      self._iprot.readMessageEnd()
1674 
      raise x
1675 
    result = getAllMasterAffiliates_result()
1676 
    result.read(self._iprot)
1677 
    self._iprot.readMessageEnd()
3431 rajveer 1678 
    if result.success is not None:
1899 vikas 1679 
      return result.success
3431 rajveer 1680 
    if result.utx is not None:
1899 vikas 1681 
      raise result.utx
1682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1683 
 
1845 vikas 1684 
  def getMasterAffiliateById(self, id):
1685 
    """
1686 
    Parameters:
1687 
     - id
1688 
    """
1689 
    self.send_getMasterAffiliateById(id)
1690 
    return self.recv_getMasterAffiliateById()
1691 
 
1692 
  def send_getMasterAffiliateById(self, id):
1693 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1694 
    args = getMasterAffiliateById_args()
1695 
    args.id = id
1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
1700 
  def recv_getMasterAffiliateById(self, ):
1701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1702 
    if mtype == TMessageType.EXCEPTION:
1703 
      x = TApplicationException()
1704 
      x.read(self._iprot)
1705 
      self._iprot.readMessageEnd()
1706 
      raise x
1707 
    result = getMasterAffiliateById_result()
1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
3431 rajveer 1710 
    if result.success is not None:
1845 vikas 1711 
      return result.success
3431 rajveer 1712 
    if result.utx is not None:
1845 vikas 1713 
      raise result.utx
1714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1715 
 
1716 
  def getMasterAffiliateByName(self, name):
1717 
    """
1718 
    Parameters:
1719 
     - name
1720 
    """
1721 
    self.send_getMasterAffiliateByName(name)
1722 
    return self.recv_getMasterAffiliateByName()
1723 
 
1724 
  def send_getMasterAffiliateByName(self, name):
1725 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1726 
    args = getMasterAffiliateByName_args()
1727 
    args.name = name
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getMasterAffiliateByName(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getMasterAffiliateByName_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
3431 rajveer 1742 
    if result.success is not None:
1845 vikas 1743 
      return result.success
3431 rajveer 1744 
    if result.utx is not None:
1845 vikas 1745 
      raise result.utx
1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1747 
 
1859 vikas 1748 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1749 
    """
1750 
    Parameters:
1751 
     - name
1752 
     - url
1753 
     - masterAffiliateId
1859 vikas 1754 
     - addedOn
1845 vikas 1755 
    """
1859 vikas 1756 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1757 
    return self.recv_createAffiliate()
1758 
 
1859 vikas 1759 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1760 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1761 
    args = createAffiliate_args()
1762 
    args.name = name
1763 
    args.url = url
1764 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1765 
    args.addedOn = addedOn
1845 vikas 1766 
    args.write(self._oprot)
1767 
    self._oprot.writeMessageEnd()
1768 
    self._oprot.trans.flush()
1769 
 
1770 
  def recv_createAffiliate(self, ):
1771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1772 
    if mtype == TMessageType.EXCEPTION:
1773 
      x = TApplicationException()
1774 
      x.read(self._iprot)
1775 
      self._iprot.readMessageEnd()
1776 
      raise x
1777 
    result = createAffiliate_result()
1778 
    result.read(self._iprot)
1779 
    self._iprot.readMessageEnd()
3431 rajveer 1780 
    if result.success is not None:
1845 vikas 1781 
      return result.success
3431 rajveer 1782 
    if result.utx is not None:
1845 vikas 1783 
      raise result.utx
1784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1785 
 
1786 
  def getAffiliateById(self, id):
1787 
    """
1788 
    Parameters:
1789 
     - id
1790 
    """
1791 
    self.send_getAffiliateById(id)
1792 
    return self.recv_getAffiliateById()
1793 
 
1794 
  def send_getAffiliateById(self, id):
1795 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1796 
    args = getAffiliateById_args()
1797 
    args.id = id
1798 
    args.write(self._oprot)
1799 
    self._oprot.writeMessageEnd()
1800 
    self._oprot.trans.flush()
1801 
 
1802 
  def recv_getAffiliateById(self, ):
1803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1804 
    if mtype == TMessageType.EXCEPTION:
1805 
      x = TApplicationException()
1806 
      x.read(self._iprot)
1807 
      self._iprot.readMessageEnd()
1808 
      raise x
1809 
    result = getAffiliateById_result()
1810 
    result.read(self._iprot)
1811 
    self._iprot.readMessageEnd()
3431 rajveer 1812 
    if result.success is not None:
1845 vikas 1813 
      return result.success
3431 rajveer 1814 
    if result.utx is not None:
1845 vikas 1815 
      raise result.utx
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1817 
 
1818 
  def getAffiliateByName(self, name):
1819 
    """
1820 
    Parameters:
1821 
     - name
1822 
    """
1823 
    self.send_getAffiliateByName(name)
1824 
    return self.recv_getAffiliateByName()
1825 
 
1826 
  def send_getAffiliateByName(self, name):
1827 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1828 
    args = getAffiliateByName_args()
1829 
    args.name = name
1830 
    args.write(self._oprot)
1831 
    self._oprot.writeMessageEnd()
1832 
    self._oprot.trans.flush()
1833 
 
1834 
  def recv_getAffiliateByName(self, ):
1835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1836 
    if mtype == TMessageType.EXCEPTION:
1837 
      x = TApplicationException()
1838 
      x.read(self._iprot)
1839 
      self._iprot.readMessageEnd()
1840 
      raise x
1841 
    result = getAffiliateByName_result()
1842 
    result.read(self._iprot)
1843 
    self._iprot.readMessageEnd()
3431 rajveer 1844 
    if result.success is not None:
1845 vikas 1845 
      return result.success
3431 rajveer 1846 
    if result.utx is not None:
1845 vikas 1847 
      raise result.utx
1848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1849 
 
1996 vikas 1850 
  def getTrackerById(self, id):
1845 vikas 1851 
    """
1852 
    Parameters:
1853 
     - id
1854 
    """
1996 vikas 1855 
    self.send_getTrackerById(id)
1845 vikas 1856 
    return self.recv_getTrackerById()
1857 
 
1996 vikas 1858 
  def send_getTrackerById(self, id):
1845 vikas 1859 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1860 
    args = getTrackerById_args()
1996 vikas 1861 
    args.id = id
1845 vikas 1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_getTrackerById(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = getTrackerById_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
3431 rajveer 1876 
    if result.success is not None:
1845 vikas 1877 
      return result.success
3431 rajveer 1878 
    if result.utx is not None:
1845 vikas 1879 
      raise result.utx
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1881 
 
1996 vikas 1882 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1883 
    """
1884 
    Parameters:
1996 vikas 1885 
     - id
1845 vikas 1886 
    """
1996 vikas 1887 
    self.send_getAffiliatesByMasterAffiliate(id)
1888 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1889 
 
1996 vikas 1890 
  def send_getAffiliatesByMasterAffiliate(self, id):
1891 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1892 
    args = getAffiliatesByMasterAffiliate_args()
1893 
    args.id = id
1845 vikas 1894 
    args.write(self._oprot)
1895 
    self._oprot.writeMessageEnd()
1896 
    self._oprot.trans.flush()
1897 
 
1996 vikas 1898 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1900 
    if mtype == TMessageType.EXCEPTION:
1901 
      x = TApplicationException()
1902 
      x.read(self._iprot)
1903 
      self._iprot.readMessageEnd()
1904 
      raise x
1996 vikas 1905 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1906 
    result.read(self._iprot)
1907 
    self._iprot.readMessageEnd()
3431 rajveer 1908 
    if result.success is not None:
1845 vikas 1909 
      return result.success
3431 rajveer 1910 
    if result.utx is not None:
1845 vikas 1911 
      raise result.utx
1996 vikas 1912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1913 
 
1996 vikas 1914 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1915 
    """
1916 
    Parameters:
1996 vikas 1917 
     - affiliateId
1845 vikas 1918 
     - userId
1919 
     - event
1920 
     - url
1921 
     - data
1859 vikas 1922 
     - addedOn
1845 vikas 1923 
    """
1996 vikas 1924 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1925 
    return self.recv_addTrackLog()
1926 
 
1996 vikas 1927 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1928 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1929 
    args = addTrackLog_args()
1996 vikas 1930 
    args.affiliateId = affiliateId
1845 vikas 1931 
    args.userId = userId
1932 
    args.event = event
1933 
    args.url = url
1934 
    args.data = data
1859 vikas 1935 
    args.addedOn = addedOn
1845 vikas 1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
1940 
  def recv_addTrackLog(self, ):
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
1947 
    result = addTrackLog_result()
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
1954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1955 
 
1956 
  def getTrackLogById(self, id):
1957 
    """
1958 
    Parameters:
1959 
     - id
1960 
    """
1961 
    self.send_getTrackLogById(id)
1962 
    return self.recv_getTrackLogById()
1963 
 
1964 
  def send_getTrackLogById(self, id):
1965 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1966 
    args = getTrackLogById_args()
1967 
    args.id = id
1968 
    args.write(self._oprot)
1969 
    self._oprot.writeMessageEnd()
1970 
    self._oprot.trans.flush()
1971 
 
1972 
  def recv_getTrackLogById(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 = getTrackLogById_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, "getTrackLogById failed: unknown result");
1987 
 
3293 vikas 1988 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1989 
    """
1990 
    Parameters:
1996 vikas 1991 
     - affiliateId
3293 vikas 1992 
     - startDate
1993 
     - endDate
1845 vikas 1994 
    """
3293 vikas 1995 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1996 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1997 
 
3293 vikas 1998 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1999 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2000 
    args = getTrackLogsByAffiliate_args()
2001 
    args.affiliateId = affiliateId
3293 vikas 2002 
    args.startDate = startDate
2003 
    args.endDate = endDate
1845 vikas 2004 
    args.write(self._oprot)
2005 
    self._oprot.writeMessageEnd()
2006 
    self._oprot.trans.flush()
2007 
 
1996 vikas 2008 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 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
1996 vikas 2015 
    result = getTrackLogsByAffiliate_result()
1845 vikas 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
1996 vikas 2022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2023 
 
2024 
  def getTrackLogsByUser(self, userId):
2025 
    """
2026 
    Parameters:
2027 
     - userId
2028 
    """
2029 
    self.send_getTrackLogsByUser(userId)
2030 
    return self.recv_getTrackLogsByUser()
2031 
 
2032 
  def send_getTrackLogsByUser(self, userId):
2033 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2034 
    args = getTrackLogsByUser_args()
2035 
    args.userId = userId
2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
2040 
  def recv_getTrackLogsByUser(self, ):
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
2047 
    result = getTrackLogsByUser_result()
2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.success is not None:
1845 vikas 2051 
      return result.success
3431 rajveer 2052 
    if result.utx is not None:
1845 vikas 2053 
      raise result.utx
2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2055 
 
1996 vikas 2056 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2057 
    """
2058 
    Parameters:
2059 
     - userId
2060 
     - event
2061 
     - url
2062 
    """
1996 vikas 2063 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2064 
    return self.recv_getTrackLogs()
2065 
 
1996 vikas 2066 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2067 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2068 
    args = getTrackLogs_args()
2069 
    args.userId = userId
2070 
    args.event = event
2071 
    args.url = url
2072 
    args.write(self._oprot)
2073 
    self._oprot.writeMessageEnd()
2074 
    self._oprot.trans.flush()
2075 
 
2076 
  def recv_getTrackLogs(self, ):
2077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2078 
    if mtype == TMessageType.EXCEPTION:
2079 
      x = TApplicationException()
2080 
      x.read(self._iprot)
2081 
      self._iprot.readMessageEnd()
2082 
      raise x
2083 
    result = getTrackLogs_result()
2084 
    result.read(self._iprot)
2085 
    self._iprot.readMessageEnd()
3431 rajveer 2086 
    if result.success is not None:
1845 vikas 2087 
      return result.success
3431 rajveer 2088 
    if result.utx is not None:
1845 vikas 2089 
      raise result.utx
2090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2091 
 
559 chandransh 2092 
  def getCurrentCart(self, userId):
94 ashish 2093 
    """
2094 
    Parameters:
559 chandransh 2095 
     - userId
94 ashish 2096 
    """
559 chandransh 2097 
    self.send_getCurrentCart(userId)
2098 
    return self.recv_getCurrentCart()
94 ashish 2099 
 
559 chandransh 2100 
  def send_getCurrentCart(self, userId):
2101 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2102 
    args = getCurrentCart_args()
2103 
    args.userId = userId
94 ashish 2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
559 chandransh 2108 
  def recv_getCurrentCart(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 = getCurrentCart_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, "getCurrentCart failed: unknown result");
94 ashish 2123 
 
559 chandransh 2124 
  def getCart(self, cartId):
94 ashish 2125 
    """
2126 
    Parameters:
559 chandransh 2127 
     - cartId
94 ashish 2128 
    """
559 chandransh 2129 
    self.send_getCart(cartId)
2130 
    return self.recv_getCart()
94 ashish 2131 
 
559 chandransh 2132 
  def send_getCart(self, cartId):
2133 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2134 
    args = getCart_args()
2135 
    args.cartId = cartId
94 ashish 2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
559 chandransh 2140 
  def recv_getCart(self, ):
94 ashish 2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
559 chandransh 2147 
    result = getCart_result()
94 ashish 2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
3431 rajveer 2150 
    if result.success is not None:
94 ashish 2151 
      return result.success
3431 rajveer 2152 
    if result.scx is not None:
559 chandransh 2153 
      raise result.scx
2154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2155 
 
559 chandransh 2156 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2157 
    """
2158 
    Parameters:
559 chandransh 2159 
     - from_time
2160 
     - to_time
2161 
     - status
94 ashish 2162 
    """
559 chandransh 2163 
    self.send_getCartsByTime(from_time, to_time, status)
2164 
    return self.recv_getCartsByTime()
94 ashish 2165 
 
559 chandransh 2166 
  def send_getCartsByTime(self, from_time, to_time, status):
2167 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2168 
    args = getCartsByTime_args()
2169 
    args.from_time = from_time
2170 
    args.to_time = to_time
2171 
    args.status = status
94 ashish 2172 
    args.write(self._oprot)
2173 
    self._oprot.writeMessageEnd()
2174 
    self._oprot.trans.flush()
2175 
 
559 chandransh 2176 
  def recv_getCartsByTime(self, ):
94 ashish 2177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2178 
    if mtype == TMessageType.EXCEPTION:
2179 
      x = TApplicationException()
2180 
      x.read(self._iprot)
2181 
      self._iprot.readMessageEnd()
2182 
      raise x
559 chandransh 2183 
    result = getCartsByTime_result()
94 ashish 2184 
    result.read(self._iprot)
2185 
    self._iprot.readMessageEnd()
3431 rajveer 2186 
    if result.success is not None:
94 ashish 2187 
      return result.success
3431 rajveer 2188 
    if result.scx is not None:
559 chandransh 2189 
      raise result.scx
2190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2191 
 
3557 rajveer 2192 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2193 
    """
2194 
    Parameters:
2195 
     - cartId
2196 
     - itemId
2197 
     - quantity
3557 rajveer 2198 
     - sourceId
559 chandransh 2199 
    """
3557 rajveer 2200 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2201 
    return self.recv_addItemToCart()
559 chandransh 2202 
 
3557 rajveer 2203 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2204 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2205 
    args = addItemToCart_args()
2206 
    args.cartId = cartId
2207 
    args.itemId = itemId
2208 
    args.quantity = quantity
3557 rajveer 2209 
    args.sourceId = sourceId
559 chandransh 2210 
    args.write(self._oprot)
2211 
    self._oprot.writeMessageEnd()
2212 
    self._oprot.trans.flush()
2213 
 
2214 
  def recv_addItemToCart(self, ):
2215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2216 
    if mtype == TMessageType.EXCEPTION:
2217 
      x = TApplicationException()
2218 
      x.read(self._iprot)
2219 
      self._iprot.readMessageEnd()
2220 
      raise x
2221 
    result = addItemToCart_result()
2222 
    result.read(self._iprot)
2223 
    self._iprot.readMessageEnd()
3431 rajveer 2224 
    if result.success is not None:
2035 rajveer 2225 
      return result.success
3431 rajveer 2226 
    if result.scx is not None:
559 chandransh 2227 
      raise result.scx
2035 rajveer 2228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2229 
 
2230 
  def deleteItemFromCart(self, cartId, itemId):
2231 
    """
2232 
    Parameters:
2233 
     - cartId
2234 
     - itemId
2235 
    """
2236 
    self.send_deleteItemFromCart(cartId, itemId)
2237 
    self.recv_deleteItemFromCart()
2238 
 
2239 
  def send_deleteItemFromCart(self, cartId, itemId):
2240 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2241 
    args = deleteItemFromCart_args()
2242 
    args.cartId = cartId
2243 
    args.itemId = itemId
2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
2248 
  def recv_deleteItemFromCart(self, ):
2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
2255 
    result = deleteItemFromCart_result()
2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
3431 rajveer 2258 
    if result.scx is not None:
559 chandransh 2259 
      raise result.scx
2260 
    return
2261 
 
2262 
  def addAddressToCart(self, cartId, addressId):
2263 
    """
2264 
    Parameters:
2265 
     - cartId
2266 
     - addressId
2267 
    """
2268 
    self.send_addAddressToCart(cartId, addressId)
2269 
    self.recv_addAddressToCart()
2270 
 
2271 
  def send_addAddressToCart(self, cartId, addressId):
2272 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2273 
    args = addAddressToCart_args()
2274 
    args.cartId = cartId
2275 
    args.addressId = addressId
2276 
    args.write(self._oprot)
2277 
    self._oprot.writeMessageEnd()
2278 
    self._oprot.trans.flush()
2279 
 
2280 
  def recv_addAddressToCart(self, ):
2281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2282 
    if mtype == TMessageType.EXCEPTION:
2283 
      x = TApplicationException()
2284 
      x.read(self._iprot)
2285 
      self._iprot.readMessageEnd()
2286 
      raise x
2287 
    result = addAddressToCart_result()
2288 
    result.read(self._iprot)
2289 
    self._iprot.readMessageEnd()
3431 rajveer 2290 
    if result.scx is not None:
575 chandransh 2291 
      raise result.scx
559 chandransh 2292 
    return
2293 
 
5553 rajveer 2294 
  def addStoreToCart(self, cartId, storeId):
2295 
    """
2296 
    Parameters:
2297 
     - cartId
2298 
     - storeId
2299 
    """
2300 
    self.send_addStoreToCart(cartId, storeId)
2301 
    self.recv_addStoreToCart()
2302 
 
2303 
  def send_addStoreToCart(self, cartId, storeId):
2304 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2305 
    args = addStoreToCart_args()
2306 
    args.cartId = cartId
2307 
    args.storeId = storeId
2308 
    args.write(self._oprot)
2309 
    self._oprot.writeMessageEnd()
2310 
    self._oprot.trans.flush()
2311 
 
2312 
  def recv_addStoreToCart(self, ):
2313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2314 
    if mtype == TMessageType.EXCEPTION:
2315 
      x = TApplicationException()
2316 
      x.read(self._iprot)
2317 
      self._iprot.readMessageEnd()
2318 
      raise x
2319 
    result = addStoreToCart_result()
2320 
    result.read(self._iprot)
2321 
    self._iprot.readMessageEnd()
2322 
    if result.scx is not None:
2323 
      raise result.scx
2324 
    return
2325 
 
6922 anupam.sin 2326 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2327 
    """
2328 
    Parameters:
6922 anupam.sin 2329 
     - cart
1976 varun.gupt 2330 
     - couponCode
2331 
    """
6922 anupam.sin 2332 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2333 
    self.recv_applyCouponToCart()
2334 
 
6922 anupam.sin 2335 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2336 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2337 
    args = applyCouponToCart_args()
6922 anupam.sin 2338 
    args.cart = cart
1976 varun.gupt 2339 
    args.couponCode = couponCode
2340 
    args.write(self._oprot)
2341 
    self._oprot.writeMessageEnd()
2342 
    self._oprot.trans.flush()
2343 
 
2344 
  def recv_applyCouponToCart(self, ):
2345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2346 
    if mtype == TMessageType.EXCEPTION:
2347 
      x = TApplicationException()
2348 
      x.read(self._iprot)
2349 
      self._iprot.readMessageEnd()
2350 
      raise x
2351 
    result = applyCouponToCart_result()
2352 
    result.read(self._iprot)
2353 
    self._iprot.readMessageEnd()
3431 rajveer 2354 
    if result.scx is not None:
1976 varun.gupt 2355 
      raise result.scx
2356 
    return
2357 
 
2358 
  def removeCoupon(self, cartId):
2359 
    """
2360 
    Parameters:
2361 
     - cartId
2362 
    """
2363 
    self.send_removeCoupon(cartId)
2364 
    self.recv_removeCoupon()
2365 
 
2366 
  def send_removeCoupon(self, cartId):
2367 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2368 
    args = removeCoupon_args()
2369 
    args.cartId = cartId
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_removeCoupon(self, ):
2375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2376 
    if mtype == TMessageType.EXCEPTION:
2377 
      x = TApplicationException()
2378 
      x.read(self._iprot)
2379 
      self._iprot.readMessageEnd()
2380 
      raise x
2381 
    result = removeCoupon_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
3431 rajveer 2384 
    if result.scx is not None:
1976 varun.gupt 2385 
      raise result.scx
2386 
    return
2387 
 
3554 varun.gupt 2388 
  def deleteDiscountsFromCart(self, cartId):
2389 
    """
2390 
    Deletes all the discounts associated with the cart
2391 
 
2392 
    Parameters:
2393 
     - cartId
2394 
    """
2395 
    self.send_deleteDiscountsFromCart(cartId)
2396 
    self.recv_deleteDiscountsFromCart()
2397 
 
2398 
  def send_deleteDiscountsFromCart(self, cartId):
2399 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2400 
    args = deleteDiscountsFromCart_args()
2401 
    args.cartId = cartId
2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
2406 
  def recv_deleteDiscountsFromCart(self, ):
2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
2413 
    result = deleteDiscountsFromCart_result()
2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
2416 
    if result.scx is not None:
2417 
      raise result.scx
2418 
    return
2419 
 
2420 
  def saveDiscounts(self, discounts):
2421 
    """
2422 
    Accepts a list of thrift objects of Discount type and saves them
2423 
 
2424 
    Parameters:
2425 
     - discounts
2426 
    """
2427 
    self.send_saveDiscounts(discounts)
2428 
    self.recv_saveDiscounts()
2429 
 
2430 
  def send_saveDiscounts(self, discounts):
2431 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2432 
    args = saveDiscounts_args()
2433 
    args.discounts = discounts
2434 
    args.write(self._oprot)
2435 
    self._oprot.writeMessageEnd()
2436 
    self._oprot.trans.flush()
2437 
 
2438 
  def recv_saveDiscounts(self, ):
2439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2440 
    if mtype == TMessageType.EXCEPTION:
2441 
      x = TApplicationException()
2442 
      x.read(self._iprot)
2443 
      self._iprot.readMessageEnd()
2444 
      raise x
2445 
    result = saveDiscounts_result()
2446 
    result.read(self._iprot)
2447 
    self._iprot.readMessageEnd()
2448 
    if result.scx is not None:
2449 
      raise result.scx
2450 
    return
2451 
 
11526 amit.gupta 2452 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2453 
    """
690 chandransh 2454 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2455 
 
559 chandransh 2456 
    Parameters:
2457 
     - cartId
2815 vikas 2458 
     - sessionSource
2459 
     - sessionStartTime
3858 vikas 2460 
     - firstSource
2461 
     - firstSourceTime
5326 rajveer 2462 
     - userId
6389 rajveer 2463 
     - schemeId
11526 amit.gupta 2464 
     - orderSource
559 chandransh 2465 
    """
11526 amit.gupta 2466 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2467 
    return self.recv_createOrders()
559 chandransh 2468 
 
11526 amit.gupta 2469 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2470 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2471 
    args = createOrders_args()
559 chandransh 2472 
    args.cartId = cartId
2815 vikas 2473 
    args.sessionSource = sessionSource
2474 
    args.sessionStartTime = sessionStartTime
3858 vikas 2475 
    args.firstSource = firstSource
2476 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2477 
    args.userId = userId
6389 rajveer 2478 
    args.schemeId = schemeId
11526 amit.gupta 2479 
    args.orderSource = orderSource
559 chandransh 2480 
    args.write(self._oprot)
2481 
    self._oprot.writeMessageEnd()
2482 
    self._oprot.trans.flush()
2483 
 
690 chandransh 2484 
  def recv_createOrders(self, ):
559 chandransh 2485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2486 
    if mtype == TMessageType.EXCEPTION:
2487 
      x = TApplicationException()
2488 
      x.read(self._iprot)
2489 
      self._iprot.readMessageEnd()
2490 
      raise x
690 chandransh 2491 
    result = createOrders_result()
559 chandransh 2492 
    result.read(self._iprot)
2493 
    self._iprot.readMessageEnd()
3431 rajveer 2494 
    if result.success is not None:
130 ashish 2495 
      return result.success
3431 rajveer 2496 
    if result.scx is not None:
559 chandransh 2497 
      raise result.scx
690 chandransh 2498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2499 
 
3557 rajveer 2500 
  def validateCart(self, cartId, sourceId):
130 ashish 2501 
    """
690 chandransh 2502 
    Validates that:
2503 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2504 
    2. All of the lines in the cart are active items.
690 chandransh 2505 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2506 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2507 
 
130 ashish 2508 
    Parameters:
559 chandransh 2509 
     - cartId
3557 rajveer 2510 
     - sourceId
130 ashish 2511 
    """
3557 rajveer 2512 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2513 
    return self.recv_validateCart()
130 ashish 2514 
 
3557 rajveer 2515 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2516 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2517 
    args = validateCart_args()
2518 
    args.cartId = cartId
3557 rajveer 2519 
    args.sourceId = sourceId
130 ashish 2520 
    args.write(self._oprot)
2521 
    self._oprot.writeMessageEnd()
2522 
    self._oprot.trans.flush()
2523 
 
559 chandransh 2524 
  def recv_validateCart(self, ):
130 ashish 2525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2526 
    if mtype == TMessageType.EXCEPTION:
2527 
      x = TApplicationException()
2528 
      x.read(self._iprot)
2529 
      self._iprot.readMessageEnd()
2530 
      raise x
559 chandransh 2531 
    result = validateCart_result()
130 ashish 2532 
    result.read(self._iprot)
2533 
    self._iprot.readMessageEnd()
3431 rajveer 2534 
    if result.success is not None:
130 ashish 2535 
      return result.success
3431 rajveer 2536 
    if result.scex is not None:
575 chandransh 2537 
      raise result.scex
559 chandransh 2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2539 
 
11980 amit.gupta 2540 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2541 
    """
2542 
    Validates that:
2543 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2544 
    2. All of the lines in the cart are active items.
2545 
    3. The estimate for any of the lines in cart doesn't change.
2546 
    If all three are true, returns empty string; else returns appropriate message.
2547 
 
2548 
    Parameters:
2549 
     - cartId
2550 
     - sourceId
2551 
     - dealCoupon
2552 
    """
2553 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2554 
    return self.recv_validateCartWithDealerCoupon()
2555 
 
2556 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2557 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2558 
    args = validateCartWithDealerCoupon_args()
2559 
    args.cartId = cartId
2560 
    args.sourceId = sourceId
2561 
    args.dealCoupon = dealCoupon
2562 
    args.write(self._oprot)
2563 
    self._oprot.writeMessageEnd()
2564 
    self._oprot.trans.flush()
2565 
 
2566 
  def recv_validateCartWithDealerCoupon(self, ):
2567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2568 
    if mtype == TMessageType.EXCEPTION:
2569 
      x = TApplicationException()
2570 
      x.read(self._iprot)
2571 
      self._iprot.readMessageEnd()
2572 
      raise x
2573 
    result = validateCartWithDealerCoupon_result()
2574 
    result.read(self._iprot)
2575 
    self._iprot.readMessageEnd()
2576 
    if result.success is not None:
2577 
      return result.success
2578 
    if result.scex is not None:
2579 
      raise result.scex
2580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2581 
 
690 chandransh 2582 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2583 
    """
690 chandransh 2584 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2585 
 
575 chandransh 2586 
    Parameters:
690 chandransh 2587 
     - fromCartId
2588 
     - toCartId
2589 
    """
2590 
    self.send_mergeCart(fromCartId, toCartId)
2591 
    self.recv_mergeCart()
2592 
 
2593 
  def send_mergeCart(self, fromCartId, toCartId):
2594 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2595 
    args = mergeCart_args()
2596 
    args.fromCartId = fromCartId
2597 
    args.toCartId = toCartId
2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
2602 
  def recv_mergeCart(self, ):
2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
2609 
    result = mergeCart_result()
2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
2612 
    return
2613 
 
2614 
  def checkOut(self, cartId):
2615 
    """
2616 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2617 
 
690 chandransh 2618 
    Parameters:
575 chandransh 2619 
     - cartId
2620 
    """
690 chandransh 2621 
    self.send_checkOut(cartId)
2622 
    return self.recv_checkOut()
575 chandransh 2623 
 
690 chandransh 2624 
  def send_checkOut(self, cartId):
2625 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2626 
    args = checkOut_args()
575 chandransh 2627 
    args.cartId = cartId
2628 
    args.write(self._oprot)
2629 
    self._oprot.writeMessageEnd()
2630 
    self._oprot.trans.flush()
2631 
 
690 chandransh 2632 
  def recv_checkOut(self, ):
575 chandransh 2633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2634 
    if mtype == TMessageType.EXCEPTION:
2635 
      x = TApplicationException()
2636 
      x.read(self._iprot)
2637 
      self._iprot.readMessageEnd()
2638 
      raise x
690 chandransh 2639 
    result = checkOut_result()
575 chandransh 2640 
    result.read(self._iprot)
2641 
    self._iprot.readMessageEnd()
3431 rajveer 2642 
    if result.success is not None:
575 chandransh 2643 
      return result.success
3431 rajveer 2644 
    if result.scex is not None:
575 chandransh 2645 
      raise result.scex
690 chandransh 2646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2647 
 
690 chandransh 2648 
  def resetCart(self, cartId, items):
559 chandransh 2649 
    """
690 chandransh 2650 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2651 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2652 
 
559 chandransh 2653 
    Parameters:
690 chandransh 2654 
     - cartId
2655 
     - items
559 chandransh 2656 
    """
690 chandransh 2657 
    self.send_resetCart(cartId, items)
2658 
    return self.recv_resetCart()
130 ashish 2659 
 
690 chandransh 2660 
  def send_resetCart(self, cartId, items):
2661 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2662 
    args = resetCart_args()
2663 
    args.cartId = cartId
2664 
    args.items = items
559 chandransh 2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
690 chandransh 2669 
  def recv_resetCart(self, ):
559 chandransh 2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
690 chandransh 2676 
    result = resetCart_result()
559 chandransh 2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
3431 rajveer 2679 
    if result.success is not None:
690 chandransh 2680 
      return result.success
3431 rajveer 2681 
    if result.scex is not None:
690 chandransh 2682 
      raise result.scex
2683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2684 
 
2981 rajveer 2685 
  def getUserCount(self, userType):
559 chandransh 2686 
    """
2981 rajveer 2687 
    Returns number of registered users.
2688 
    If userType = null, then it returns count of all users, including anonymous
2689 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2690 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2691 
 
559 chandransh 2692 
    Parameters:
2981 rajveer 2693 
     - userType
559 chandransh 2694 
    """
2981 rajveer 2695 
    self.send_getUserCount(userType)
2696 
    return self.recv_getUserCount()
559 chandransh 2697 
 
2981 rajveer 2698 
  def send_getUserCount(self, userType):
2699 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2700 
    args = getUserCount_args()
2701 
    args.userType = userType
559 chandransh 2702 
    args.write(self._oprot)
2703 
    self._oprot.writeMessageEnd()
2704 
    self._oprot.trans.flush()
2705 
 
2981 rajveer 2706 
  def recv_getUserCount(self, ):
559 chandransh 2707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2708 
    if mtype == TMessageType.EXCEPTION:
2709 
      x = TApplicationException()
2710 
      x.read(self._iprot)
2711 
      self._iprot.readMessageEnd()
2712 
      raise x
2981 rajveer 2713 
    result = getUserCount_result()
559 chandransh 2714 
    result.read(self._iprot)
2715 
    self._iprot.readMessageEnd()
3431 rajveer 2716 
    if result.success is not None:
559 chandransh 2717 
      return result.success
2981 rajveer 2718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2719 
 
2981 rajveer 2720 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2721 
    """
2981 rajveer 2722 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2723 
    If any of startDate or endDate is -1, then that filter is ignored.
2724 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2725 
 
2726 
 
559 chandransh 2727 
    Parameters:
2981 rajveer 2728 
     - userType
2729 
     - startDate
2730 
     - endDate
559 chandransh 2731 
    """
2981 rajveer 2732 
    self.send_getAllUsers(userType, startDate, endDate)
2733 
    return self.recv_getAllUsers()
559 chandransh 2734 
 
2981 rajveer 2735 
  def send_getAllUsers(self, userType, startDate, endDate):
2736 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2737 
    args = getAllUsers_args()
2738 
    args.userType = userType
2739 
    args.startDate = startDate
2740 
    args.endDate = endDate
559 chandransh 2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
2981 rajveer 2745 
  def recv_getAllUsers(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 = getAllUsers_result()
559 chandransh 2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
3431 rajveer 2755 
    if result.success is not None:
559 chandransh 2756 
      return result.success
2981 rajveer 2757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2758 
 
2981 rajveer 2759 
  def getMyResearchItems(self, userId):
559 chandransh 2760 
    """
2981 rajveer 2761 
    Returns list of item ids in myresearch for the user
3431 rajveer 2762 
 
559 chandransh 2763 
    Parameters:
772 rajveer 2764 
     - userId
559 chandransh 2765 
    """
2981 rajveer 2766 
    self.send_getMyResearchItems(userId)
2767 
    return self.recv_getMyResearchItems()
559 chandransh 2768 
 
2981 rajveer 2769 
  def send_getMyResearchItems(self, userId):
2770 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2771 
    args = getMyResearchItems_args()
772 rajveer 2772 
    args.userId = userId
559 chandransh 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2981 rajveer 2777 
  def recv_getMyResearchItems(self, ):
559 chandransh 2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2981 rajveer 2784 
    result = getMyResearchItems_result()
559 chandransh 2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
3431 rajveer 2787 
    if result.success is not None:
559 chandransh 2788 
      return result.success
3431 rajveer 2789 
    if result.scx is not None:
559 chandransh 2790 
      raise result.scx
2981 rajveer 2791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2792 
 
2981 rajveer 2793 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2794 
    """
2981 rajveer 2795 
    add item to my research for a user
3431 rajveer 2796 
 
559 chandransh 2797 
    Parameters:
2981 rajveer 2798 
     - userId
2799 
     - itemId
559 chandransh 2800 
    """
2981 rajveer 2801 
    self.send_updateMyResearch(userId, itemId)
2802 
    return self.recv_updateMyResearch()
559 chandransh 2803 
 
2981 rajveer 2804 
  def send_updateMyResearch(self, userId, itemId):
2805 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2806 
    args = updateMyResearch_args()
2807 
    args.userId = userId
2808 
    args.itemId = itemId
559 chandransh 2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2981 rajveer 2813 
  def recv_updateMyResearch(self, ):
559 chandransh 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 = updateMyResearch_result()
559 chandransh 2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
3431 rajveer 2823 
    if result.success is not None:
2981 rajveer 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, "updateMyResearch failed: unknown result");
559 chandransh 2828 
 
2981 rajveer 2829 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2830 
    """
2981 rajveer 2831 
    delete item from my research for a user
3431 rajveer 2832 
 
1596 ankur.sing 2833 
    Parameters:
2981 rajveer 2834 
     - userId
2835 
     - itemId
1596 ankur.sing 2836 
    """
2981 rajveer 2837 
    self.send_deleteItemFromMyResearch(userId, itemId)
2838 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2839 
 
2981 rajveer 2840 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2841 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2842 
    args = deleteItemFromMyResearch_args()
2843 
    args.userId = userId
2844 
    args.itemId = itemId
1596 ankur.sing 2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2981 rajveer 2849 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 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 = deleteItemFromMyResearch_result()
1596 ankur.sing 2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
3431 rajveer 2859 
    if result.scx is not None:
2981 rajveer 2860 
      raise result.scx
2861 
    return
1596 ankur.sing 2862 
 
2981 rajveer 2863 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2864 
    """
2981 rajveer 2865 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2866 
 
1673 ankur.sing 2867 
    Parameters:
2981 rajveer 2868 
     - userId
1673 ankur.sing 2869 
    """
2981 rajveer 2870 
    self.send_getBrowseHistoryItems(userId)
2871 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2872 
 
2981 rajveer 2873 
  def send_getBrowseHistoryItems(self, userId):
2874 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2875 
    args = getBrowseHistoryItems_args()
2876 
    args.userId = userId
1673 ankur.sing 2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
2981 rajveer 2881 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
2981 rajveer 2888 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
3431 rajveer 2891 
    if result.success is not None:
1673 ankur.sing 2892 
      return result.success
3431 rajveer 2893 
    if result.scx is not None:
2981 rajveer 2894 
      raise result.scx
2895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2896 
 
2981 rajveer 2897 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2898 
    """
2981 rajveer 2899 
    add item to browse history for a user
3431 rajveer 2900 
 
2642 varun.gupt 2901 
    Parameters:
2981 rajveer 2902 
     - userId
2903 
     - itemId
2642 varun.gupt 2904 
    """
2981 rajveer 2905 
    self.send_updateBrowseHistory(userId, itemId)
2906 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2907 
 
2981 rajveer 2908 
  def send_updateBrowseHistory(self, userId, itemId):
2909 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2910 
    args = updateBrowseHistory_args()
2911 
    args.userId = userId
2912 
    args.itemId = itemId
2642 varun.gupt 2913 
    args.write(self._oprot)
2914 
    self._oprot.writeMessageEnd()
2915 
    self._oprot.trans.flush()
2916 
 
2981 rajveer 2917 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2919 
    if mtype == TMessageType.EXCEPTION:
2920 
      x = TApplicationException()
2921 
      x.read(self._iprot)
2922 
      self._iprot.readMessageEnd()
2923 
      raise x
2981 rajveer 2924 
    result = updateBrowseHistory_result()
2642 varun.gupt 2925 
    result.read(self._iprot)
2926 
    self._iprot.readMessageEnd()
2927 
    return
2928 
 
3385 varun.gupt 2929 
  def getCartsWithCouponCount(self, couponCode):
2930 
    """
2931 
    Returns count of Carts with given coupon applied
3431 rajveer 2932 
 
3385 varun.gupt 2933 
    Parameters:
2934 
     - couponCode
2935 
    """
2936 
    self.send_getCartsWithCouponCount(couponCode)
2937 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2938 
 
3385 varun.gupt 2939 
  def send_getCartsWithCouponCount(self, couponCode):
2940 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2941 
    args = getCartsWithCouponCount_args()
2942 
    args.couponCode = couponCode
2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
2947 
  def recv_getCartsWithCouponCount(self, ):
2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
2954 
    result = getCartsWithCouponCount_result()
2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
3431 rajveer 2957 
    if result.success is not None:
3385 varun.gupt 2958 
      return result.success
2959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2960 
 
3499 mandeep.dh 2961 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2962 
    """
2963 
    Updates COD trust level of a user
3385 varun.gupt 2964 
 
3499 mandeep.dh 2965 
    Parameters:
2966 
     - userId
2967 
     - trustLevelDelta
2968 
    """
2969 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2970 
 
2971 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2972 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2973 
    args = increaseTrustLevel_args()
2974 
    args.userId = userId
2975 
    args.trustLevelDelta = trustLevelDelta
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
5407 amar.kumar 2979 
  def getTrustLevel(self, userId):
2980 
    """
2981 
    Get trust level of a user
2982 
 
2983 
    Parameters:
2984 
     - userId
2985 
    """
2986 
    self.send_getTrustLevel(userId)
2987 
    return self.recv_getTrustLevel()
2988 
 
2989 
  def send_getTrustLevel(self, userId):
2990 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2991 
    args = getTrustLevel_args()
2992 
    args.userId = userId
2993 
    args.write(self._oprot)
2994 
    self._oprot.writeMessageEnd()
2995 
    self._oprot.trans.flush()
2996 
 
2997 
  def recv_getTrustLevel(self, ):
2998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2999 
    if mtype == TMessageType.EXCEPTION:
3000 
      x = TApplicationException()
3001 
      x.read(self._iprot)
3002 
      self._iprot.readMessageEnd()
3003 
      raise x
3004 
    result = getTrustLevel_result()
3005 
    result.read(self._iprot)
3006 
    self._iprot.readMessageEnd()
3007 
    if result.success is not None:
3008 
      return result.success
3009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3010 
 
4668 varun.gupt 3011 
  def showCODOption(self, cartId, sourceId, pincode):
3012 
    """
3013 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3014 
 
4668 varun.gupt 3015 
    Parameters:
3016 
     - cartId
3017 
     - sourceId
3018 
     - pincode
3019 
    """
3020 
    self.send_showCODOption(cartId, sourceId, pincode)
3021 
    return self.recv_showCODOption()
3022 
 
3023 
  def send_showCODOption(self, cartId, sourceId, pincode):
3024 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3025 
    args = showCODOption_args()
3026 
    args.cartId = cartId
3027 
    args.sourceId = sourceId
3028 
    args.pincode = pincode
3029 
    args.write(self._oprot)
3030 
    self._oprot.writeMessageEnd()
3031 
    self._oprot.trans.flush()
3032 
 
3033 
  def recv_showCODOption(self, ):
3034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3035 
    if mtype == TMessageType.EXCEPTION:
3036 
      x = TApplicationException()
3037 
      x.read(self._iprot)
3038 
      self._iprot.readMessageEnd()
3039 
      raise x
3040 
    result = showCODOption_result()
3041 
    result.read(self._iprot)
3042 
    self._iprot.readMessageEnd()
3043 
    if result.success is not None:
3044 
      return result.success
3045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3046 
 
5623 anupam.sin 3047 
  def getUserEmails(self, startDate, endDate):
3048 
    """
3049 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3050 
 
5623 anupam.sin 3051 
    Parameters:
3052 
     - startDate
3053 
     - endDate
3054 
    """
3055 
    self.send_getUserEmails(startDate, endDate)
3056 
    return self.recv_getUserEmails()
3057 
 
3058 
  def send_getUserEmails(self, startDate, endDate):
3059 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3060 
    args = getUserEmails_args()
3061 
    args.startDate = startDate
3062 
    args.endDate = endDate
3063 
    args.write(self._oprot)
3064 
    self._oprot.writeMessageEnd()
3065 
    self._oprot.trans.flush()
3066 
 
3067 
  def recv_getUserEmails(self, ):
3068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3069 
    if mtype == TMessageType.EXCEPTION:
3070 
      x = TApplicationException()
3071 
      x.read(self._iprot)
3072 
      self._iprot.readMessageEnd()
3073 
      raise x
3074 
    result = getUserEmails_result()
3075 
    result.read(self._iprot)
3076 
    self._iprot.readMessageEnd()
3077 
    if result.success is not None:
3078 
      return result.success
3079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3080 
 
9299 kshitij.so 3081 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3082 
    """
3083 
    Mark a cart lineitem as insured. Returns true/false.
3084 
 
3085 
    Parameters:
3086 
     - itemId
3087 
     - cartId
3088 
     - toInsure
9299 kshitij.so 3089 
     - insurerType
6903 anupam.sin 3090 
    """
9299 kshitij.so 3091 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3092 
    return self.recv_insureItem()
3093 
 
9299 kshitij.so 3094 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3095 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3096 
    args = insureItem_args()
3097 
    args.itemId = itemId
3098 
    args.cartId = cartId
3099 
    args.toInsure = toInsure
9299 kshitij.so 3100 
    args.insurerType = insurerType
6903 anupam.sin 3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_insureItem(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 = insureItem_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, "insureItem failed: unknown result");
3118 
 
3119 
  def cancelInsurance(self, cartId):
3120 
    """
3121 
    Cancel insurance for all items in the cart
3122 
 
3123 
    Parameters:
3124 
     - cartId
3125 
    """
3126 
    self.send_cancelInsurance(cartId)
3127 
    return self.recv_cancelInsurance()
3128 
 
3129 
  def send_cancelInsurance(self, cartId):
3130 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3131 
    args = cancelInsurance_args()
3132 
    args.cartId = cartId
3133 
    args.write(self._oprot)
3134 
    self._oprot.writeMessageEnd()
3135 
    self._oprot.trans.flush()
3136 
 
3137 
  def recv_cancelInsurance(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 = cancelInsurance_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, "cancelInsurance failed: unknown result");
3150 
 
3151 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3152 
    """
3153 
    Stores insurance specific details like date of birth and guardianName
3154 
 
3155 
    Parameters:
3156 
     - addressId
3157 
     - dob
3158 
     - guardianName
3159 
    """
3160 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3161 
    return self.recv_storeInsuranceSpecificDetails()
3162 
 
3163 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3164 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3165 
    args = storeInsuranceSpecificDetails_args()
3166 
    args.addressId = addressId
3167 
    args.dob = dob
3168 
    args.guardianName = guardianName
3169 
    args.write(self._oprot)
3170 
    self._oprot.writeMessageEnd()
3171 
    self._oprot.trans.flush()
3172 
 
3173 
  def recv_storeInsuranceSpecificDetails(self, ):
3174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3175 
    if mtype == TMessageType.EXCEPTION:
3176 
      x = TApplicationException()
3177 
      x.read(self._iprot)
3178 
      self._iprot.readMessageEnd()
3179 
      raise x
3180 
    result = storeInsuranceSpecificDetails_result()
3181 
    result.read(self._iprot)
3182 
    self._iprot.readMessageEnd()
3183 
    if result.success is not None:
3184 
      return result.success
3185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3186 
 
3187 
  def isInsuranceDetailPresent(self, addressId):
3188 
    """
3189 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3190 
 
3191 
    Parameters:
3192 
     - addressId
3193 
    """
3194 
    self.send_isInsuranceDetailPresent(addressId)
3195 
    return self.recv_isInsuranceDetailPresent()
3196 
 
3197 
  def send_isInsuranceDetailPresent(self, addressId):
3198 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3199 
    args = isInsuranceDetailPresent_args()
3200 
    args.addressId = addressId
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_isInsuranceDetailPresent(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = isInsuranceDetailPresent_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.success is not None:
3216 
      return result.success
3217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3218 
 
9791 rajveer 3219 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3220 
    """
9791 rajveer 3221 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3222 
 
6821 amar.kumar 3223 
    Parameters:
3224 
     - startDate
3225 
     - endDate
3226 
    """
9791 rajveer 3227 
    self.send_getProductsAddedToCart(startDate, endDate)
3228 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3229 
 
9791 rajveer 3230 
  def send_getProductsAddedToCart(self, startDate, endDate):
3231 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3232 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3233 
    args.startDate = startDate
3234 
    args.endDate = endDate
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
9791 rajveer 3239 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 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
9791 rajveer 3246 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
3249 
    if result.success is not None:
3250 
      return result.success
9791 rajveer 3251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3252 
 
11980 amit.gupta 3253 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3254 
    """
3255 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3256 
 
11592 amit.gupta 3257 
    Parameters:
3258 
     - cartId
3259 
     - sourceId
11980 amit.gupta 3260 
     - dealerCoupon
11592 amit.gupta 3261 
    """
11980 amit.gupta 3262 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3263 
    return self.recv_validateCartPlus()
3264 
 
11980 amit.gupta 3265 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3266 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3267 
    args = validateCartPlus_args()
3268 
    args.cartId = cartId
3269 
    args.sourceId = sourceId
11980 amit.gupta 3270 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
3275 
  def recv_validateCartPlus(self, ):
3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
3282 
    result = validateCartPlus_result()
3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3285 
    if result.success is not None:
3286 
      return result.success
3287 
    if result.scex is not None:
3288 
      raise result.scex
3289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3290 
 
11679 vikram.rag 3291 
  def isPrivateDealUser(self, userId):
3292 
    """
3293 
    Parameters:
3294 
     - userId
3295 
    """
3296 
    self.send_isPrivateDealUser(userId)
3297 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3298 
 
11679 vikram.rag 3299 
  def send_isPrivateDealUser(self, userId):
3300 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3301 
    args = isPrivateDealUser_args()
3302 
    args.userId = userId
3303 
    args.write(self._oprot)
3304 
    self._oprot.writeMessageEnd()
3305 
    self._oprot.trans.flush()
3306 
 
3307 
  def recv_isPrivateDealUser(self, ):
3308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3309 
    if mtype == TMessageType.EXCEPTION:
3310 
      x = TApplicationException()
3311 
      x.read(self._iprot)
3312 
      self._iprot.readMessageEnd()
3313 
      raise x
3314 
    result = isPrivateDealUser_result()
3315 
    result.read(self._iprot)
3316 
    self._iprot.readMessageEnd()
3317 
    if result.success is not None:
3318 
      return result.success
3319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3320 
 
11890 kshitij.so 3321 
  def addPrivateDealUser(self, userId):
3322 
    """
3323 
    Parameters:
3324 
     - userId
3325 
    """
3326 
    self.send_addPrivateDealUser(userId)
3327 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3328 
 
11890 kshitij.so 3329 
  def send_addPrivateDealUser(self, userId):
3330 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3331 
    args = addPrivateDealUser_args()
3332 
    args.userId = userId
3333 
    args.write(self._oprot)
3334 
    self._oprot.writeMessageEnd()
3335 
    self._oprot.trans.flush()
3336 
 
3337 
  def recv_addPrivateDealUser(self, ):
3338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3339 
    if mtype == TMessageType.EXCEPTION:
3340 
      x = TApplicationException()
3341 
      x.read(self._iprot)
3342 
      self._iprot.readMessageEnd()
3343 
      raise x
3344 
    result = addPrivateDealUser_result()
3345 
    result.read(self._iprot)
3346 
    self._iprot.readMessageEnd()
3347 
    if result.success is not None:
3348 
      return result.success
3349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3350 
 
3351 
  def changePrivateDealUserStatus(self, userId, isActive):
3352 
    """
3353 
    Parameters:
3354 
     - userId
3355 
     - isActive
3356 
    """
3357 
    self.send_changePrivateDealUserStatus(userId, isActive)
3358 
    return self.recv_changePrivateDealUserStatus()
3359 
 
3360 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3361 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3362 
    args = changePrivateDealUserStatus_args()
3363 
    args.userId = userId
3364 
    args.isActive = isActive
3365 
    args.write(self._oprot)
3366 
    self._oprot.writeMessageEnd()
3367 
    self._oprot.trans.flush()
3368 
 
3369 
  def recv_changePrivateDealUserStatus(self, ):
3370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3371 
    if mtype == TMessageType.EXCEPTION:
3372 
      x = TApplicationException()
3373 
      x.read(self._iprot)
3374 
      self._iprot.readMessageEnd()
3375 
      raise x
3376 
    result = changePrivateDealUserStatus_result()
3377 
    result.read(self._iprot)
3378 
    self._iprot.readMessageEnd()
3379 
    if result.success is not None:
3380 
      return result.success
3381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3382 
 
3383 
  def getPrivateDealUser(self, userId):
3384 
    """
3385 
    Parameters:
3386 
     - userId
3387 
    """
3388 
    self.send_getPrivateDealUser(userId)
3389 
    return self.recv_getPrivateDealUser()
3390 
 
3391 
  def send_getPrivateDealUser(self, userId):
3392 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3393 
    args = getPrivateDealUser_args()
3394 
    args.userId = userId
3395 
    args.write(self._oprot)
3396 
    self._oprot.writeMessageEnd()
3397 
    self._oprot.trans.flush()
3398 
 
3399 
  def recv_getPrivateDealUser(self, ):
3400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3401 
    if mtype == TMessageType.EXCEPTION:
3402 
      x = TApplicationException()
3403 
      x.read(self._iprot)
3404 
      self._iprot.readMessageEnd()
3405 
      raise x
3406 
    result = getPrivateDealUser_result()
3407 
    result.read(self._iprot)
3408 
    self._iprot.readMessageEnd()
3409 
    if result.success is not None:
3410 
      return result.success
3411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3412 
 
12696 amit.gupta 3413 
  def registerCounter(self, counter, userId):
3414 
    """
3415 
    Parameters:
3416 
     - counter
3417 
     - userId
3418 
    """
3419 
    self.send_registerCounter(counter, userId)
3420 
    return self.recv_registerCounter()
11890 kshitij.so 3421 
 
12696 amit.gupta 3422 
  def send_registerCounter(self, counter, userId):
3423 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3424 
    args = registerCounter_args()
3425 
    args.counter = counter
3426 
    args.userId = userId
3427 
    args.write(self._oprot)
3428 
    self._oprot.writeMessageEnd()
3429 
    self._oprot.trans.flush()
3430 
 
3431 
  def recv_registerCounter(self, ):
3432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3433 
    if mtype == TMessageType.EXCEPTION:
3434 
      x = TApplicationException()
3435 
      x.read(self._iprot)
3436 
      self._iprot.readMessageEnd()
3437 
      raise x
3438 
    result = registerCounter_result()
3439 
    result.read(self._iprot)
3440 
    self._iprot.readMessageEnd()
3441 
    if result.success is not None:
3442 
      return result.success
3443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3444 
 
12722 amit.gupta 3445 
  def searchCounter(self, type1, searchString):
3446 
    """
3447 
    Parameters:
3448 
     - type1
3449 
     - searchString
3450 
    """
3451 
    self.send_searchCounter(type1, searchString)
3452 
    return self.recv_searchCounter()
12696 amit.gupta 3453 
 
12722 amit.gupta 3454 
  def send_searchCounter(self, type1, searchString):
3455 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3456 
    args = searchCounter_args()
3457 
    args.type1 = type1
3458 
    args.searchString = searchString
3459 
    args.write(self._oprot)
3460 
    self._oprot.writeMessageEnd()
3461 
    self._oprot.trans.flush()
3462 
 
3463 
  def recv_searchCounter(self, ):
3464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3465 
    if mtype == TMessageType.EXCEPTION:
3466 
      x = TApplicationException()
3467 
      x.read(self._iprot)
3468 
      self._iprot.readMessageEnd()
3469 
      raise x
3470 
    result = searchCounter_result()
3471 
    result.read(self._iprot)
3472 
    self._iprot.readMessageEnd()
3473 
    if result.success is not None:
3474 
      return result.success
3475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3476 
 
3477 
  def getAllUsersByCounter(self, counterId):
3478 
    """
3479 
    Parameters:
3480 
     - counterId
3481 
    """
3482 
    self.send_getAllUsersByCounter(counterId)
3483 
    return self.recv_getAllUsersByCounter()
3484 
 
3485 
  def send_getAllUsersByCounter(self, counterId):
3486 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3487 
    args = getAllUsersByCounter_args()
3488 
    args.counterId = counterId
3489 
    args.write(self._oprot)
3490 
    self._oprot.writeMessageEnd()
3491 
    self._oprot.trans.flush()
3492 
 
3493 
  def recv_getAllUsersByCounter(self, ):
3494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3495 
    if mtype == TMessageType.EXCEPTION:
3496 
      x = TApplicationException()
3497 
      x.read(self._iprot)
3498 
      self._iprot.readMessageEnd()
3499 
      raise x
3500 
    result = getAllUsersByCounter_result()
3501 
    result.read(self._iprot)
3502 
    self._iprot.readMessageEnd()
3503 
    if result.success is not None:
3504 
      return result.success
3505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3506 
 
15251 manish.sha 3507 
  def getActiveAccessTokenForUser(self, userId, source):
3508 
    """
3509 
    Parameters:
3510 
     - userId
3511 
     - source
3512 
    """
3513 
    self.send_getActiveAccessTokenForUser(userId, source)
3514 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3515 
 
15251 manish.sha 3516 
  def send_getActiveAccessTokenForUser(self, userId, source):
3517 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3518 
    args = getActiveAccessTokenForUser_args()
3519 
    args.userId = userId
3520 
    args.source = source
3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
3525 
  def recv_getActiveAccessTokenForUser(self, ):
3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
3532 
    result = getActiveAccessTokenForUser_result()
3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3535 
    if result.success is not None:
3536 
      return result.success
3537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3538 
 
3539 
  def validateAccessToken(self, accessToken):
3540 
    """
3541 
    Parameters:
3542 
     - accessToken
3543 
    """
3544 
    self.send_validateAccessToken(accessToken)
3545 
    return self.recv_validateAccessToken()
3546 
 
3547 
  def send_validateAccessToken(self, accessToken):
3548 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3549 
    args = validateAccessToken_args()
3550 
    args.accessToken = accessToken
3551 
    args.write(self._oprot)
3552 
    self._oprot.writeMessageEnd()
3553 
    self._oprot.trans.flush()
3554 
 
3555 
  def recv_validateAccessToken(self, ):
3556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3557 
    if mtype == TMessageType.EXCEPTION:
3558 
      x = TApplicationException()
3559 
      x.read(self._iprot)
3560 
      self._iprot.readMessageEnd()
3561 
      raise x
3562 
    result = validateAccessToken_result()
3563 
    result.read(self._iprot)
3564 
    self._iprot.readMessageEnd()
3565 
    if result.success is not None:
3566 
      return result.success
3567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3568 
 
17782 amit.gupta 3569 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3570 
    """
3571 
    Parameters:
3572 
     - cartId
3573 
     - itemQty
3574 
     - couponCode
3575 
    """
3576 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3577 
    return self.recv_addItemsToCart()
15251 manish.sha 3578 
 
17782 amit.gupta 3579 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3580 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3581 
    args = addItemsToCart_args()
3582 
    args.cartId = cartId
3583 
    args.itemQty = itemQty
3584 
    args.couponCode = couponCode
3585 
    args.write(self._oprot)
3586 
    self._oprot.writeMessageEnd()
3587 
    self._oprot.trans.flush()
3588 
 
3589 
  def recv_addItemsToCart(self, ):
3590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3591 
    if mtype == TMessageType.EXCEPTION:
3592 
      x = TApplicationException()
3593 
      x.read(self._iprot)
3594 
      self._iprot.readMessageEnd()
3595 
      raise x
3596 
    result = addItemsToCart_result()
3597 
    result.read(self._iprot)
3598 
    self._iprot.readMessageEnd()
3599 
    if result.success is not None:
3600 
      return result.success
3601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3602 
 
3603 
  def validateCartNew(self, cartId, pinCode, sourceId):
3604 
    """
3605 
    Parameters:
3606 
     - cartId
3607 
     - pinCode
3608 
     - sourceId
3609 
    """
3610 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3611 
    return self.recv_validateCartNew()
3612 
 
3613 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3614 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3615 
    args = validateCartNew_args()
3616 
    args.cartId = cartId
3617 
    args.pinCode = pinCode
3618 
    args.sourceId = sourceId
3619 
    args.write(self._oprot)
3620 
    self._oprot.writeMessageEnd()
3621 
    self._oprot.trans.flush()
3622 
 
3623 
  def recv_validateCartNew(self, ):
3624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3625 
    if mtype == TMessageType.EXCEPTION:
3626 
      x = TApplicationException()
3627 
      x.read(self._iprot)
3628 
      self._iprot.readMessageEnd()
3629 
      raise x
3630 
    result = validateCartNew_result()
3631 
    result.read(self._iprot)
3632 
    self._iprot.readMessageEnd()
3633 
    if result.success is not None:
3634 
      return result.success
3635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3636 
 
18644 manish.sha 3637 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3638 
    """
3639 
    Parameters:
3640 
     - userId
3641 
    """
18644 manish.sha 3642 
    self.send_isAddressEditableForCounter(userId)
3643 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3644 
 
18644 manish.sha 3645 
  def send_isAddressEditableForCounter(self, userId):
3646 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3647 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3648 
    args.userId = userId
3649 
    args.write(self._oprot)
3650 
    self._oprot.writeMessageEnd()
3651 
    self._oprot.trans.flush()
3652 
 
18644 manish.sha 3653 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3655 
    if mtype == TMessageType.EXCEPTION:
3656 
      x = TApplicationException()
3657 
      x.read(self._iprot)
3658 
      self._iprot.readMessageEnd()
3659 
      raise x
18644 manish.sha 3660 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3661 
    result.read(self._iprot)
3662 
    self._iprot.readMessageEnd()
3663 
    if result.success is not None:
3664 
      return result.success
18644 manish.sha 3665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3666 
 
3667 
  def getBillingAddressForUser(self, userId):
3668 
    """
3669 
    Parameters:
3670 
     - userId
3671 
    """
3672 
    self.send_getBillingAddressForUser(userId)
3673 
    return self.recv_getBillingAddressForUser()
3674 
 
3675 
  def send_getBillingAddressForUser(self, userId):
3676 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3677 
    args = getBillingAddressForUser_args()
3678 
    args.userId = userId
3679 
    args.write(self._oprot)
3680 
    self._oprot.writeMessageEnd()
3681 
    self._oprot.trans.flush()
3682 
 
3683 
  def recv_getBillingAddressForUser(self, ):
3684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3685 
    if mtype == TMessageType.EXCEPTION:
3686 
      x = TApplicationException()
3687 
      x.read(self._iprot)
3688 
      self._iprot.readMessageEnd()
3689 
      raise x
3690 
    result = getBillingAddressForUser_result()
3691 
    result.read(self._iprot)
3692 
    self._iprot.readMessageEnd()
3693 
    if result.success is not None:
3694 
      return result.success
3695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3696 
 
18590 manish.sha 3697 
  def isCreditorAssigned(self, userId):
3698 
    """
3699 
    Parameters:
3700 
     - userId
3701 
    """
3702 
    self.send_isCreditorAssigned(userId)
3703 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3704 
 
18590 manish.sha 3705 
  def send_isCreditorAssigned(self, userId):
3706 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3707 
    args = isCreditorAssigned_args()
3708 
    args.userId = userId
3709 
    args.write(self._oprot)
3710 
    self._oprot.writeMessageEnd()
3711 
    self._oprot.trans.flush()
3712 
 
3713 
  def recv_isCreditorAssigned(self, ):
3714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3715 
    if mtype == TMessageType.EXCEPTION:
3716 
      x = TApplicationException()
3717 
      x.read(self._iprot)
3718 
      self._iprot.readMessageEnd()
3719 
      raise x
3720 
    result = isCreditorAssigned_result()
3721 
    result.read(self._iprot)
3722 
    self._iprot.readMessageEnd()
3723 
    if result.success is not None:
3724 
      return result.success
3725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3726 
 
18735 manish.sha 3727 
  def isTaxInvoiceEnabledUser(self, userId):
3728 
    """
3729 
    Parameters:
3730 
     - userId
3731 
    """
3732 
    self.send_isTaxInvoiceEnabledUser(userId)
3733 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3734 
 
18735 manish.sha 3735 
  def send_isTaxInvoiceEnabledUser(self, userId):
3736 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3737 
    args = isTaxInvoiceEnabledUser_args()
3738 
    args.userId = userId
3739 
    args.write(self._oprot)
3740 
    self._oprot.writeMessageEnd()
3741 
    self._oprot.trans.flush()
3742 
 
3743 
  def recv_isTaxInvoiceEnabledUser(self, ):
3744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3745 
    if mtype == TMessageType.EXCEPTION:
3746 
      x = TApplicationException()
3747 
      x.read(self._iprot)
3748 
      self._iprot.readMessageEnd()
3749 
      raise x
3750 
    result = isTaxInvoiceEnabledUser_result()
3751 
    result.read(self._iprot)
3752 
    self._iprot.readMessageEnd()
3753 
    if result.success is not None:
3754 
      return result.success
3755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3756 
 
18764 kshitij.so 3757 
  def getCartByValue(self, cartIds):
3758 
    """
3759 
    Parameters:
3760 
     - cartIds
3761 
    """
3762 
    self.send_getCartByValue(cartIds)
3763 
    return self.recv_getCartByValue()
18735 manish.sha 3764 
 
18764 kshitij.so 3765 
  def send_getCartByValue(self, cartIds):
3766 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3767 
    args = getCartByValue_args()
3768 
    args.cartIds = cartIds
3769 
    args.write(self._oprot)
3770 
    self._oprot.writeMessageEnd()
3771 
    self._oprot.trans.flush()
3772 
 
3773 
  def recv_getCartByValue(self, ):
3774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3775 
    if mtype == TMessageType.EXCEPTION:
3776 
      x = TApplicationException()
3777 
      x.read(self._iprot)
3778 
      self._iprot.readMessageEnd()
3779 
      raise x
3780 
    result = getCartByValue_result()
3781 
    result.read(self._iprot)
3782 
    self._iprot.readMessageEnd()
3783 
    if result.success is not None:
3784 
      return result.success
3785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3786 
 
3787 
 
3376 rajveer 3788 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3789 
  def __init__(self, handler):
3376 rajveer 3790 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3791 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3792 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3793 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3794 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3795 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3796 
    self._processMap["createUser"] = Processor.process_createUser
3797 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3798 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3799 
    self._processMap["userExists"] = Processor.process_userExists
3800 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3801 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3802 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3803 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3804 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3805 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3806 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3807 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3808 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3809 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3810 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3811 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3812 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3813 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3814 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3815 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3816 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3817 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3818 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3819 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3820 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3821 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3822 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3823 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3824 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3825 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3826 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3827 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3828 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3829 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3830 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3831 
    self._processMap["getCart"] = Processor.process_getCart
3832 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3833 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3834 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3835 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3836 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3837 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3838 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3839 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3840 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3841 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3842 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3843 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3844 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3845 
    self._processMap["checkOut"] = Processor.process_checkOut
3846 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3847 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3848 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3849 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3850 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3851 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3852 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3853 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3854 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3855 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3856 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3857 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3858 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3859 
    self._processMap["insureItem"] = Processor.process_insureItem
3860 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3861 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3862 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3863 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3864 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3865 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3866 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3867 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3868 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3869 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3870 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3871 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3872 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3873 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3874 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3875 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 3876 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 3877 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 3878 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 3879 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
18764 kshitij.so 3880 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
94 ashish 3881 
 
3882 
  def process(self, iprot, oprot):
3883 
    (name, type, seqid) = iprot.readMessageBegin()
3884 
    if name not in self._processMap:
3885 
      iprot.skip(TType.STRUCT)
3886 
      iprot.readMessageEnd()
3887 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3888 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3889 
      x.write(oprot)
3890 
      oprot.writeMessageEnd()
3891 
      oprot.trans.flush()
3892 
      return
3893 
    else:
3894 
      self._processMap[name](self, seqid, iprot, oprot)
3895 
    return True
3896 
 
559 chandransh 3897 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3898 
    args = createAnonymousUser_args()
94 ashish 3899 
    args.read(iprot)
3900 
    iprot.readMessageEnd()
559 chandransh 3901 
    result = createAnonymousUser_result()
94 ashish 3902 
    try:
559 chandransh 3903 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3904 
    except UserContextException, ucex:
3905 
      result.ucex = ucex
3906 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3907 
    result.write(oprot)
3908 
    oprot.writeMessageEnd()
3909 
    oprot.trans.flush()
3910 
 
559 chandransh 3911 
  def process_getUserById(self, seqid, iprot, oprot):
3912 
    args = getUserById_args()
94 ashish 3913 
    args.read(iprot)
3914 
    iprot.readMessageEnd()
559 chandransh 3915 
    result = getUserById_result()
94 ashish 3916 
    try:
559 chandransh 3917 
      result.success = self._handler.getUserById(args.userId)
3918 
    except UserContextException, ucex:
3919 
      result.ucex = ucex
3920 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3921 
    result.write(oprot)
3922 
    oprot.writeMessageEnd()
3923 
    oprot.trans.flush()
3924 
 
5326 rajveer 3925 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3926 
    args = getUserByCartId_args()
3927 
    args.read(iprot)
3928 
    iprot.readMessageEnd()
3929 
    result = getUserByCartId_result()
3930 
    try:
3931 
      result.success = self._handler.getUserByCartId(args.cartId)
3932 
    except UserContextException, ucex:
3933 
      result.ucex = ucex
3934 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3935 
    result.write(oprot)
3936 
    oprot.writeMessageEnd()
3937 
    oprot.trans.flush()
3938 
 
1491 vikas 3939 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3940 
    args = getUserByEmail_args()
3941 
    args.read(iprot)
3942 
    iprot.readMessageEnd()
3943 
    result = getUserByEmail_result()
3944 
    try:
3945 
      result.success = self._handler.getUserByEmail(args.email)
3946 
    except UserContextException, ucex:
3947 
      result.ucex = ucex
3948 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3949 
    result.write(oprot)
3950 
    oprot.writeMessageEnd()
3951 
    oprot.trans.flush()
3952 
 
3032 mandeep.dh 3953 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3954 
    args = getUserByMobileNumber_args()
3955 
    args.read(iprot)
3956 
    iprot.readMessageEnd()
3957 
    result = getUserByMobileNumber_result()
3958 
    try:
3959 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3960 
    except UserContextException, ucex:
3961 
      result.ucex = ucex
3962 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3963 
    result.write(oprot)
3964 
    oprot.writeMessageEnd()
3965 
    oprot.trans.flush()
3966 
 
559 chandransh 3967 
  def process_createUser(self, seqid, iprot, oprot):
3968 
    args = createUser_args()
94 ashish 3969 
    args.read(iprot)
3970 
    iprot.readMessageEnd()
559 chandransh 3971 
    result = createUser_result()
94 ashish 3972 
    try:
559 chandransh 3973 
      result.success = self._handler.createUser(args.user)
3974 
    except UserContextException, ucex:
3975 
      result.ucex = ucex
3976 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3977 
    result.write(oprot)
3978 
    oprot.writeMessageEnd()
3979 
    oprot.trans.flush()
3980 
 
559 chandransh 3981 
  def process_updateUser(self, seqid, iprot, oprot):
3982 
    args = updateUser_args()
94 ashish 3983 
    args.read(iprot)
3984 
    iprot.readMessageEnd()
559 chandransh 3985 
    result = updateUser_result()
94 ashish 3986 
    try:
559 chandransh 3987 
      result.success = self._handler.updateUser(args.user)
3988 
    except UserContextException, ucex:
3989 
      result.ucex = ucex
3990 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3991 
    result.write(oprot)
3992 
    oprot.writeMessageEnd()
3993 
    oprot.trans.flush()
3994 
 
122 ashish 3995 
  def process_authenticateUser(self, seqid, iprot, oprot):
3996 
    args = authenticateUser_args()
3997 
    args.read(iprot)
3998 
    iprot.readMessageEnd()
3999 
    result = authenticateUser_result()
4000 
    try:
559 chandransh 4001 
      result.success = self._handler.authenticateUser(args.email, args.password)
4002 
    except AuthenticationException, auex:
4003 
      result.auex = auex
122 ashish 4004 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4005 
    result.write(oprot)
4006 
    oprot.writeMessageEnd()
4007 
    oprot.trans.flush()
4008 
 
94 ashish 4009 
  def process_userExists(self, seqid, iprot, oprot):
4010 
    args = userExists_args()
4011 
    args.read(iprot)
4012 
    iprot.readMessageEnd()
4013 
    result = userExists_result()
4014 
    try:
4015 
      result.success = self._handler.userExists(args.email)
4016 
    except UserContextException, ucx:
4017 
      result.ucx = ucx
4018 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4019 
    result.write(oprot)
4020 
    oprot.writeMessageEnd()
4021 
    oprot.trans.flush()
4022 
 
4023 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4024 
    args = addAddressForUser_args()
4025 
    args.read(iprot)
4026 
    iprot.readMessageEnd()
4027 
    result = addAddressForUser_result()
4028 
    try:
567 rajveer 4029 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4030 
    except UserContextException, ucx:
4031 
      result.ucx = ucx
4032 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4033 
    result.write(oprot)
4034 
    oprot.writeMessageEnd()
4035 
    oprot.trans.flush()
4036 
 
4037 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4038 
    args = removeAddressForUser_args()
4039 
    args.read(iprot)
4040 
    iprot.readMessageEnd()
4041 
    result = removeAddressForUser_result()
4042 
    try:
4043 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4044 
    except UserContextException, ucx:
4045 
      result.ucx = ucx
4046 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4047 
    result.write(oprot)
4048 
    oprot.writeMessageEnd()
4049 
    oprot.trans.flush()
4050 
 
4051 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4052 
    args = setUserAsLoggedIn_args()
4053 
    args.read(iprot)
4054 
    iprot.readMessageEnd()
4055 
    result = setUserAsLoggedIn_result()
4056 
    try:
4057 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4058 
    except UserContextException, ucx:
4059 
      result.ucx = ucx
4060 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4061 
    result.write(oprot)
4062 
    oprot.writeMessageEnd()
4063 
    oprot.trans.flush()
4064 
 
4065 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4066 
    args = setUserAsLoggedOut_args()
4067 
    args.read(iprot)
4068 
    iprot.readMessageEnd()
4069 
    result = setUserAsLoggedOut_result()
4070 
    try:
4071 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4072 
    except UserContextException, ucx:
4073 
      result.ucx = ucx
4074 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4075 
    result.write(oprot)
4076 
    oprot.writeMessageEnd()
4077 
    oprot.trans.flush()
4078 
 
504 rajveer 4079 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4080 
    args = setDefaultAddress_args()
4081 
    args.read(iprot)
4082 
    iprot.readMessageEnd()
4083 
    result = setDefaultAddress_result()
4084 
    try:
4085 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4086 
    except UserContextException, ucx:
4087 
      result.ucx = ucx
4088 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4089 
    result.write(oprot)
4090 
    oprot.writeMessageEnd()
4091 
    oprot.trans.flush()
4092 
 
94 ashish 4093 
  def process_updatePassword(self, seqid, iprot, oprot):
4094 
    args = updatePassword_args()
4095 
    args.read(iprot)
4096 
    iprot.readMessageEnd()
4097 
    result = updatePassword_result()
4098 
    try:
594 rajveer 4099 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4100 
    except UserContextException, ucx:
4101 
      result.ucx = ucx
4102 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4103 
    result.write(oprot)
4104 
    oprot.writeMessageEnd()
4105 
    oprot.trans.flush()
4106 
 
581 rajveer 4107 
  def process_forgotPassword(self, seqid, iprot, oprot):
4108 
    args = forgotPassword_args()
4109 
    args.read(iprot)
4110 
    iprot.readMessageEnd()
4111 
    result = forgotPassword_result()
4112 
    try:
884 rajveer 4113 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4114 
    except UserContextException, ucx:
4115 
      result.ucx = ucx
4116 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4117 
    result.write(oprot)
4118 
    oprot.writeMessageEnd()
4119 
    oprot.trans.flush()
4120 
 
594 rajveer 4121 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4122 
    args = getAllAddressesForUser_args()
4123 
    args.read(iprot)
4124 
    iprot.readMessageEnd()
4125 
    result = getAllAddressesForUser_result()
4126 
    try:
4127 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4128 
    except UserContextException, ucx:
4129 
      result.ucx = ucx
4130 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4131 
    result.write(oprot)
4132 
    oprot.writeMessageEnd()
4133 
    oprot.trans.flush()
4134 
 
1894 vikas 4135 
  def process_getAddressById(self, seqid, iprot, oprot):
4136 
    args = getAddressById_args()
4137 
    args.read(iprot)
4138 
    iprot.readMessageEnd()
4139 
    result = getAddressById_result()
4140 
    try:
4141 
      result.success = self._handler.getAddressById(args.addressId)
4142 
    except UserContextException, ucx:
4143 
      result.ucx = ucx
4144 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4145 
    result.write(oprot)
4146 
    oprot.writeMessageEnd()
4147 
    oprot.trans.flush()
4148 
 
594 rajveer 4149 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4150 
    args = getDefaultAddressId_args()
4151 
    args.read(iprot)
4152 
    iprot.readMessageEnd()
4153 
    result = getDefaultAddressId_result()
4154 
    try:
4155 
      result.success = self._handler.getDefaultAddressId(args.userId)
4156 
    except UserContextException, ucx:
4157 
      result.ucx = ucx
4158 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4159 
    result.write(oprot)
4160 
    oprot.writeMessageEnd()
4161 
    oprot.trans.flush()
4162 
 
785 rajveer 4163 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4164 
    args = getDefaultPincode_args()
4165 
    args.read(iprot)
4166 
    iprot.readMessageEnd()
4167 
    result = getDefaultPincode_result()
4168 
    try:
4169 
      result.success = self._handler.getDefaultPincode(args.userId)
4170 
    except UserContextException, ucx:
4171 
      result.ucx = ucx
4172 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4173 
    result.write(oprot)
4174 
    oprot.writeMessageEnd()
4175 
    oprot.trans.flush()
4176 
 
1274 varun.gupt 4177 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4178 
    args = saveUserCommunication_args()
4179 
    args.read(iprot)
4180 
    iprot.readMessageEnd()
4181 
    result = saveUserCommunication_result()
4182 
    try:
4183 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4184 
    except UserCommunicationException, ucx:
4185 
      result.ucx = ucx
4186 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4187 
    result.write(oprot)
4188 
    oprot.writeMessageEnd()
4189 
    oprot.trans.flush()
4190 
 
1590 varun.gupt 4191 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4192 
    args = getUserCommunicationById_args()
4193 
    args.read(iprot)
4194 
    iprot.readMessageEnd()
4195 
    result = getUserCommunicationById_result()
4196 
    try:
4197 
      result.success = self._handler.getUserCommunicationById(args.id)
4198 
    except UserCommunicationException, ucx:
4199 
      result.ucx = ucx
4200 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4201 
    result.write(oprot)
4202 
    oprot.writeMessageEnd()
4203 
    oprot.trans.flush()
4204 
 
4205 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4206 
    args = getUserCommunicationByUser_args()
4207 
    args.read(iprot)
4208 
    iprot.readMessageEnd()
4209 
    result = getUserCommunicationByUser_result()
4210 
    try:
4211 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4212 
    except UserCommunicationException, ucx:
4213 
      result.ucx = ucx
4214 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4215 
    result.write(oprot)
4216 
    oprot.writeMessageEnd()
4217 
    oprot.trans.flush()
4218 
 
4219 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4220 
    args = getAllUserCommunications_args()
4221 
    args.read(iprot)
4222 
    iprot.readMessageEnd()
4223 
    result = getAllUserCommunications_result()
4224 
    try:
4225 
      result.success = self._handler.getAllUserCommunications()
4226 
    except UserCommunicationException, ucx:
4227 
      result.ucx = ucx
4228 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4229 
    result.write(oprot)
4230 
    oprot.writeMessageEnd()
4231 
    oprot.trans.flush()
4232 
 
5407 amar.kumar 4233 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4234 
    args = removeUserCommunication_args()
4235 
    args.read(iprot)
4236 
    iprot.readMessageEnd()
4237 
    result = removeUserCommunication_result()
4238 
    try:
4239 
      self._handler.removeUserCommunication(args.id)
4240 
    except UserCommunicationException, ucx:
4241 
      result.ucx = ucx
4242 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4243 
    result.write(oprot)
4244 
    oprot.writeMessageEnd()
4245 
    oprot.trans.flush()
4246 
 
1845 vikas 4247 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4248 
    args = createMasterAffiliate_args()
4249 
    args.read(iprot)
4250 
    iprot.readMessageEnd()
4251 
    result = createMasterAffiliate_result()
4252 
    try:
1859 vikas 4253 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4254 
    except UserAffiliateException, utx:
1845 vikas 4255 
      result.utx = utx
4256 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4257 
    result.write(oprot)
4258 
    oprot.writeMessageEnd()
4259 
    oprot.trans.flush()
4260 
 
1899 vikas 4261 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4262 
    args = getAllMasterAffiliates_args()
4263 
    args.read(iprot)
4264 
    iprot.readMessageEnd()
4265 
    result = getAllMasterAffiliates_result()
4266 
    try:
4267 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4268 
    except UserAffiliateException, utx:
1899 vikas 4269 
      result.utx = utx
4270 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4271 
    result.write(oprot)
4272 
    oprot.writeMessageEnd()
4273 
    oprot.trans.flush()
4274 
 
1845 vikas 4275 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4276 
    args = getMasterAffiliateById_args()
4277 
    args.read(iprot)
4278 
    iprot.readMessageEnd()
4279 
    result = getMasterAffiliateById_result()
4280 
    try:
4281 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4282 
    except UserAffiliateException, utx:
1845 vikas 4283 
      result.utx = utx
4284 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4285 
    result.write(oprot)
4286 
    oprot.writeMessageEnd()
4287 
    oprot.trans.flush()
4288 
 
4289 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4290 
    args = getMasterAffiliateByName_args()
4291 
    args.read(iprot)
4292 
    iprot.readMessageEnd()
4293 
    result = getMasterAffiliateByName_result()
4294 
    try:
4295 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4296 
    except UserAffiliateException, utx:
1845 vikas 4297 
      result.utx = utx
4298 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4299 
    result.write(oprot)
4300 
    oprot.writeMessageEnd()
4301 
    oprot.trans.flush()
4302 
 
4303 
  def process_createAffiliate(self, seqid, iprot, oprot):
4304 
    args = createAffiliate_args()
4305 
    args.read(iprot)
4306 
    iprot.readMessageEnd()
4307 
    result = createAffiliate_result()
4308 
    try:
1859 vikas 4309 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4310 
    except UserAffiliateException, utx:
1845 vikas 4311 
      result.utx = utx
4312 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4313 
    result.write(oprot)
4314 
    oprot.writeMessageEnd()
4315 
    oprot.trans.flush()
4316 
 
4317 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4318 
    args = getAffiliateById_args()
4319 
    args.read(iprot)
4320 
    iprot.readMessageEnd()
4321 
    result = getAffiliateById_result()
4322 
    try:
4323 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4324 
    except UserAffiliateException, utx:
1845 vikas 4325 
      result.utx = utx
4326 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
4330 
 
4331 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4332 
    args = getAffiliateByName_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = getAffiliateByName_result()
4336 
    try:
4337 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4338 
    except UserAffiliateException, utx:
1845 vikas 4339 
      result.utx = utx
4340 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4341 
    result.write(oprot)
4342 
    oprot.writeMessageEnd()
4343 
    oprot.trans.flush()
4344 
 
4345 
  def process_getTrackerById(self, seqid, iprot, oprot):
4346 
    args = getTrackerById_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = getTrackerById_result()
4350 
    try:
1996 vikas 4351 
      result.success = self._handler.getTrackerById(args.id)
4352 
    except UserAffiliateException, utx:
1845 vikas 4353 
      result.utx = utx
4354 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4355 
    result.write(oprot)
4356 
    oprot.writeMessageEnd()
4357 
    oprot.trans.flush()
4358 
 
1996 vikas 4359 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4360 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4361 
    args.read(iprot)
4362 
    iprot.readMessageEnd()
1996 vikas 4363 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4364 
    try:
1996 vikas 4365 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4366 
    except UserAffiliateException, utx:
1845 vikas 4367 
      result.utx = utx
1996 vikas 4368 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4369 
    result.write(oprot)
4370 
    oprot.writeMessageEnd()
4371 
    oprot.trans.flush()
4372 
 
4373 
  def process_addTrackLog(self, seqid, iprot, oprot):
4374 
    args = addTrackLog_args()
4375 
    args.read(iprot)
4376 
    iprot.readMessageEnd()
4377 
    result = addTrackLog_result()
4378 
    try:
1996 vikas 4379 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4380 
    except UserAffiliateException, utx:
1845 vikas 4381 
      result.utx = utx
4382 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4383 
    result.write(oprot)
4384 
    oprot.writeMessageEnd()
4385 
    oprot.trans.flush()
4386 
 
4387 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4388 
    args = getTrackLogById_args()
4389 
    args.read(iprot)
4390 
    iprot.readMessageEnd()
4391 
    result = getTrackLogById_result()
4392 
    try:
4393 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4394 
    except UserAffiliateException, utx:
1845 vikas 4395 
      result.utx = utx
4396 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4397 
    result.write(oprot)
4398 
    oprot.writeMessageEnd()
4399 
    oprot.trans.flush()
4400 
 
1996 vikas 4401 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4402 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4403 
    args.read(iprot)
4404 
    iprot.readMessageEnd()
1996 vikas 4405 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4406 
    try:
3293 vikas 4407 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4408 
    except UserAffiliateException, utx:
1845 vikas 4409 
      result.utx = utx
1996 vikas 4410 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4411 
    result.write(oprot)
4412 
    oprot.writeMessageEnd()
4413 
    oprot.trans.flush()
4414 
 
4415 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4416 
    args = getTrackLogsByUser_args()
4417 
    args.read(iprot)
4418 
    iprot.readMessageEnd()
4419 
    result = getTrackLogsByUser_result()
4420 
    try:
4421 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4422 
    except UserAffiliateException, utx:
1845 vikas 4423 
      result.utx = utx
4424 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
4429 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4430 
    args = getTrackLogs_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = getTrackLogs_result()
4434 
    try:
1996 vikas 4435 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4436 
    except UserAffiliateException, utx:
1845 vikas 4437 
      result.utx = utx
4438 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
4442 
 
559 chandransh 4443 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4444 
    args = getCurrentCart_args()
94 ashish 4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
559 chandransh 4447 
    result = getCurrentCart_result()
94 ashish 4448 
    try:
559 chandransh 4449 
      result.success = self._handler.getCurrentCart(args.userId)
4450 
    except ShoppingCartException, scx:
4451 
      result.scx = scx
4452 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
4456 
 
559 chandransh 4457 
  def process_getCart(self, seqid, iprot, oprot):
4458 
    args = getCart_args()
94 ashish 4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
559 chandransh 4461 
    result = getCart_result()
94 ashish 4462 
    try:
559 chandransh 4463 
      result.success = self._handler.getCart(args.cartId)
4464 
    except ShoppingCartException, scx:
4465 
      result.scx = scx
4466 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4467 
    result.write(oprot)
4468 
    oprot.writeMessageEnd()
4469 
    oprot.trans.flush()
4470 
 
559 chandransh 4471 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4472 
    args = getCartsByTime_args()
94 ashish 4473 
    args.read(iprot)
4474 
    iprot.readMessageEnd()
559 chandransh 4475 
    result = getCartsByTime_result()
94 ashish 4476 
    try:
559 chandransh 4477 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4478 
    except ShoppingCartException, scx:
4479 
      result.scx = scx
4480 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
559 chandransh 4485 
  def process_addItemToCart(self, seqid, iprot, oprot):
4486 
    args = addItemToCart_args()
130 ashish 4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
559 chandransh 4489 
    result = addItemToCart_result()
130 ashish 4490 
    try:
3557 rajveer 4491 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4492 
    except ShoppingCartException, scx:
4493 
      result.scx = scx
4494 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
559 chandransh 4499 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4500 
    args = deleteItemFromCart_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = deleteItemFromCart_result()
4504 
    try:
4505 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4506 
    except ShoppingCartException, scx:
4507 
      result.scx = scx
4508 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
130 ashish 4512 
 
559 chandransh 4513 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4514 
    args = addAddressToCart_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = addAddressToCart_result()
575 chandransh 4518 
    try:
4519 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4520 
    except ShoppingCartException, scx:
4521 
      result.scx = scx
559 chandransh 4522 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4523 
    result.write(oprot)
4524 
    oprot.writeMessageEnd()
4525 
    oprot.trans.flush()
4526 
 
5553 rajveer 4527 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4528 
    args = addStoreToCart_args()
4529 
    args.read(iprot)
4530 
    iprot.readMessageEnd()
4531 
    result = addStoreToCart_result()
4532 
    try:
4533 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4534 
    except ShoppingCartException, scx:
4535 
      result.scx = scx
4536 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
4540 
 
1976 varun.gupt 4541 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4542 
    args = applyCouponToCart_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = applyCouponToCart_result()
4546 
    try:
6922 anupam.sin 4547 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4548 
    except ShoppingCartException, scx:
4549 
      result.scx = scx
4550 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4551 
    result.write(oprot)
4552 
    oprot.writeMessageEnd()
4553 
    oprot.trans.flush()
4554 
 
4555 
  def process_removeCoupon(self, seqid, iprot, oprot):
4556 
    args = removeCoupon_args()
4557 
    args.read(iprot)
4558 
    iprot.readMessageEnd()
4559 
    result = removeCoupon_result()
4560 
    try:
4561 
      self._handler.removeCoupon(args.cartId)
4562 
    except ShoppingCartException, scx:
4563 
      result.scx = scx
4564 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4565 
    result.write(oprot)
4566 
    oprot.writeMessageEnd()
4567 
    oprot.trans.flush()
4568 
 
3554 varun.gupt 4569 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4570 
    args = deleteDiscountsFromCart_args()
4571 
    args.read(iprot)
4572 
    iprot.readMessageEnd()
4573 
    result = deleteDiscountsFromCart_result()
4574 
    try:
4575 
      self._handler.deleteDiscountsFromCart(args.cartId)
4576 
    except ShoppingCartException, scx:
4577 
      result.scx = scx
4578 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4579 
    result.write(oprot)
4580 
    oprot.writeMessageEnd()
4581 
    oprot.trans.flush()
4582 
 
4583 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4584 
    args = saveDiscounts_args()
4585 
    args.read(iprot)
4586 
    iprot.readMessageEnd()
4587 
    result = saveDiscounts_result()
4588 
    try:
4589 
      self._handler.saveDiscounts(args.discounts)
4590 
    except ShoppingCartException, scx:
4591 
      result.scx = scx
4592 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4593 
    result.write(oprot)
4594 
    oprot.writeMessageEnd()
4595 
    oprot.trans.flush()
4596 
 
690 chandransh 4597 
  def process_createOrders(self, seqid, iprot, oprot):
4598 
    args = createOrders_args()
559 chandransh 4599 
    args.read(iprot)
4600 
    iprot.readMessageEnd()
690 chandransh 4601 
    result = createOrders_result()
559 chandransh 4602 
    try:
11526 amit.gupta 4603 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4604 
    except ShoppingCartException, scx:
4605 
      result.scx = scx
690 chandransh 4606 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4611 
  def process_validateCart(self, seqid, iprot, oprot):
4612 
    args = validateCart_args()
4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4615 
    result = validateCart_result()
575 chandransh 4616 
    try:
3557 rajveer 4617 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4618 
    except ShoppingCartException, scex:
4619 
      result.scex = scex
559 chandransh 4620 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4621 
    result.write(oprot)
4622 
    oprot.writeMessageEnd()
4623 
    oprot.trans.flush()
4624 
 
11980 amit.gupta 4625 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4626 
    args = validateCartWithDealerCoupon_args()
4627 
    args.read(iprot)
4628 
    iprot.readMessageEnd()
4629 
    result = validateCartWithDealerCoupon_result()
4630 
    try:
4631 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4632 
    except ShoppingCartException, scex:
4633 
      result.scex = scex
4634 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4635 
    result.write(oprot)
4636 
    oprot.writeMessageEnd()
4637 
    oprot.trans.flush()
4638 
 
690 chandransh 4639 
  def process_mergeCart(self, seqid, iprot, oprot):
4640 
    args = mergeCart_args()
575 chandransh 4641 
    args.read(iprot)
4642 
    iprot.readMessageEnd()
690 chandransh 4643 
    result = mergeCart_result()
4644 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4645 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4646 
    result.write(oprot)
4647 
    oprot.writeMessageEnd()
4648 
    oprot.trans.flush()
4649 
 
4650 
  def process_checkOut(self, seqid, iprot, oprot):
4651 
    args = checkOut_args()
4652 
    args.read(iprot)
4653 
    iprot.readMessageEnd()
4654 
    result = checkOut_result()
575 chandransh 4655 
    try:
690 chandransh 4656 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4657 
    except ShoppingCartException, scex:
4658 
      result.scex = scex
690 chandransh 4659 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
4663 
 
690 chandransh 4664 
  def process_resetCart(self, seqid, iprot, oprot):
4665 
    args = resetCart_args()
559 chandransh 4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
690 chandransh 4668 
    result = resetCart_result()
4669 
    try:
4670 
      result.success = self._handler.resetCart(args.cartId, args.items)
4671 
    except ShoppingCartException, scex:
4672 
      result.scex = scex
4673 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4674 
    result.write(oprot)
4675 
    oprot.writeMessageEnd()
4676 
    oprot.trans.flush()
4677 
 
2981 rajveer 4678 
  def process_getUserCount(self, seqid, iprot, oprot):
4679 
    args = getUserCount_args()
559 chandransh 4680 
    args.read(iprot)
4681 
    iprot.readMessageEnd()
2981 rajveer 4682 
    result = getUserCount_result()
4683 
    result.success = self._handler.getUserCount(args.userType)
4684 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4685 
    result.write(oprot)
4686 
    oprot.writeMessageEnd()
4687 
    oprot.trans.flush()
4688 
 
2981 rajveer 4689 
  def process_getAllUsers(self, seqid, iprot, oprot):
4690 
    args = getAllUsers_args()
559 chandransh 4691 
    args.read(iprot)
4692 
    iprot.readMessageEnd()
2981 rajveer 4693 
    result = getAllUsers_result()
4694 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4695 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4696 
    result.write(oprot)
4697 
    oprot.writeMessageEnd()
4698 
    oprot.trans.flush()
4699 
 
2981 rajveer 4700 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4701 
    args = getMyResearchItems_args()
559 chandransh 4702 
    args.read(iprot)
4703 
    iprot.readMessageEnd()
2981 rajveer 4704 
    result = getMyResearchItems_result()
559 chandransh 4705 
    try:
2981 rajveer 4706 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4707 
    except WidgetException, scx:
4708 
      result.scx = scx
2981 rajveer 4709 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4710 
    result.write(oprot)
4711 
    oprot.writeMessageEnd()
4712 
    oprot.trans.flush()
4713 
 
2981 rajveer 4714 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4715 
    args = updateMyResearch_args()
772 rajveer 4716 
    args.read(iprot)
4717 
    iprot.readMessageEnd()
2981 rajveer 4718 
    result = updateMyResearch_result()
4719 
    try:
4720 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4721 
    except WidgetException, scx:
4722 
      result.scx = scx
4723 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4724 
    result.write(oprot)
4725 
    oprot.writeMessageEnd()
4726 
    oprot.trans.flush()
559 chandransh 4727 
 
2981 rajveer 4728 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4729 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4730 
    args.read(iprot)
4731 
    iprot.readMessageEnd()
2981 rajveer 4732 
    result = deleteItemFromMyResearch_result()
4733 
    try:
4734 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4735 
    except WidgetException, scx:
4736 
      result.scx = scx
4737 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
772 rajveer 4741 
 
2981 rajveer 4742 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4743 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
2981 rajveer 4746 
    result = getBrowseHistoryItems_result()
4747 
    try:
4748 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4749 
    except WidgetException, scx:
4750 
      result.scx = scx
4751 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4752 
    result.write(oprot)
4753 
    oprot.writeMessageEnd()
4754 
    oprot.trans.flush()
1596 ankur.sing 4755 
 
2981 rajveer 4756 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4757 
    args = updateBrowseHistory_args()
2642 varun.gupt 4758 
    args.read(iprot)
4759 
    iprot.readMessageEnd()
2981 rajveer 4760 
    result = updateBrowseHistory_result()
4761 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4762 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4763 
    result.write(oprot)
4764 
    oprot.writeMessageEnd()
4765 
    oprot.trans.flush()
1673 ankur.sing 4766 
 
3385 varun.gupt 4767 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4768 
    args = getCartsWithCouponCount_args()
4769 
    args.read(iprot)
4770 
    iprot.readMessageEnd()
4771 
    result = getCartsWithCouponCount_result()
4772 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4773 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
2642 varun.gupt 4777 
 
3499 mandeep.dh 4778 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4779 
    args = increaseTrustLevel_args()
4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
4782 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4783 
    return
3385 varun.gupt 4784 
 
5407 amar.kumar 4785 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4786 
    args = getTrustLevel_args()
4787 
    args.read(iprot)
4788 
    iprot.readMessageEnd()
4789 
    result = getTrustLevel_result()
4790 
    result.success = self._handler.getTrustLevel(args.userId)
4791 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4792 
    result.write(oprot)
4793 
    oprot.writeMessageEnd()
4794 
    oprot.trans.flush()
4795 
 
4668 varun.gupt 4796 
  def process_showCODOption(self, seqid, iprot, oprot):
4797 
    args = showCODOption_args()
4798 
    args.read(iprot)
4799 
    iprot.readMessageEnd()
4800 
    result = showCODOption_result()
4801 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4802 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4803 
    result.write(oprot)
4804 
    oprot.writeMessageEnd()
4805 
    oprot.trans.flush()
3499 mandeep.dh 4806 
 
5623 anupam.sin 4807 
  def process_getUserEmails(self, seqid, iprot, oprot):
4808 
    args = getUserEmails_args()
4809 
    args.read(iprot)
4810 
    iprot.readMessageEnd()
4811 
    result = getUserEmails_result()
4812 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4813 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4668 varun.gupt 4817 
 
6903 anupam.sin 4818 
  def process_insureItem(self, seqid, iprot, oprot):
4819 
    args = insureItem_args()
4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
4822 
    result = insureItem_result()
9299 kshitij.so 4823 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4824 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4825 
    result.write(oprot)
4826 
    oprot.writeMessageEnd()
4827 
    oprot.trans.flush()
4828 
 
4829 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4830 
    args = cancelInsurance_args()
4831 
    args.read(iprot)
4832 
    iprot.readMessageEnd()
4833 
    result = cancelInsurance_result()
4834 
    result.success = self._handler.cancelInsurance(args.cartId)
4835 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4836 
    result.write(oprot)
4837 
    oprot.writeMessageEnd()
4838 
    oprot.trans.flush()
4839 
 
4840 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4841 
    args = storeInsuranceSpecificDetails_args()
4842 
    args.read(iprot)
4843 
    iprot.readMessageEnd()
4844 
    result = storeInsuranceSpecificDetails_result()
4845 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4846 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4847 
    result.write(oprot)
4848 
    oprot.writeMessageEnd()
4849 
    oprot.trans.flush()
4850 
 
4851 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4852 
    args = isInsuranceDetailPresent_args()
4853 
    args.read(iprot)
4854 
    iprot.readMessageEnd()
4855 
    result = isInsuranceDetailPresent_result()
4856 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4857 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4858 
    result.write(oprot)
4859 
    oprot.writeMessageEnd()
4860 
    oprot.trans.flush()
4861 
 
9791 rajveer 4862 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4863 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4864 
    args.read(iprot)
4865 
    iprot.readMessageEnd()
9791 rajveer 4866 
    result = getProductsAddedToCart_result()
4867 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4868 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4869 
    result.write(oprot)
4870 
    oprot.writeMessageEnd()
4871 
    oprot.trans.flush()
5623 anupam.sin 4872 
 
11592 amit.gupta 4873 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4874 
    args = validateCartPlus_args()
4875 
    args.read(iprot)
4876 
    iprot.readMessageEnd()
4877 
    result = validateCartPlus_result()
4878 
    try:
11980 amit.gupta 4879 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4880 
    except ShoppingCartException, scex:
4881 
      result.scex = scex
4882 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4883 
    result.write(oprot)
4884 
    oprot.writeMessageEnd()
4885 
    oprot.trans.flush()
6821 amar.kumar 4886 
 
11679 vikram.rag 4887 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4888 
    args = isPrivateDealUser_args()
4889 
    args.read(iprot)
4890 
    iprot.readMessageEnd()
4891 
    result = isPrivateDealUser_result()
4892 
    result.success = self._handler.isPrivateDealUser(args.userId)
4893 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4894 
    result.write(oprot)
4895 
    oprot.writeMessageEnd()
4896 
    oprot.trans.flush()
11592 amit.gupta 4897 
 
11890 kshitij.so 4898 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4899 
    args = addPrivateDealUser_args()
4900 
    args.read(iprot)
4901 
    iprot.readMessageEnd()
4902 
    result = addPrivateDealUser_result()
4903 
    result.success = self._handler.addPrivateDealUser(args.userId)
4904 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4905 
    result.write(oprot)
4906 
    oprot.writeMessageEnd()
4907 
    oprot.trans.flush()
11679 vikram.rag 4908 
 
11890 kshitij.so 4909 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4910 
    args = changePrivateDealUserStatus_args()
4911 
    args.read(iprot)
4912 
    iprot.readMessageEnd()
4913 
    result = changePrivateDealUserStatus_result()
4914 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4915 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4916 
    result.write(oprot)
4917 
    oprot.writeMessageEnd()
4918 
    oprot.trans.flush()
4919 
 
4920 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4921 
    args = getPrivateDealUser_args()
4922 
    args.read(iprot)
4923 
    iprot.readMessageEnd()
4924 
    result = getPrivateDealUser_result()
4925 
    result.success = self._handler.getPrivateDealUser(args.userId)
4926 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4927 
    result.write(oprot)
4928 
    oprot.writeMessageEnd()
4929 
    oprot.trans.flush()
4930 
 
12696 amit.gupta 4931 
  def process_registerCounter(self, seqid, iprot, oprot):
4932 
    args = registerCounter_args()
4933 
    args.read(iprot)
4934 
    iprot.readMessageEnd()
4935 
    result = registerCounter_result()
4936 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4937 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4938 
    result.write(oprot)
4939 
    oprot.writeMessageEnd()
4940 
    oprot.trans.flush()
11890 kshitij.so 4941 
 
12722 amit.gupta 4942 
  def process_searchCounter(self, seqid, iprot, oprot):
4943 
    args = searchCounter_args()
4944 
    args.read(iprot)
4945 
    iprot.readMessageEnd()
4946 
    result = searchCounter_result()
4947 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4948 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4949 
    result.write(oprot)
4950 
    oprot.writeMessageEnd()
4951 
    oprot.trans.flush()
12696 amit.gupta 4952 
 
12722 amit.gupta 4953 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4954 
    args = getAllUsersByCounter_args()
4955 
    args.read(iprot)
4956 
    iprot.readMessageEnd()
4957 
    result = getAllUsersByCounter_result()
4958 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4959 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4960 
    result.write(oprot)
4961 
    oprot.writeMessageEnd()
4962 
    oprot.trans.flush()
4963 
 
15251 manish.sha 4964 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
4965 
    args = getActiveAccessTokenForUser_args()
4966 
    args.read(iprot)
4967 
    iprot.readMessageEnd()
4968 
    result = getActiveAccessTokenForUser_result()
4969 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
4970 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
4971 
    result.write(oprot)
4972 
    oprot.writeMessageEnd()
4973 
    oprot.trans.flush()
12722 amit.gupta 4974 
 
15251 manish.sha 4975 
  def process_validateAccessToken(self, seqid, iprot, oprot):
4976 
    args = validateAccessToken_args()
4977 
    args.read(iprot)
4978 
    iprot.readMessageEnd()
4979 
    result = validateAccessToken_result()
4980 
    result.success = self._handler.validateAccessToken(args.accessToken)
4981 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
4982 
    result.write(oprot)
4983 
    oprot.writeMessageEnd()
4984 
    oprot.trans.flush()
4985 
 
17782 amit.gupta 4986 
  def process_addItemsToCart(self, seqid, iprot, oprot):
4987 
    args = addItemsToCart_args()
4988 
    args.read(iprot)
4989 
    iprot.readMessageEnd()
4990 
    result = addItemsToCart_result()
4991 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
4992 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
4993 
    result.write(oprot)
4994 
    oprot.writeMessageEnd()
4995 
    oprot.trans.flush()
15251 manish.sha 4996 
 
17782 amit.gupta 4997 
  def process_validateCartNew(self, seqid, iprot, oprot):
4998 
    args = validateCartNew_args()
4999 
    args.read(iprot)
5000 
    iprot.readMessageEnd()
5001 
    result = validateCartNew_result()
5002 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5003 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
5007 
 
18644 manish.sha 5008 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5009 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
18644 manish.sha 5012 
    result = isAddressEditableForCounter_result()
5013 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5014 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5015 
    result.write(oprot)
5016 
    oprot.writeMessageEnd()
5017 
    oprot.trans.flush()
17782 amit.gupta 5018 
 
18530 manish.sha 5019 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5020 
    args = getBillingAddressForUser_args()
5021 
    args.read(iprot)
5022 
    iprot.readMessageEnd()
5023 
    result = getBillingAddressForUser_result()
5024 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5025 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5026 
    result.write(oprot)
5027 
    oprot.writeMessageEnd()
5028 
    oprot.trans.flush()
5029 
 
18590 manish.sha 5030 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5031 
    args = isCreditorAssigned_args()
5032 
    args.read(iprot)
5033 
    iprot.readMessageEnd()
5034 
    result = isCreditorAssigned_result()
5035 
    result.success = self._handler.isCreditorAssigned(args.userId)
5036 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5037 
    result.write(oprot)
5038 
    oprot.writeMessageEnd()
5039 
    oprot.trans.flush()
18530 manish.sha 5040 
 
18735 manish.sha 5041 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5042 
    args = isTaxInvoiceEnabledUser_args()
5043 
    args.read(iprot)
5044 
    iprot.readMessageEnd()
5045 
    result = isTaxInvoiceEnabledUser_result()
5046 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5047 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5048 
    result.write(oprot)
5049 
    oprot.writeMessageEnd()
5050 
    oprot.trans.flush()
18590 manish.sha 5051 
 
18764 kshitij.so 5052 
  def process_getCartByValue(self, seqid, iprot, oprot):
5053 
    args = getCartByValue_args()
5054 
    args.read(iprot)
5055 
    iprot.readMessageEnd()
5056 
    result = getCartByValue_result()
5057 
    result.success = self._handler.getCartByValue(args.cartIds)
5058 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
18735 manish.sha 5062 
 
18764 kshitij.so 5063 
 
94 ashish 5064 
# HELPER FUNCTIONS AND STRUCTURES
5065 
 
559 chandransh 5066 
class createAnonymousUser_args:
94 ashish 5067 
  """
5068 
  Attributes:
559 chandransh 5069 
   - jsessionId
94 ashish 5070 
  """
5071 
 
5072 
  thrift_spec = (
5073 
    None, # 0
559 chandransh 5074 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5075 
  )
5076 
 
559 chandransh 5077 
  def __init__(self, jsessionId=None,):
5078 
    self.jsessionId = jsessionId
94 ashish 5079 
 
5080 
  def read(self, iprot):
5081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5083 
      return
5084 
    iprot.readStructBegin()
5085 
    while True:
5086 
      (fname, ftype, fid) = iprot.readFieldBegin()
5087 
      if ftype == TType.STOP:
5088 
        break
5089 
      if fid == 1:
559 chandransh 5090 
        if ftype == TType.STRING:
5091 
          self.jsessionId = iprot.readString();
94 ashish 5092 
        else:
5093 
          iprot.skip(ftype)
5094 
      else:
5095 
        iprot.skip(ftype)
5096 
      iprot.readFieldEnd()
5097 
    iprot.readStructEnd()
5098 
 
5099 
  def write(self, oprot):
5100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5102 
      return
559 chandransh 5103 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5104 
    if self.jsessionId is not None:
559 chandransh 5105 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5106 
      oprot.writeString(self.jsessionId)
94 ashish 5107 
      oprot.writeFieldEnd()
5108 
    oprot.writeFieldStop()
5109 
    oprot.writeStructEnd()
5110 
 
3431 rajveer 5111 
  def validate(self):
5112 
    return
5113 
 
5114 
 
94 ashish 5115 
  def __repr__(self):
5116 
    L = ['%s=%r' % (key, value)
5117 
      for key, value in self.__dict__.iteritems()]
5118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5119 
 
5120 
  def __eq__(self, other):
5121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5122 
 
5123 
  def __ne__(self, other):
5124 
    return not (self == other)
5125 
 
559 chandransh 5126 
class createAnonymousUser_result:
94 ashish 5127 
  """
5128 
  Attributes:
5129 
   - success
559 chandransh 5130 
   - ucex
94 ashish 5131 
  """
5132 
 
5133 
  thrift_spec = (
559 chandransh 5134 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5135 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5136 
  )
5137 
 
559 chandransh 5138 
  def __init__(self, success=None, ucex=None,):
94 ashish 5139 
    self.success = success
559 chandransh 5140 
    self.ucex = ucex
94 ashish 5141 
 
5142 
  def read(self, iprot):
5143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5145 
      return
5146 
    iprot.readStructBegin()
5147 
    while True:
5148 
      (fname, ftype, fid) = iprot.readFieldBegin()
5149 
      if ftype == TType.STOP:
5150 
        break
5151 
      if fid == 0:
5152 
        if ftype == TType.STRUCT:
559 chandransh 5153 
          self.success = User()
94 ashish 5154 
          self.success.read(iprot)
5155 
        else:
5156 
          iprot.skip(ftype)
5157 
      elif fid == 1:
5158 
        if ftype == TType.STRUCT:
559 chandransh 5159 
          self.ucex = UserContextException()
5160 
          self.ucex.read(iprot)
94 ashish 5161 
        else:
5162 
          iprot.skip(ftype)
5163 
      else:
5164 
        iprot.skip(ftype)
5165 
      iprot.readFieldEnd()
5166 
    iprot.readStructEnd()
5167 
 
5168 
  def write(self, oprot):
5169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5171 
      return
559 chandransh 5172 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5173 
    if self.success is not None:
94 ashish 5174 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5175 
      self.success.write(oprot)
5176 
      oprot.writeFieldEnd()
3431 rajveer 5177 
    if self.ucex is not None:
559 chandransh 5178 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5179 
      self.ucex.write(oprot)
94 ashish 5180 
      oprot.writeFieldEnd()
5181 
    oprot.writeFieldStop()
5182 
    oprot.writeStructEnd()
5183 
 
3431 rajveer 5184 
  def validate(self):
5185 
    return
5186 
 
5187 
 
94 ashish 5188 
  def __repr__(self):
5189 
    L = ['%s=%r' % (key, value)
5190 
      for key, value in self.__dict__.iteritems()]
5191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5192 
 
5193 
  def __eq__(self, other):
5194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5195 
 
5196 
  def __ne__(self, other):
5197 
    return not (self == other)
5198 
 
559 chandransh 5199 
class getUserById_args:
94 ashish 5200 
  """
5201 
  Attributes:
5202 
   - userId
5203 
  """
5204 
 
5205 
  thrift_spec = (
5206 
    None, # 0
5207 
    (1, TType.I64, 'userId', None, None, ), # 1
5208 
  )
5209 
 
559 chandransh 5210 
  def __init__(self, userId=None,):
94 ashish 5211 
    self.userId = userId
5212 
 
5213 
  def read(self, iprot):
5214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5216 
      return
5217 
    iprot.readStructBegin()
5218 
    while True:
5219 
      (fname, ftype, fid) = iprot.readFieldBegin()
5220 
      if ftype == TType.STOP:
5221 
        break
5222 
      if fid == 1:
5223 
        if ftype == TType.I64:
5224 
          self.userId = iprot.readI64();
5225 
        else:
5226 
          iprot.skip(ftype)
5227 
      else:
5228 
        iprot.skip(ftype)
5229 
      iprot.readFieldEnd()
5230 
    iprot.readStructEnd()
5231 
 
5232 
  def write(self, oprot):
5233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5235 
      return
559 chandransh 5236 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5237 
    if self.userId is not None:
94 ashish 5238 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5239 
      oprot.writeI64(self.userId)
5240 
      oprot.writeFieldEnd()
5241 
    oprot.writeFieldStop()
5242 
    oprot.writeStructEnd()
5243 
 
3431 rajveer 5244 
  def validate(self):
5245 
    return
5246 
 
5247 
 
94 ashish 5248 
  def __repr__(self):
5249 
    L = ['%s=%r' % (key, value)
5250 
      for key, value in self.__dict__.iteritems()]
5251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5252 
 
5253 
  def __eq__(self, other):
5254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5255 
 
5256 
  def __ne__(self, other):
5257 
    return not (self == other)
5258 
 
559 chandransh 5259 
class getUserById_result:
94 ashish 5260 
  """
5261 
  Attributes:
5262 
   - success
559 chandransh 5263 
   - ucex
94 ashish 5264 
  """
5265 
 
5266 
  thrift_spec = (
559 chandransh 5267 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5268 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5269 
  )
5270 
 
559 chandransh 5271 
  def __init__(self, success=None, ucex=None,):
94 ashish 5272 
    self.success = success
559 chandransh 5273 
    self.ucex = ucex
94 ashish 5274 
 
5275 
  def read(self, iprot):
5276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5278 
      return
5279 
    iprot.readStructBegin()
5280 
    while True:
5281 
      (fname, ftype, fid) = iprot.readFieldBegin()
5282 
      if ftype == TType.STOP:
5283 
        break
5284 
      if fid == 0:
5285 
        if ftype == TType.STRUCT:
559 chandransh 5286 
          self.success = User()
94 ashish 5287 
          self.success.read(iprot)
5288 
        else:
5289 
          iprot.skip(ftype)
5290 
      elif fid == 1:
5291 
        if ftype == TType.STRUCT:
559 chandransh 5292 
          self.ucex = UserContextException()
5293 
          self.ucex.read(iprot)
94 ashish 5294 
        else:
5295 
          iprot.skip(ftype)
5296 
      else:
5297 
        iprot.skip(ftype)
5298 
      iprot.readFieldEnd()
5299 
    iprot.readStructEnd()
5300 
 
5301 
  def write(self, oprot):
5302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5304 
      return
559 chandransh 5305 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5306 
    if self.success is not None:
94 ashish 5307 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5308 
      self.success.write(oprot)
5309 
      oprot.writeFieldEnd()
3431 rajveer 5310 
    if self.ucex is not None:
559 chandransh 5311 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5312 
      self.ucex.write(oprot)
94 ashish 5313 
      oprot.writeFieldEnd()
5314 
    oprot.writeFieldStop()
5315 
    oprot.writeStructEnd()
5316 
 
3431 rajveer 5317 
  def validate(self):
5318 
    return
5319 
 
5320 
 
94 ashish 5321 
  def __repr__(self):
5322 
    L = ['%s=%r' % (key, value)
5323 
      for key, value in self.__dict__.iteritems()]
5324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5325 
 
5326 
  def __eq__(self, other):
5327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5328 
 
5329 
  def __ne__(self, other):
5330 
    return not (self == other)
5331 
 
5326 rajveer 5332 
class getUserByCartId_args:
1491 vikas 5333 
  """
5334 
  Attributes:
5326 rajveer 5335 
   - cartId
1491 vikas 5336 
  """
5337 
 
5338 
  thrift_spec = (
5339 
    None, # 0
5326 rajveer 5340 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5341 
  )
5342 
 
5326 rajveer 5343 
  def __init__(self, cartId=None,):
5344 
    self.cartId = cartId
1491 vikas 5345 
 
5346 
  def read(self, iprot):
5347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5349 
      return
5350 
    iprot.readStructBegin()
5351 
    while True:
5352 
      (fname, ftype, fid) = iprot.readFieldBegin()
5353 
      if ftype == TType.STOP:
5354 
        break
5355 
      if fid == 1:
5326 rajveer 5356 
        if ftype == TType.I64:
5357 
          self.cartId = iprot.readI64();
1491 vikas 5358 
        else:
5359 
          iprot.skip(ftype)
5360 
      else:
5361 
        iprot.skip(ftype)
5362 
      iprot.readFieldEnd()
5363 
    iprot.readStructEnd()
5364 
 
5365 
  def write(self, oprot):
5366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5368 
      return
5326 rajveer 5369 
    oprot.writeStructBegin('getUserByCartId_args')
5370 
    if self.cartId is not None:
5371 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5372 
      oprot.writeI64(self.cartId)
1491 vikas 5373 
      oprot.writeFieldEnd()
5374 
    oprot.writeFieldStop()
5375 
    oprot.writeStructEnd()
5376 
 
3431 rajveer 5377 
  def validate(self):
5378 
    return
5379 
 
5380 
 
1491 vikas 5381 
  def __repr__(self):
5382 
    L = ['%s=%r' % (key, value)
5383 
      for key, value in self.__dict__.iteritems()]
5384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5385 
 
5386 
  def __eq__(self, other):
5387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5388 
 
5389 
  def __ne__(self, other):
5390 
    return not (self == other)
5391 
 
5326 rajveer 5392 
class getUserByCartId_result:
1491 vikas 5393 
  """
5394 
  Attributes:
5395 
   - success
5396 
   - ucex
5397 
  """
5398 
 
5399 
  thrift_spec = (
5400 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5401 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5402 
  )
5403 
 
5404 
  def __init__(self, success=None, ucex=None,):
5405 
    self.success = success
5406 
    self.ucex = ucex
5407 
 
5408 
  def read(self, iprot):
5409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5411 
      return
5412 
    iprot.readStructBegin()
5413 
    while True:
5414 
      (fname, ftype, fid) = iprot.readFieldBegin()
5415 
      if ftype == TType.STOP:
5416 
        break
5417 
      if fid == 0:
5418 
        if ftype == TType.STRUCT:
5419 
          self.success = User()
5420 
          self.success.read(iprot)
5421 
        else:
5422 
          iprot.skip(ftype)
5423 
      elif fid == 1:
5424 
        if ftype == TType.STRUCT:
5425 
          self.ucex = UserContextException()
5426 
          self.ucex.read(iprot)
5427 
        else:
5428 
          iprot.skip(ftype)
5429 
      else:
5430 
        iprot.skip(ftype)
5431 
      iprot.readFieldEnd()
5432 
    iprot.readStructEnd()
5433 
 
5434 
  def write(self, oprot):
5435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5437 
      return
5326 rajveer 5438 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5439 
    if self.success is not None:
1491 vikas 5440 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5441 
      self.success.write(oprot)
5442 
      oprot.writeFieldEnd()
3431 rajveer 5443 
    if self.ucex is not None:
1491 vikas 5444 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5445 
      self.ucex.write(oprot)
5446 
      oprot.writeFieldEnd()
5447 
    oprot.writeFieldStop()
5448 
    oprot.writeStructEnd()
5449 
 
3431 rajveer 5450 
  def validate(self):
5451 
    return
5452 
 
5453 
 
1491 vikas 5454 
  def __repr__(self):
5455 
    L = ['%s=%r' % (key, value)
5456 
      for key, value in self.__dict__.iteritems()]
5457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5458 
 
5459 
  def __eq__(self, other):
5460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5461 
 
5462 
  def __ne__(self, other):
5463 
    return not (self == other)
5464 
 
5326 rajveer 5465 
class getUserByEmail_args:
3032 mandeep.dh 5466 
  """
5467 
  Attributes:
5326 rajveer 5468 
   - email
3032 mandeep.dh 5469 
  """
5470 
 
5471 
  thrift_spec = (
5472 
    None, # 0
5326 rajveer 5473 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5474 
  )
5475 
 
5326 rajveer 5476 
  def __init__(self, email=None,):
5477 
    self.email = email
3032 mandeep.dh 5478 
 
5479 
  def read(self, iprot):
5480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5482 
      return
5483 
    iprot.readStructBegin()
5484 
    while True:
5485 
      (fname, ftype, fid) = iprot.readFieldBegin()
5486 
      if ftype == TType.STOP:
5487 
        break
5488 
      if fid == 1:
5326 rajveer 5489 
        if ftype == TType.STRING:
5490 
          self.email = iprot.readString();
3032 mandeep.dh 5491 
        else:
5492 
          iprot.skip(ftype)
5493 
      else:
5494 
        iprot.skip(ftype)
5495 
      iprot.readFieldEnd()
5496 
    iprot.readStructEnd()
5497 
 
5498 
  def write(self, oprot):
5499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5501 
      return
5326 rajveer 5502 
    oprot.writeStructBegin('getUserByEmail_args')
5503 
    if self.email is not None:
5504 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5505 
      oprot.writeString(self.email)
3032 mandeep.dh 5506 
      oprot.writeFieldEnd()
5507 
    oprot.writeFieldStop()
5508 
    oprot.writeStructEnd()
5509 
 
3431 rajveer 5510 
  def validate(self):
5511 
    return
5512 
 
5513 
 
3032 mandeep.dh 5514 
  def __repr__(self):
5515 
    L = ['%s=%r' % (key, value)
5516 
      for key, value in self.__dict__.iteritems()]
5517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5518 
 
5519 
  def __eq__(self, other):
5520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5521 
 
5522 
  def __ne__(self, other):
5523 
    return not (self == other)
5524 
 
5326 rajveer 5525 
class getUserByEmail_result:
3032 mandeep.dh 5526 
  """
5527 
  Attributes:
5528 
   - success
5529 
   - ucex
5530 
  """
5531 
 
5532 
  thrift_spec = (
5533 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5534 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5535 
  )
5536 
 
5537 
  def __init__(self, success=None, ucex=None,):
5538 
    self.success = success
5539 
    self.ucex = ucex
5540 
 
5541 
  def read(self, iprot):
5542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5544 
      return
5545 
    iprot.readStructBegin()
5546 
    while True:
5547 
      (fname, ftype, fid) = iprot.readFieldBegin()
5548 
      if ftype == TType.STOP:
5549 
        break
5550 
      if fid == 0:
5551 
        if ftype == TType.STRUCT:
5552 
          self.success = User()
5553 
          self.success.read(iprot)
5554 
        else:
5555 
          iprot.skip(ftype)
5556 
      elif fid == 1:
5557 
        if ftype == TType.STRUCT:
5558 
          self.ucex = UserContextException()
5559 
          self.ucex.read(iprot)
5560 
        else:
5561 
          iprot.skip(ftype)
5562 
      else:
5563 
        iprot.skip(ftype)
5564 
      iprot.readFieldEnd()
5565 
    iprot.readStructEnd()
5566 
 
5567 
  def write(self, oprot):
5568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5570 
      return
5326 rajveer 5571 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5572 
    if self.success is not None:
3032 mandeep.dh 5573 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5574 
      self.success.write(oprot)
5575 
      oprot.writeFieldEnd()
3431 rajveer 5576 
    if self.ucex is not None:
3032 mandeep.dh 5577 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5578 
      self.ucex.write(oprot)
5579 
      oprot.writeFieldEnd()
5580 
    oprot.writeFieldStop()
5581 
    oprot.writeStructEnd()
5582 
 
3431 rajveer 5583 
  def validate(self):
5584 
    return
5585 
 
5586 
 
3032 mandeep.dh 5587 
  def __repr__(self):
5588 
    L = ['%s=%r' % (key, value)
5589 
      for key, value in self.__dict__.iteritems()]
5590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5591 
 
5592 
  def __eq__(self, other):
5593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5594 
 
5595 
  def __ne__(self, other):
5596 
    return not (self == other)
5597 
 
5326 rajveer 5598 
class getUserByMobileNumber_args:
94 ashish 5599 
  """
5600 
  Attributes:
5326 rajveer 5601 
   - mobileNumber
94 ashish 5602 
  """
5603 
 
5604 
  thrift_spec = (
5605 
    None, # 0
5326 rajveer 5606 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5607 
  )
5608 
 
5326 rajveer 5609 
  def __init__(self, mobileNumber=None,):
5610 
    self.mobileNumber = mobileNumber
94 ashish 5611 
 
5612 
  def read(self, iprot):
5613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5615 
      return
5616 
    iprot.readStructBegin()
5617 
    while True:
5618 
      (fname, ftype, fid) = iprot.readFieldBegin()
5619 
      if ftype == TType.STOP:
5620 
        break
5621 
      if fid == 1:
5326 rajveer 5622 
        if ftype == TType.I64:
5623 
          self.mobileNumber = iprot.readI64();
94 ashish 5624 
        else:
5625 
          iprot.skip(ftype)
5626 
      else:
5627 
        iprot.skip(ftype)
5628 
      iprot.readFieldEnd()
5629 
    iprot.readStructEnd()
5630 
 
5631 
  def write(self, oprot):
5632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5634 
      return
5326 rajveer 5635 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5636 
    if self.mobileNumber is not None:
5637 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5638 
      oprot.writeI64(self.mobileNumber)
94 ashish 5639 
      oprot.writeFieldEnd()
5640 
    oprot.writeFieldStop()
5641 
    oprot.writeStructEnd()
5642 
 
3431 rajveer 5643 
  def validate(self):
5644 
    return
5645 
 
5646 
 
94 ashish 5647 
  def __repr__(self):
5648 
    L = ['%s=%r' % (key, value)
5649 
      for key, value in self.__dict__.iteritems()]
5650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5651 
 
5652 
  def __eq__(self, other):
5653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5654 
 
5655 
  def __ne__(self, other):
5656 
    return not (self == other)
5657 
 
5326 rajveer 5658 
class getUserByMobileNumber_result:
94 ashish 5659 
  """
5660 
  Attributes:
5661 
   - success
559 chandransh 5662 
   - ucex
94 ashish 5663 
  """
5664 
 
5665 
  thrift_spec = (
559 chandransh 5666 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5667 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5668 
  )
5669 
 
559 chandransh 5670 
  def __init__(self, success=None, ucex=None,):
94 ashish 5671 
    self.success = success
559 chandransh 5672 
    self.ucex = ucex
94 ashish 5673 
 
5674 
  def read(self, iprot):
5675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5677 
      return
5678 
    iprot.readStructBegin()
5679 
    while True:
5680 
      (fname, ftype, fid) = iprot.readFieldBegin()
5681 
      if ftype == TType.STOP:
5682 
        break
5683 
      if fid == 0:
5684 
        if ftype == TType.STRUCT:
559 chandransh 5685 
          self.success = User()
94 ashish 5686 
          self.success.read(iprot)
5687 
        else:
5688 
          iprot.skip(ftype)
5689 
      elif fid == 1:
5690 
        if ftype == TType.STRUCT:
559 chandransh 5691 
          self.ucex = UserContextException()
5692 
          self.ucex.read(iprot)
94 ashish 5693 
        else:
5694 
          iprot.skip(ftype)
5695 
      else:
5696 
        iprot.skip(ftype)
5697 
      iprot.readFieldEnd()
5698 
    iprot.readStructEnd()
5699 
 
5700 
  def write(self, oprot):
5701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5703 
      return
5326 rajveer 5704 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5705 
    if self.success is not None:
94 ashish 5706 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5707 
      self.success.write(oprot)
5708 
      oprot.writeFieldEnd()
3431 rajveer 5709 
    if self.ucex is not None:
559 chandransh 5710 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5711 
      self.ucex.write(oprot)
94 ashish 5712 
      oprot.writeFieldEnd()
5713 
    oprot.writeFieldStop()
5714 
    oprot.writeStructEnd()
5715 
 
3431 rajveer 5716 
  def validate(self):
5717 
    return
5718 
 
5719 
 
94 ashish 5720 
  def __repr__(self):
5721 
    L = ['%s=%r' % (key, value)
5722 
      for key, value in self.__dict__.iteritems()]
5723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5724 
 
5725 
  def __eq__(self, other):
5726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5727 
 
5728 
  def __ne__(self, other):
5729 
    return not (self == other)
5730 
 
5326 rajveer 5731 
class createUser_args:
94 ashish 5732 
  """
5733 
  Attributes:
559 chandransh 5734 
   - user
94 ashish 5735 
  """
5736 
 
5737 
  thrift_spec = (
5738 
    None, # 0
559 chandransh 5739 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5740 
  )
5741 
 
559 chandransh 5742 
  def __init__(self, user=None,):
5743 
    self.user = user
94 ashish 5744 
 
5745 
  def read(self, iprot):
5746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5748 
      return
5749 
    iprot.readStructBegin()
5750 
    while True:
5751 
      (fname, ftype, fid) = iprot.readFieldBegin()
5752 
      if ftype == TType.STOP:
5753 
        break
5754 
      if fid == 1:
559 chandransh 5755 
        if ftype == TType.STRUCT:
5756 
          self.user = User()
5757 
          self.user.read(iprot)
94 ashish 5758 
        else:
5759 
          iprot.skip(ftype)
5760 
      else:
5761 
        iprot.skip(ftype)
5762 
      iprot.readFieldEnd()
5763 
    iprot.readStructEnd()
5764 
 
5765 
  def write(self, oprot):
5766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5768 
      return
5326 rajveer 5769 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5770 
    if self.user is not None:
559 chandransh 5771 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5772 
      self.user.write(oprot)
94 ashish 5773 
      oprot.writeFieldEnd()
5774 
    oprot.writeFieldStop()
5775 
    oprot.writeStructEnd()
5776 
 
3431 rajveer 5777 
  def validate(self):
5778 
    return
5779 
 
5780 
 
94 ashish 5781 
  def __repr__(self):
5782 
    L = ['%s=%r' % (key, value)
5783 
      for key, value in self.__dict__.iteritems()]
5784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5785 
 
5786 
  def __eq__(self, other):
5787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5788 
 
5789 
  def __ne__(self, other):
5790 
    return not (self == other)
5791 
 
5326 rajveer 5792 
class createUser_result:
94 ashish 5793 
  """
5794 
  Attributes:
5795 
   - success
559 chandransh 5796 
   - ucex
94 ashish 5797 
  """
5798 
 
5799 
  thrift_spec = (
559 chandransh 5800 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5801 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5802 
  )
5803 
 
559 chandransh 5804 
  def __init__(self, success=None, ucex=None,):
94 ashish 5805 
    self.success = success
559 chandransh 5806 
    self.ucex = ucex
94 ashish 5807 
 
5808 
  def read(self, iprot):
5809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5811 
      return
5812 
    iprot.readStructBegin()
5813 
    while True:
5814 
      (fname, ftype, fid) = iprot.readFieldBegin()
5815 
      if ftype == TType.STOP:
5816 
        break
5817 
      if fid == 0:
5818 
        if ftype == TType.STRUCT:
559 chandransh 5819 
          self.success = User()
94 ashish 5820 
          self.success.read(iprot)
5821 
        else:
5822 
          iprot.skip(ftype)
5823 
      elif fid == 1:
5824 
        if ftype == TType.STRUCT:
559 chandransh 5825 
          self.ucex = UserContextException()
5826 
          self.ucex.read(iprot)
94 ashish 5827 
        else:
5828 
          iprot.skip(ftype)
5829 
      else:
5830 
        iprot.skip(ftype)
5831 
      iprot.readFieldEnd()
5832 
    iprot.readStructEnd()
5833 
 
5834 
  def write(self, oprot):
5835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5837 
      return
5326 rajveer 5838 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5839 
    if self.success is not None:
94 ashish 5840 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5841 
      self.success.write(oprot)
5842 
      oprot.writeFieldEnd()
3431 rajveer 5843 
    if self.ucex is not None:
559 chandransh 5844 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5845 
      self.ucex.write(oprot)
94 ashish 5846 
      oprot.writeFieldEnd()
5847 
    oprot.writeFieldStop()
5848 
    oprot.writeStructEnd()
5849 
 
3431 rajveer 5850 
  def validate(self):
5851 
    return
5852 
 
5853 
 
94 ashish 5854 
  def __repr__(self):
5855 
    L = ['%s=%r' % (key, value)
5856 
      for key, value in self.__dict__.iteritems()]
5857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5858 
 
5859 
  def __eq__(self, other):
5860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5861 
 
5862 
  def __ne__(self, other):
5863 
    return not (self == other)
5864 
 
5326 rajveer 5865 
class updateUser_args:
94 ashish 5866 
  """
5867 
  Attributes:
5326 rajveer 5868 
   - user
94 ashish 5869 
  """
5870 
 
5871 
  thrift_spec = (
5872 
    None, # 0
5326 rajveer 5873 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5874 
  )
5875 
 
5326 rajveer 5876 
  def __init__(self, user=None,):
5877 
    self.user = user
94 ashish 5878 
 
5879 
  def read(self, iprot):
5880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5882 
      return
5883 
    iprot.readStructBegin()
5884 
    while True:
5885 
      (fname, ftype, fid) = iprot.readFieldBegin()
5886 
      if ftype == TType.STOP:
5887 
        break
5888 
      if fid == 1:
5326 rajveer 5889 
        if ftype == TType.STRUCT:
5890 
          self.user = User()
5891 
          self.user.read(iprot)
94 ashish 5892 
        else:
5893 
          iprot.skip(ftype)
5894 
      else:
5895 
        iprot.skip(ftype)
5896 
      iprot.readFieldEnd()
5897 
    iprot.readStructEnd()
5898 
 
5899 
  def write(self, oprot):
5900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5902 
      return
5326 rajveer 5903 
    oprot.writeStructBegin('updateUser_args')
5904 
    if self.user is not None:
5905 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5906 
      self.user.write(oprot)
94 ashish 5907 
      oprot.writeFieldEnd()
5908 
    oprot.writeFieldStop()
5909 
    oprot.writeStructEnd()
5910 
 
3431 rajveer 5911 
  def validate(self):
5912 
    return
5913 
 
5914 
 
94 ashish 5915 
  def __repr__(self):
5916 
    L = ['%s=%r' % (key, value)
5917 
      for key, value in self.__dict__.iteritems()]
5918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5919 
 
5920 
  def __eq__(self, other):
5921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5922 
 
5923 
  def __ne__(self, other):
5924 
    return not (self == other)
5925 
 
5326 rajveer 5926 
class updateUser_result:
94 ashish 5927 
  """
5928 
  Attributes:
5929 
   - success
559 chandransh 5930 
   - ucex
94 ashish 5931 
  """
5932 
 
5933 
  thrift_spec = (
5326 rajveer 5934 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5935 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5936 
  )
5937 
 
559 chandransh 5938 
  def __init__(self, success=None, ucex=None,):
94 ashish 5939 
    self.success = success
559 chandransh 5940 
    self.ucex = ucex
94 ashish 5941 
 
5942 
  def read(self, iprot):
5943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5945 
      return
5946 
    iprot.readStructBegin()
5947 
    while True:
5948 
      (fname, ftype, fid) = iprot.readFieldBegin()
5949 
      if ftype == TType.STOP:
5950 
        break
5951 
      if fid == 0:
5326 rajveer 5952 
        if ftype == TType.STRUCT:
5953 
          self.success = User()
5954 
          self.success.read(iprot)
94 ashish 5955 
        else:
5956 
          iprot.skip(ftype)
5957 
      elif fid == 1:
5958 
        if ftype == TType.STRUCT:
559 chandransh 5959 
          self.ucex = UserContextException()
5960 
          self.ucex.read(iprot)
94 ashish 5961 
        else:
5962 
          iprot.skip(ftype)
5963 
      else:
5964 
        iprot.skip(ftype)
5965 
      iprot.readFieldEnd()
5966 
    iprot.readStructEnd()
5967 
 
5968 
  def write(self, oprot):
5969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5971 
      return
5326 rajveer 5972 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5973 
    if self.success is not None:
5326 rajveer 5974 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5975 
      self.success.write(oprot)
94 ashish 5976 
      oprot.writeFieldEnd()
3431 rajveer 5977 
    if self.ucex is not None:
559 chandransh 5978 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5979 
      self.ucex.write(oprot)
94 ashish 5980 
      oprot.writeFieldEnd()
5981 
    oprot.writeFieldStop()
5982 
    oprot.writeStructEnd()
5983 
 
3431 rajveer 5984 
  def validate(self):
5985 
    return
5986 
 
5987 
 
94 ashish 5988 
  def __repr__(self):
5989 
    L = ['%s=%r' % (key, value)
5990 
      for key, value in self.__dict__.iteritems()]
5991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5992 
 
5993 
  def __eq__(self, other):
5994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5995 
 
5996 
  def __ne__(self, other):
5997 
    return not (self == other)
5998 
 
559 chandransh 5999 
class authenticateUser_args:
94 ashish 6000 
  """
6001 
  Attributes:
6002 
   - email
6003 
   - password
6004 
  """
6005 
 
6006 
  thrift_spec = (
6007 
    None, # 0
6008 
    (1, TType.STRING, 'email', None, None, ), # 1
6009 
    (2, TType.STRING, 'password', None, None, ), # 2
6010 
  )
6011 
 
6012 
  def __init__(self, email=None, password=None,):
6013 
    self.email = email
6014 
    self.password = password
6015 
 
6016 
  def read(self, iprot):
6017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6019 
      return
6020 
    iprot.readStructBegin()
6021 
    while True:
6022 
      (fname, ftype, fid) = iprot.readFieldBegin()
6023 
      if ftype == TType.STOP:
6024 
        break
6025 
      if fid == 1:
6026 
        if ftype == TType.STRING:
6027 
          self.email = iprot.readString();
6028 
        else:
6029 
          iprot.skip(ftype)
6030 
      elif fid == 2:
6031 
        if ftype == TType.STRING:
6032 
          self.password = iprot.readString();
6033 
        else:
6034 
          iprot.skip(ftype)
6035 
      else:
6036 
        iprot.skip(ftype)
6037 
      iprot.readFieldEnd()
6038 
    iprot.readStructEnd()
6039 
 
6040 
  def write(self, oprot):
6041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6043 
      return
559 chandransh 6044 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6045 
    if self.email is not None:
94 ashish 6046 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6047 
      oprot.writeString(self.email)
6048 
      oprot.writeFieldEnd()
3431 rajveer 6049 
    if self.password is not None:
94 ashish 6050 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6051 
      oprot.writeString(self.password)
6052 
      oprot.writeFieldEnd()
6053 
    oprot.writeFieldStop()
6054 
    oprot.writeStructEnd()
6055 
 
3431 rajveer 6056 
  def validate(self):
6057 
    return
6058 
 
6059 
 
94 ashish 6060 
  def __repr__(self):
6061 
    L = ['%s=%r' % (key, value)
6062 
      for key, value in self.__dict__.iteritems()]
6063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6064 
 
6065 
  def __eq__(self, other):
6066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6067 
 
6068 
  def __ne__(self, other):
6069 
    return not (self == other)
6070 
 
559 chandransh 6071 
class authenticateUser_result:
94 ashish 6072 
  """
6073 
  Attributes:
6074 
   - success
559 chandransh 6075 
   - auex
94 ashish 6076 
  """
6077 
 
6078 
  thrift_spec = (
559 chandransh 6079 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6080 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6081 
  )
6082 
 
559 chandransh 6083 
  def __init__(self, success=None, auex=None,):
94 ashish 6084 
    self.success = success
559 chandransh 6085 
    self.auex = auex
94 ashish 6086 
 
6087 
  def read(self, iprot):
6088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6090 
      return
6091 
    iprot.readStructBegin()
6092 
    while True:
6093 
      (fname, ftype, fid) = iprot.readFieldBegin()
6094 
      if ftype == TType.STOP:
6095 
        break
6096 
      if fid == 0:
6097 
        if ftype == TType.STRUCT:
559 chandransh 6098 
          self.success = User()
94 ashish 6099 
          self.success.read(iprot)
6100 
        else:
6101 
          iprot.skip(ftype)
6102 
      elif fid == 1:
6103 
        if ftype == TType.STRUCT:
559 chandransh 6104 
          self.auex = AuthenticationException()
6105 
          self.auex.read(iprot)
94 ashish 6106 
        else:
6107 
          iprot.skip(ftype)
6108 
      else:
6109 
        iprot.skip(ftype)
6110 
      iprot.readFieldEnd()
6111 
    iprot.readStructEnd()
6112 
 
6113 
  def write(self, oprot):
6114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6116 
      return
559 chandransh 6117 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6118 
    if self.success is not None:
94 ashish 6119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6120 
      self.success.write(oprot)
6121 
      oprot.writeFieldEnd()
3431 rajveer 6122 
    if self.auex is not None:
559 chandransh 6123 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6124 
      self.auex.write(oprot)
94 ashish 6125 
      oprot.writeFieldEnd()
6126 
    oprot.writeFieldStop()
6127 
    oprot.writeStructEnd()
6128 
 
3431 rajveer 6129 
  def validate(self):
6130 
    return
6131 
 
6132 
 
94 ashish 6133 
  def __repr__(self):
6134 
    L = ['%s=%r' % (key, value)
6135 
      for key, value in self.__dict__.iteritems()]
6136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6137 
 
6138 
  def __eq__(self, other):
6139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6140 
 
6141 
  def __ne__(self, other):
6142 
    return not (self == other)
6143 
 
559 chandransh 6144 
class userExists_args:
122 ashish 6145 
  """
6146 
  Attributes:
559 chandransh 6147 
   - email
122 ashish 6148 
  """
6149 
 
6150 
  thrift_spec = (
6151 
    None, # 0
559 chandransh 6152 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6153 
  )
6154 
 
559 chandransh 6155 
  def __init__(self, email=None,):
6156 
    self.email = email
122 ashish 6157 
 
6158 
  def read(self, iprot):
6159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6161 
      return
6162 
    iprot.readStructBegin()
6163 
    while True:
6164 
      (fname, ftype, fid) = iprot.readFieldBegin()
6165 
      if ftype == TType.STOP:
6166 
        break
6167 
      if fid == 1:
6168 
        if ftype == TType.STRING:
559 chandransh 6169 
          self.email = iprot.readString();
122 ashish 6170 
        else:
6171 
          iprot.skip(ftype)
559 chandransh 6172 
      else:
6173 
        iprot.skip(ftype)
6174 
      iprot.readFieldEnd()
6175 
    iprot.readStructEnd()
6176 
 
6177 
  def write(self, oprot):
6178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6180 
      return
6181 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6182 
    if self.email is not None:
559 chandransh 6183 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6184 
      oprot.writeString(self.email)
6185 
      oprot.writeFieldEnd()
6186 
    oprot.writeFieldStop()
6187 
    oprot.writeStructEnd()
6188 
 
3431 rajveer 6189 
  def validate(self):
6190 
    return
6191 
 
6192 
 
559 chandransh 6193 
  def __repr__(self):
6194 
    L = ['%s=%r' % (key, value)
6195 
      for key, value in self.__dict__.iteritems()]
6196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6197 
 
6198 
  def __eq__(self, other):
6199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6200 
 
6201 
  def __ne__(self, other):
6202 
    return not (self == other)
6203 
 
6204 
class userExists_result:
6205 
  """
6206 
  Attributes:
6207 
   - success
6208 
   - ucx
6209 
  """
6210 
 
6211 
  thrift_spec = (
6212 
    (0, TType.BOOL, 'success', None, None, ), # 0
6213 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6214 
  )
6215 
 
6216 
  def __init__(self, success=None, ucx=None,):
6217 
    self.success = success
6218 
    self.ucx = ucx
6219 
 
6220 
  def read(self, iprot):
6221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6223 
      return
6224 
    iprot.readStructBegin()
6225 
    while True:
6226 
      (fname, ftype, fid) = iprot.readFieldBegin()
6227 
      if ftype == TType.STOP:
6228 
        break
6229 
      if fid == 0:
6230 
        if ftype == TType.BOOL:
6231 
          self.success = iprot.readBool();
6232 
        else:
6233 
          iprot.skip(ftype)
6234 
      elif fid == 1:
6235 
        if ftype == TType.STRUCT:
6236 
          self.ucx = UserContextException()
6237 
          self.ucx.read(iprot)
6238 
        else:
6239 
          iprot.skip(ftype)
6240 
      else:
6241 
        iprot.skip(ftype)
6242 
      iprot.readFieldEnd()
6243 
    iprot.readStructEnd()
6244 
 
6245 
  def write(self, oprot):
6246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6248 
      return
6249 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6250 
    if self.success is not None:
559 chandransh 6251 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6252 
      oprot.writeBool(self.success)
6253 
      oprot.writeFieldEnd()
3431 rajveer 6254 
    if self.ucx is not None:
559 chandransh 6255 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6256 
      self.ucx.write(oprot)
6257 
      oprot.writeFieldEnd()
6258 
    oprot.writeFieldStop()
6259 
    oprot.writeStructEnd()
6260 
 
3431 rajveer 6261 
  def validate(self):
6262 
    return
6263 
 
6264 
 
559 chandransh 6265 
  def __repr__(self):
6266 
    L = ['%s=%r' % (key, value)
6267 
      for key, value in self.__dict__.iteritems()]
6268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6269 
 
6270 
  def __eq__(self, other):
6271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6272 
 
6273 
  def __ne__(self, other):
6274 
    return not (self == other)
6275 
 
6276 
class addAddressForUser_args:
6277 
  """
6278 
  Attributes:
6279 
   - userId
6280 
   - address
6281 
   - setDefault
6282 
  """
6283 
 
6284 
  thrift_spec = (
6285 
    None, # 0
6286 
    (1, TType.I64, 'userId', None, None, ), # 1
6287 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6288 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6289 
  )
6290 
 
567 rajveer 6291 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6292 
    self.userId = userId
6293 
    self.address = address
6294 
    self.setDefault = setDefault
6295 
 
6296 
  def read(self, iprot):
6297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6299 
      return
6300 
    iprot.readStructBegin()
6301 
    while True:
6302 
      (fname, ftype, fid) = iprot.readFieldBegin()
6303 
      if ftype == TType.STOP:
6304 
        break
6305 
      if fid == 1:
6306 
        if ftype == TType.I64:
6307 
          self.userId = iprot.readI64();
6308 
        else:
6309 
          iprot.skip(ftype)
122 ashish 6310 
      elif fid == 2:
559 chandransh 6311 
        if ftype == TType.STRUCT:
6312 
          self.address = Address()
6313 
          self.address.read(iprot)
122 ashish 6314 
        else:
6315 
          iprot.skip(ftype)
6316 
      elif fid == 3:
6317 
        if ftype == TType.BOOL:
559 chandransh 6318 
          self.setDefault = iprot.readBool();
122 ashish 6319 
        else:
6320 
          iprot.skip(ftype)
6321 
      else:
6322 
        iprot.skip(ftype)
6323 
      iprot.readFieldEnd()
6324 
    iprot.readStructEnd()
6325 
 
6326 
  def write(self, oprot):
6327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6329 
      return
559 chandransh 6330 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6331 
    if self.userId is not None:
559 chandransh 6332 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6333 
      oprot.writeI64(self.userId)
122 ashish 6334 
      oprot.writeFieldEnd()
3431 rajveer 6335 
    if self.address is not None:
559 chandransh 6336 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6337 
      self.address.write(oprot)
122 ashish 6338 
      oprot.writeFieldEnd()
3431 rajveer 6339 
    if self.setDefault is not None:
567 rajveer 6340 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6341 
      oprot.writeBool(self.setDefault)
6342 
      oprot.writeFieldEnd()
122 ashish 6343 
    oprot.writeFieldStop()
6344 
    oprot.writeStructEnd()
6345 
 
3431 rajveer 6346 
  def validate(self):
6347 
    return
6348 
 
6349 
 
122 ashish 6350 
  def __repr__(self):
6351 
    L = ['%s=%r' % (key, value)
6352 
      for key, value in self.__dict__.iteritems()]
6353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6354 
 
6355 
  def __eq__(self, other):
6356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6357 
 
6358 
  def __ne__(self, other):
6359 
    return not (self == other)
6360 
 
559 chandransh 6361 
class addAddressForUser_result:
122 ashish 6362 
  """
6363 
  Attributes:
6364 
   - success
559 chandransh 6365 
   - ucx
122 ashish 6366 
  """
6367 
 
6368 
  thrift_spec = (
567 rajveer 6369 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6370 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6371 
  )
6372 
 
559 chandransh 6373 
  def __init__(self, success=None, ucx=None,):
122 ashish 6374 
    self.success = success
559 chandransh 6375 
    self.ucx = ucx
122 ashish 6376 
 
6377 
  def read(self, iprot):
6378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6380 
      return
6381 
    iprot.readStructBegin()
6382 
    while True:
6383 
      (fname, ftype, fid) = iprot.readFieldBegin()
6384 
      if ftype == TType.STOP:
6385 
        break
6386 
      if fid == 0:
567 rajveer 6387 
        if ftype == TType.I64:
6388 
          self.success = iprot.readI64();
122 ashish 6389 
        else:
6390 
          iprot.skip(ftype)
6391 
      elif fid == 1:
6392 
        if ftype == TType.STRUCT:
559 chandransh 6393 
          self.ucx = UserContextException()
6394 
          self.ucx.read(iprot)
122 ashish 6395 
        else:
6396 
          iprot.skip(ftype)
6397 
      else:
6398 
        iprot.skip(ftype)
6399 
      iprot.readFieldEnd()
6400 
    iprot.readStructEnd()
6401 
 
6402 
  def write(self, oprot):
6403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6405 
      return
559 chandransh 6406 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6407 
    if self.success is not None:
567 rajveer 6408 
      oprot.writeFieldBegin('success', TType.I64, 0)
6409 
      oprot.writeI64(self.success)
122 ashish 6410 
      oprot.writeFieldEnd()
3431 rajveer 6411 
    if self.ucx is not None:
559 chandransh 6412 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6413 
      self.ucx.write(oprot)
122 ashish 6414 
      oprot.writeFieldEnd()
6415 
    oprot.writeFieldStop()
6416 
    oprot.writeStructEnd()
6417 
 
3431 rajveer 6418 
  def validate(self):
6419 
    return
6420 
 
6421 
 
122 ashish 6422 
  def __repr__(self):
6423 
    L = ['%s=%r' % (key, value)
6424 
      for key, value in self.__dict__.iteritems()]
6425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6426 
 
6427 
  def __eq__(self, other):
6428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6429 
 
6430 
  def __ne__(self, other):
6431 
    return not (self == other)
6432 
 
559 chandransh 6433 
class removeAddressForUser_args:
94 ashish 6434 
  """
6435 
  Attributes:
559 chandransh 6436 
   - userid
6437 
   - addressId
94 ashish 6438 
  """
6439 
 
6440 
  thrift_spec = (
6441 
    None, # 0
559 chandransh 6442 
    (1, TType.I64, 'userid', None, None, ), # 1
6443 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6444 
  )
6445 
 
559 chandransh 6446 
  def __init__(self, userid=None, addressId=None,):
6447 
    self.userid = userid
6448 
    self.addressId = addressId
94 ashish 6449 
 
6450 
  def read(self, iprot):
6451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6453 
      return
6454 
    iprot.readStructBegin()
6455 
    while True:
6456 
      (fname, ftype, fid) = iprot.readFieldBegin()
6457 
      if ftype == TType.STOP:
6458 
        break
6459 
      if fid == 1:
559 chandransh 6460 
        if ftype == TType.I64:
6461 
          self.userid = iprot.readI64();
94 ashish 6462 
        else:
6463 
          iprot.skip(ftype)
559 chandransh 6464 
      elif fid == 2:
6465 
        if ftype == TType.I64:
6466 
          self.addressId = iprot.readI64();
6467 
        else:
6468 
          iprot.skip(ftype)
94 ashish 6469 
      else:
6470 
        iprot.skip(ftype)
6471 
      iprot.readFieldEnd()
6472 
    iprot.readStructEnd()
6473 
 
6474 
  def write(self, oprot):
6475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6477 
      return
559 chandransh 6478 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6479 
    if self.userid is not None:
559 chandransh 6480 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6481 
      oprot.writeI64(self.userid)
94 ashish 6482 
      oprot.writeFieldEnd()
3431 rajveer 6483 
    if self.addressId is not None:
559 chandransh 6484 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6485 
      oprot.writeI64(self.addressId)
6486 
      oprot.writeFieldEnd()
94 ashish 6487 
    oprot.writeFieldStop()
6488 
    oprot.writeStructEnd()
6489 
 
3431 rajveer 6490 
  def validate(self):
6491 
    return
6492 
 
6493 
 
94 ashish 6494 
  def __repr__(self):
6495 
    L = ['%s=%r' % (key, value)
6496 
      for key, value in self.__dict__.iteritems()]
6497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6498 
 
6499 
  def __eq__(self, other):
6500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6501 
 
6502 
  def __ne__(self, other):
6503 
    return not (self == other)
6504 
 
559 chandransh 6505 
class removeAddressForUser_result:
94 ashish 6506 
  """
6507 
  Attributes:
6508 
   - success
6509 
   - ucx
6510 
  """
6511 
 
6512 
  thrift_spec = (
6513 
    (0, TType.BOOL, 'success', None, None, ), # 0
6514 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6515 
  )
6516 
 
6517 
  def __init__(self, success=None, ucx=None,):
6518 
    self.success = success
6519 
    self.ucx = ucx
6520 
 
6521 
  def read(self, iprot):
6522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6524 
      return
6525 
    iprot.readStructBegin()
6526 
    while True:
6527 
      (fname, ftype, fid) = iprot.readFieldBegin()
6528 
      if ftype == TType.STOP:
6529 
        break
6530 
      if fid == 0:
6531 
        if ftype == TType.BOOL:
6532 
          self.success = iprot.readBool();
6533 
        else:
6534 
          iprot.skip(ftype)
6535 
      elif fid == 1:
6536 
        if ftype == TType.STRUCT:
6537 
          self.ucx = UserContextException()
6538 
          self.ucx.read(iprot)
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      else:
6542 
        iprot.skip(ftype)
6543 
      iprot.readFieldEnd()
6544 
    iprot.readStructEnd()
6545 
 
6546 
  def write(self, oprot):
6547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6549 
      return
559 chandransh 6550 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6551 
    if self.success is not None:
94 ashish 6552 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6553 
      oprot.writeBool(self.success)
6554 
      oprot.writeFieldEnd()
3431 rajveer 6555 
    if self.ucx is not None:
94 ashish 6556 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6557 
      self.ucx.write(oprot)
6558 
      oprot.writeFieldEnd()
6559 
    oprot.writeFieldStop()
6560 
    oprot.writeStructEnd()
6561 
 
3431 rajveer 6562 
  def validate(self):
6563 
    return
6564 
 
6565 
 
94 ashish 6566 
  def __repr__(self):
6567 
    L = ['%s=%r' % (key, value)
6568 
      for key, value in self.__dict__.iteritems()]
6569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6570 
 
6571 
  def __eq__(self, other):
6572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6573 
 
6574 
  def __ne__(self, other):
6575 
    return not (self == other)
6576 
 
559 chandransh 6577 
class setUserAsLoggedIn_args:
94 ashish 6578 
  """
6579 
  Attributes:
559 chandransh 6580 
   - userId
94 ashish 6581 
   - timestamp
6582 
  """
6583 
 
6584 
  thrift_spec = (
6585 
    None, # 0
559 chandransh 6586 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6587 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6588 
  )
6589 
 
559 chandransh 6590 
  def __init__(self, userId=None, timestamp=None,):
6591 
    self.userId = userId
94 ashish 6592 
    self.timestamp = timestamp
6593 
 
6594 
  def read(self, iprot):
6595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6597 
      return
6598 
    iprot.readStructBegin()
6599 
    while True:
6600 
      (fname, ftype, fid) = iprot.readFieldBegin()
6601 
      if ftype == TType.STOP:
6602 
        break
6603 
      if fid == 1:
559 chandransh 6604 
        if ftype == TType.I64:
6605 
          self.userId = iprot.readI64();
94 ashish 6606 
        else:
6607 
          iprot.skip(ftype)
6608 
      elif fid == 2:
6609 
        if ftype == TType.I64:
6610 
          self.timestamp = iprot.readI64();
6611 
        else:
6612 
          iprot.skip(ftype)
6613 
      else:
6614 
        iprot.skip(ftype)
6615 
      iprot.readFieldEnd()
6616 
    iprot.readStructEnd()
6617 
 
6618 
  def write(self, oprot):
6619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6621 
      return
559 chandransh 6622 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6623 
    if self.userId is not None:
559 chandransh 6624 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6625 
      oprot.writeI64(self.userId)
94 ashish 6626 
      oprot.writeFieldEnd()
3431 rajveer 6627 
    if self.timestamp is not None:
94 ashish 6628 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6629 
      oprot.writeI64(self.timestamp)
6630 
      oprot.writeFieldEnd()
6631 
    oprot.writeFieldStop()
6632 
    oprot.writeStructEnd()
6633 
 
3431 rajveer 6634 
  def validate(self):
6635 
    return
6636 
 
6637 
 
94 ashish 6638 
  def __repr__(self):
6639 
    L = ['%s=%r' % (key, value)
6640 
      for key, value in self.__dict__.iteritems()]
6641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6642 
 
6643 
  def __eq__(self, other):
6644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6645 
 
6646 
  def __ne__(self, other):
6647 
    return not (self == other)
6648 
 
559 chandransh 6649 
class setUserAsLoggedIn_result:
94 ashish 6650 
  """
6651 
  Attributes:
6652 
   - success
6653 
   - ucx
6654 
  """
6655 
 
6656 
  thrift_spec = (
6657 
    (0, TType.BOOL, 'success', None, None, ), # 0
6658 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6659 
  )
6660 
 
6661 
  def __init__(self, success=None, ucx=None,):
6662 
    self.success = success
6663 
    self.ucx = ucx
6664 
 
6665 
  def read(self, iprot):
6666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6668 
      return
6669 
    iprot.readStructBegin()
6670 
    while True:
6671 
      (fname, ftype, fid) = iprot.readFieldBegin()
6672 
      if ftype == TType.STOP:
6673 
        break
6674 
      if fid == 0:
6675 
        if ftype == TType.BOOL:
6676 
          self.success = iprot.readBool();
6677 
        else:
6678 
          iprot.skip(ftype)
6679 
      elif fid == 1:
6680 
        if ftype == TType.STRUCT:
6681 
          self.ucx = UserContextException()
6682 
          self.ucx.read(iprot)
6683 
        else:
6684 
          iprot.skip(ftype)
6685 
      else:
6686 
        iprot.skip(ftype)
6687 
      iprot.readFieldEnd()
6688 
    iprot.readStructEnd()
6689 
 
6690 
  def write(self, oprot):
6691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6693 
      return
559 chandransh 6694 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6695 
    if self.success is not None:
94 ashish 6696 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6697 
      oprot.writeBool(self.success)
6698 
      oprot.writeFieldEnd()
3431 rajveer 6699 
    if self.ucx is not None:
94 ashish 6700 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6701 
      self.ucx.write(oprot)
6702 
      oprot.writeFieldEnd()
6703 
    oprot.writeFieldStop()
6704 
    oprot.writeStructEnd()
6705 
 
3431 rajveer 6706 
  def validate(self):
6707 
    return
6708 
 
6709 
 
94 ashish 6710 
  def __repr__(self):
6711 
    L = ['%s=%r' % (key, value)
6712 
      for key, value in self.__dict__.iteritems()]
6713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6714 
 
6715 
  def __eq__(self, other):
6716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6717 
 
6718 
  def __ne__(self, other):
6719 
    return not (self == other)
6720 
 
559 chandransh 6721 
class setUserAsLoggedOut_args:
94 ashish 6722 
  """
6723 
  Attributes:
6724 
   - userid
6725 
   - timestamp
6726 
  """
6727 
 
6728 
  thrift_spec = (
6729 
    None, # 0
559 chandransh 6730 
    (1, TType.I64, 'userid', None, None, ), # 1
6731 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6732 
  )
6733 
 
559 chandransh 6734 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6735 
    self.userid = userid
6736 
    self.timestamp = timestamp
6737 
 
6738 
  def read(self, iprot):
6739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6741 
      return
6742 
    iprot.readStructBegin()
6743 
    while True:
6744 
      (fname, ftype, fid) = iprot.readFieldBegin()
6745 
      if ftype == TType.STOP:
6746 
        break
6747 
      if fid == 1:
6748 
        if ftype == TType.I64:
6749 
          self.userid = iprot.readI64();
6750 
        else:
6751 
          iprot.skip(ftype)
559 chandransh 6752 
      elif fid == 2:
94 ashish 6753 
        if ftype == TType.I64:
6754 
          self.timestamp = iprot.readI64();
6755 
        else:
6756 
          iprot.skip(ftype)
6757 
      else:
6758 
        iprot.skip(ftype)
6759 
      iprot.readFieldEnd()
6760 
    iprot.readStructEnd()
6761 
 
6762 
  def write(self, oprot):
6763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6765 
      return
559 chandransh 6766 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6767 
    if self.userid is not None:
559 chandransh 6768 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6769 
      oprot.writeI64(self.userid)
6770 
      oprot.writeFieldEnd()
3431 rajveer 6771 
    if self.timestamp is not None:
559 chandransh 6772 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6773 
      oprot.writeI64(self.timestamp)
6774 
      oprot.writeFieldEnd()
6775 
    oprot.writeFieldStop()
6776 
    oprot.writeStructEnd()
6777 
 
3431 rajveer 6778 
  def validate(self):
6779 
    return
6780 
 
6781 
 
94 ashish 6782 
  def __repr__(self):
6783 
    L = ['%s=%r' % (key, value)
6784 
      for key, value in self.__dict__.iteritems()]
6785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6786 
 
6787 
  def __eq__(self, other):
6788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6789 
 
6790 
  def __ne__(self, other):
6791 
    return not (self == other)
6792 
 
559 chandransh 6793 
class setUserAsLoggedOut_result:
94 ashish 6794 
  """
6795 
  Attributes:
6796 
   - success
6797 
   - ucx
6798 
  """
6799 
 
6800 
  thrift_spec = (
6801 
    (0, TType.BOOL, 'success', None, None, ), # 0
6802 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6803 
  )
6804 
 
6805 
  def __init__(self, success=None, ucx=None,):
6806 
    self.success = success
6807 
    self.ucx = ucx
6808 
 
6809 
  def read(self, iprot):
6810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6812 
      return
6813 
    iprot.readStructBegin()
6814 
    while True:
6815 
      (fname, ftype, fid) = iprot.readFieldBegin()
6816 
      if ftype == TType.STOP:
6817 
        break
6818 
      if fid == 0:
6819 
        if ftype == TType.BOOL:
6820 
          self.success = iprot.readBool();
6821 
        else:
6822 
          iprot.skip(ftype)
6823 
      elif fid == 1:
6824 
        if ftype == TType.STRUCT:
6825 
          self.ucx = UserContextException()
6826 
          self.ucx.read(iprot)
6827 
        else:
6828 
          iprot.skip(ftype)
6829 
      else:
6830 
        iprot.skip(ftype)
6831 
      iprot.readFieldEnd()
6832 
    iprot.readStructEnd()
6833 
 
6834 
  def write(self, oprot):
6835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6837 
      return
559 chandransh 6838 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6839 
    if self.success is not None:
94 ashish 6840 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6841 
      oprot.writeBool(self.success)
6842 
      oprot.writeFieldEnd()
3431 rajveer 6843 
    if self.ucx is not None:
94 ashish 6844 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6845 
      self.ucx.write(oprot)
6846 
      oprot.writeFieldEnd()
6847 
    oprot.writeFieldStop()
6848 
    oprot.writeStructEnd()
6849 
 
3431 rajveer 6850 
  def validate(self):
6851 
    return
6852 
 
6853 
 
94 ashish 6854 
  def __repr__(self):
6855 
    L = ['%s=%r' % (key, value)
6856 
      for key, value in self.__dict__.iteritems()]
6857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6858 
 
6859 
  def __eq__(self, other):
6860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6861 
 
6862 
  def __ne__(self, other):
6863 
    return not (self == other)
6864 
 
559 chandransh 6865 
class setDefaultAddress_args:
94 ashish 6866 
  """
6867 
  Attributes:
6868 
   - userid
6869 
   - addressId
6870 
  """
6871 
 
6872 
  thrift_spec = (
6873 
    None, # 0
6874 
    (1, TType.I64, 'userid', None, None, ), # 1
6875 
    (2, TType.I64, 'addressId', None, None, ), # 2
6876 
  )
6877 
 
6878 
  def __init__(self, userid=None, addressId=None,):
6879 
    self.userid = userid
6880 
    self.addressId = addressId
6881 
 
6882 
  def read(self, iprot):
6883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6885 
      return
6886 
    iprot.readStructBegin()
6887 
    while True:
6888 
      (fname, ftype, fid) = iprot.readFieldBegin()
6889 
      if ftype == TType.STOP:
6890 
        break
6891 
      if fid == 1:
6892 
        if ftype == TType.I64:
6893 
          self.userid = iprot.readI64();
6894 
        else:
6895 
          iprot.skip(ftype)
6896 
      elif fid == 2:
6897 
        if ftype == TType.I64:
6898 
          self.addressId = iprot.readI64();
6899 
        else:
6900 
          iprot.skip(ftype)
6901 
      else:
6902 
        iprot.skip(ftype)
6903 
      iprot.readFieldEnd()
6904 
    iprot.readStructEnd()
6905 
 
6906 
  def write(self, oprot):
6907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6909 
      return
559 chandransh 6910 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6911 
    if self.userid is not None:
94 ashish 6912 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6913 
      oprot.writeI64(self.userid)
6914 
      oprot.writeFieldEnd()
3431 rajveer 6915 
    if self.addressId is not None:
94 ashish 6916 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6917 
      oprot.writeI64(self.addressId)
6918 
      oprot.writeFieldEnd()
6919 
    oprot.writeFieldStop()
6920 
    oprot.writeStructEnd()
6921 
 
3431 rajveer 6922 
  def validate(self):
6923 
    return
6924 
 
6925 
 
94 ashish 6926 
  def __repr__(self):
6927 
    L = ['%s=%r' % (key, value)
6928 
      for key, value in self.__dict__.iteritems()]
6929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6930 
 
6931 
  def __eq__(self, other):
6932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6933 
 
6934 
  def __ne__(self, other):
6935 
    return not (self == other)
6936 
 
559 chandransh 6937 
class setDefaultAddress_result:
94 ashish 6938 
  """
6939 
  Attributes:
6940 
   - success
6941 
   - ucx
6942 
  """
6943 
 
6944 
  thrift_spec = (
6945 
    (0, TType.BOOL, 'success', None, None, ), # 0
6946 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6947 
  )
6948 
 
6949 
  def __init__(self, success=None, ucx=None,):
6950 
    self.success = success
6951 
    self.ucx = ucx
6952 
 
6953 
  def read(self, iprot):
6954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6956 
      return
6957 
    iprot.readStructBegin()
6958 
    while True:
6959 
      (fname, ftype, fid) = iprot.readFieldBegin()
6960 
      if ftype == TType.STOP:
6961 
        break
6962 
      if fid == 0:
6963 
        if ftype == TType.BOOL:
6964 
          self.success = iprot.readBool();
6965 
        else:
6966 
          iprot.skip(ftype)
6967 
      elif fid == 1:
6968 
        if ftype == TType.STRUCT:
6969 
          self.ucx = UserContextException()
6970 
          self.ucx.read(iprot)
6971 
        else:
6972 
          iprot.skip(ftype)
6973 
      else:
6974 
        iprot.skip(ftype)
6975 
      iprot.readFieldEnd()
6976 
    iprot.readStructEnd()
6977 
 
6978 
  def write(self, oprot):
6979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6981 
      return
559 chandransh 6982 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6983 
    if self.success is not None:
94 ashish 6984 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6985 
      oprot.writeBool(self.success)
6986 
      oprot.writeFieldEnd()
3431 rajveer 6987 
    if self.ucx is not None:
94 ashish 6988 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6989 
      self.ucx.write(oprot)
6990 
      oprot.writeFieldEnd()
6991 
    oprot.writeFieldStop()
6992 
    oprot.writeStructEnd()
6993 
 
3431 rajveer 6994 
  def validate(self):
6995 
    return
6996 
 
6997 
 
94 ashish 6998 
  def __repr__(self):
6999 
    L = ['%s=%r' % (key, value)
7000 
      for key, value in self.__dict__.iteritems()]
7001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7002 
 
7003 
  def __eq__(self, other):
7004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7005 
 
7006 
  def __ne__(self, other):
7007 
    return not (self == other)
7008 
 
559 chandransh 7009 
class updatePassword_args:
94 ashish 7010 
  """
7011 
  Attributes:
559 chandransh 7012 
   - userid
594 rajveer 7013 
   - oldPassword
7014 
   - newPassword
94 ashish 7015 
  """
7016 
 
7017 
  thrift_spec = (
7018 
    None, # 0
559 chandransh 7019 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7020 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7021 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7022 
  )
7023 
 
594 rajveer 7024 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7025 
    self.userid = userid
594 rajveer 7026 
    self.oldPassword = oldPassword
7027 
    self.newPassword = newPassword
94 ashish 7028 
 
7029 
  def read(self, iprot):
7030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7032 
      return
7033 
    iprot.readStructBegin()
7034 
    while True:
7035 
      (fname, ftype, fid) = iprot.readFieldBegin()
7036 
      if ftype == TType.STOP:
7037 
        break
7038 
      if fid == 1:
7039 
        if ftype == TType.I64:
559 chandransh 7040 
          self.userid = iprot.readI64();
94 ashish 7041 
        else:
7042 
          iprot.skip(ftype)
7043 
      elif fid == 2:
559 chandransh 7044 
        if ftype == TType.STRING:
594 rajveer 7045 
          self.oldPassword = iprot.readString();
94 ashish 7046 
        else:
7047 
          iprot.skip(ftype)
594 rajveer 7048 
      elif fid == 3:
7049 
        if ftype == TType.STRING:
7050 
          self.newPassword = iprot.readString();
7051 
        else:
7052 
          iprot.skip(ftype)
94 ashish 7053 
      else:
7054 
        iprot.skip(ftype)
7055 
      iprot.readFieldEnd()
7056 
    iprot.readStructEnd()
7057 
 
7058 
  def write(self, oprot):
7059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7061 
      return
559 chandransh 7062 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7063 
    if self.userid is not None:
559 chandransh 7064 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7065 
      oprot.writeI64(self.userid)
94 ashish 7066 
      oprot.writeFieldEnd()
3431 rajveer 7067 
    if self.oldPassword is not None:
594 rajveer 7068 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7069 
      oprot.writeString(self.oldPassword)
94 ashish 7070 
      oprot.writeFieldEnd()
3431 rajveer 7071 
    if self.newPassword is not None:
594 rajveer 7072 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7073 
      oprot.writeString(self.newPassword)
7074 
      oprot.writeFieldEnd()
94 ashish 7075 
    oprot.writeFieldStop()
7076 
    oprot.writeStructEnd()
7077 
 
3431 rajveer 7078 
  def validate(self):
7079 
    return
7080 
 
7081 
 
94 ashish 7082 
  def __repr__(self):
7083 
    L = ['%s=%r' % (key, value)
7084 
      for key, value in self.__dict__.iteritems()]
7085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7086 
 
7087 
  def __eq__(self, other):
7088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7089 
 
7090 
  def __ne__(self, other):
7091 
    return not (self == other)
7092 
 
559 chandransh 7093 
class updatePassword_result:
94 ashish 7094 
  """
7095 
  Attributes:
7096 
   - success
7097 
   - ucx
7098 
  """
7099 
 
7100 
  thrift_spec = (
7101 
    (0, TType.BOOL, 'success', None, None, ), # 0
7102 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7103 
  )
7104 
 
7105 
  def __init__(self, success=None, ucx=None,):
7106 
    self.success = success
7107 
    self.ucx = ucx
7108 
 
7109 
  def read(self, iprot):
7110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7112 
      return
7113 
    iprot.readStructBegin()
7114 
    while True:
7115 
      (fname, ftype, fid) = iprot.readFieldBegin()
7116 
      if ftype == TType.STOP:
7117 
        break
7118 
      if fid == 0:
7119 
        if ftype == TType.BOOL:
7120 
          self.success = iprot.readBool();
7121 
        else:
7122 
          iprot.skip(ftype)
7123 
      elif fid == 1:
7124 
        if ftype == TType.STRUCT:
7125 
          self.ucx = UserContextException()
7126 
          self.ucx.read(iprot)
7127 
        else:
7128 
          iprot.skip(ftype)
7129 
      else:
7130 
        iprot.skip(ftype)
7131 
      iprot.readFieldEnd()
7132 
    iprot.readStructEnd()
7133 
 
7134 
  def write(self, oprot):
7135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7137 
      return
559 chandransh 7138 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7139 
    if self.success is not None:
94 ashish 7140 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7141 
      oprot.writeBool(self.success)
7142 
      oprot.writeFieldEnd()
3431 rajveer 7143 
    if self.ucx is not None:
94 ashish 7144 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7145 
      self.ucx.write(oprot)
7146 
      oprot.writeFieldEnd()
7147 
    oprot.writeFieldStop()
7148 
    oprot.writeStructEnd()
7149 
 
3431 rajveer 7150 
  def validate(self):
7151 
    return
7152 
 
7153 
 
94 ashish 7154 
  def __repr__(self):
7155 
    L = ['%s=%r' % (key, value)
7156 
      for key, value in self.__dict__.iteritems()]
7157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7158 
 
7159 
  def __eq__(self, other):
7160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7161 
 
7162 
  def __ne__(self, other):
7163 
    return not (self == other)
7164 
 
581 rajveer 7165 
class forgotPassword_args:
7166 
  """
7167 
  Attributes:
7168 
   - email
884 rajveer 7169 
   - newPassword
581 rajveer 7170 
  """
7171 
 
7172 
  thrift_spec = (
7173 
    None, # 0
7174 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7175 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7176 
  )
7177 
 
884 rajveer 7178 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7179 
    self.email = email
884 rajveer 7180 
    self.newPassword = newPassword
581 rajveer 7181 
 
7182 
  def read(self, iprot):
7183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7185 
      return
7186 
    iprot.readStructBegin()
7187 
    while True:
7188 
      (fname, ftype, fid) = iprot.readFieldBegin()
7189 
      if ftype == TType.STOP:
7190 
        break
7191 
      if fid == 1:
7192 
        if ftype == TType.STRING:
7193 
          self.email = iprot.readString();
7194 
        else:
7195 
          iprot.skip(ftype)
884 rajveer 7196 
      elif fid == 2:
7197 
        if ftype == TType.STRING:
7198 
          self.newPassword = iprot.readString();
7199 
        else:
7200 
          iprot.skip(ftype)
581 rajveer 7201 
      else:
7202 
        iprot.skip(ftype)
7203 
      iprot.readFieldEnd()
7204 
    iprot.readStructEnd()
7205 
 
7206 
  def write(self, oprot):
7207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7209 
      return
7210 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7211 
    if self.email is not None:
581 rajveer 7212 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7213 
      oprot.writeString(self.email)
7214 
      oprot.writeFieldEnd()
3431 rajveer 7215 
    if self.newPassword is not None:
884 rajveer 7216 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7217 
      oprot.writeString(self.newPassword)
7218 
      oprot.writeFieldEnd()
581 rajveer 7219 
    oprot.writeFieldStop()
7220 
    oprot.writeStructEnd()
7221 
 
3431 rajveer 7222 
  def validate(self):
7223 
    return
7224 
 
7225 
 
581 rajveer 7226 
  def __repr__(self):
7227 
    L = ['%s=%r' % (key, value)
7228 
      for key, value in self.__dict__.iteritems()]
7229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7230 
 
7231 
  def __eq__(self, other):
7232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7233 
 
7234 
  def __ne__(self, other):
7235 
    return not (self == other)
7236 
 
7237 
class forgotPassword_result:
7238 
  """
7239 
  Attributes:
7240 
   - success
7241 
   - ucx
7242 
  """
7243 
 
7244 
  thrift_spec = (
7245 
    (0, TType.BOOL, 'success', None, None, ), # 0
7246 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7247 
  )
7248 
 
7249 
  def __init__(self, success=None, ucx=None,):
7250 
    self.success = success
7251 
    self.ucx = ucx
7252 
 
7253 
  def read(self, iprot):
7254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7256 
      return
7257 
    iprot.readStructBegin()
7258 
    while True:
7259 
      (fname, ftype, fid) = iprot.readFieldBegin()
7260 
      if ftype == TType.STOP:
7261 
        break
7262 
      if fid == 0:
7263 
        if ftype == TType.BOOL:
7264 
          self.success = iprot.readBool();
7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 1:
7268 
        if ftype == TType.STRUCT:
7269 
          self.ucx = UserContextException()
7270 
          self.ucx.read(iprot)
7271 
        else:
7272 
          iprot.skip(ftype)
7273 
      else:
7274 
        iprot.skip(ftype)
7275 
      iprot.readFieldEnd()
7276 
    iprot.readStructEnd()
7277 
 
7278 
  def write(self, oprot):
7279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7281 
      return
7282 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7283 
    if self.success is not None:
581 rajveer 7284 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7285 
      oprot.writeBool(self.success)
7286 
      oprot.writeFieldEnd()
3431 rajveer 7287 
    if self.ucx is not None:
581 rajveer 7288 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7289 
      self.ucx.write(oprot)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
3431 rajveer 7294 
  def validate(self):
7295 
    return
7296 
 
7297 
 
581 rajveer 7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
594 rajveer 7309 
class getAllAddressesForUser_args:
7310 
  """
7311 
  Attributes:
7312 
   - userId
7313 
  """
7314 
 
7315 
  thrift_spec = (
7316 
    None, # 0
7317 
    (1, TType.I64, 'userId', None, None, ), # 1
7318 
  )
7319 
 
7320 
  def __init__(self, userId=None,):
7321 
    self.userId = userId
7322 
 
7323 
  def read(self, iprot):
7324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7326 
      return
7327 
    iprot.readStructBegin()
7328 
    while True:
7329 
      (fname, ftype, fid) = iprot.readFieldBegin()
7330 
      if ftype == TType.STOP:
7331 
        break
7332 
      if fid == 1:
7333 
        if ftype == TType.I64:
7334 
          self.userId = iprot.readI64();
7335 
        else:
7336 
          iprot.skip(ftype)
7337 
      else:
7338 
        iprot.skip(ftype)
7339 
      iprot.readFieldEnd()
7340 
    iprot.readStructEnd()
7341 
 
7342 
  def write(self, oprot):
7343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7345 
      return
7346 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7347 
    if self.userId is not None:
594 rajveer 7348 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7349 
      oprot.writeI64(self.userId)
7350 
      oprot.writeFieldEnd()
7351 
    oprot.writeFieldStop()
7352 
    oprot.writeStructEnd()
7353 
 
3431 rajveer 7354 
  def validate(self):
7355 
    return
7356 
 
7357 
 
594 rajveer 7358 
  def __repr__(self):
7359 
    L = ['%s=%r' % (key, value)
7360 
      for key, value in self.__dict__.iteritems()]
7361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7362 
 
7363 
  def __eq__(self, other):
7364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7365 
 
7366 
  def __ne__(self, other):
7367 
    return not (self == other)
7368 
 
7369 
class getAllAddressesForUser_result:
7370 
  """
7371 
  Attributes:
7372 
   - success
7373 
   - ucx
7374 
  """
7375 
 
7376 
  thrift_spec = (
7377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7378 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7379 
  )
7380 
 
7381 
  def __init__(self, success=None, ucx=None,):
7382 
    self.success = success
7383 
    self.ucx = ucx
7384 
 
7385 
  def read(self, iprot):
7386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7388 
      return
7389 
    iprot.readStructBegin()
7390 
    while True:
7391 
      (fname, ftype, fid) = iprot.readFieldBegin()
7392 
      if ftype == TType.STOP:
7393 
        break
7394 
      if fid == 0:
7395 
        if ftype == TType.LIST:
7396 
          self.success = []
11592 amit.gupta 7397 
          (_etype100, _size97) = iprot.readListBegin()
7398 
          for _i101 in xrange(_size97):
7399 
            _elem102 = Address()
7400 
            _elem102.read(iprot)
7401 
            self.success.append(_elem102)
594 rajveer 7402 
          iprot.readListEnd()
7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      elif fid == 1:
7406 
        if ftype == TType.STRUCT:
7407 
          self.ucx = UserContextException()
7408 
          self.ucx.read(iprot)
7409 
        else:
7410 
          iprot.skip(ftype)
7411 
      else:
7412 
        iprot.skip(ftype)
7413 
      iprot.readFieldEnd()
7414 
    iprot.readStructEnd()
7415 
 
7416 
  def write(self, oprot):
7417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7419 
      return
7420 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7421 
    if self.success is not None:
594 rajveer 7422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7424 
      for iter103 in self.success:
7425 
        iter103.write(oprot)
594 rajveer 7426 
      oprot.writeListEnd()
7427 
      oprot.writeFieldEnd()
3431 rajveer 7428 
    if self.ucx is not None:
594 rajveer 7429 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7430 
      self.ucx.write(oprot)
7431 
      oprot.writeFieldEnd()
7432 
    oprot.writeFieldStop()
7433 
    oprot.writeStructEnd()
7434 
 
3431 rajveer 7435 
  def validate(self):
7436 
    return
7437 
 
7438 
 
594 rajveer 7439 
  def __repr__(self):
7440 
    L = ['%s=%r' % (key, value)
7441 
      for key, value in self.__dict__.iteritems()]
7442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7443 
 
7444 
  def __eq__(self, other):
7445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7446 
 
7447 
  def __ne__(self, other):
7448 
    return not (self == other)
7449 
 
1894 vikas 7450 
class getAddressById_args:
7451 
  """
7452 
  Attributes:
7453 
   - addressId
7454 
  """
7455 
 
7456 
  thrift_spec = (
7457 
    None, # 0
7458 
    (1, TType.I64, 'addressId', None, None, ), # 1
7459 
  )
7460 
 
7461 
  def __init__(self, addressId=None,):
7462 
    self.addressId = addressId
7463 
 
7464 
  def read(self, iprot):
7465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7467 
      return
7468 
    iprot.readStructBegin()
7469 
    while True:
7470 
      (fname, ftype, fid) = iprot.readFieldBegin()
7471 
      if ftype == TType.STOP:
7472 
        break
7473 
      if fid == 1:
7474 
        if ftype == TType.I64:
7475 
          self.addressId = iprot.readI64();
7476 
        else:
7477 
          iprot.skip(ftype)
7478 
      else:
7479 
        iprot.skip(ftype)
7480 
      iprot.readFieldEnd()
7481 
    iprot.readStructEnd()
7482 
 
7483 
  def write(self, oprot):
7484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7486 
      return
7487 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7488 
    if self.addressId is not None:
1894 vikas 7489 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7490 
      oprot.writeI64(self.addressId)
7491 
      oprot.writeFieldEnd()
7492 
    oprot.writeFieldStop()
7493 
    oprot.writeStructEnd()
7494 
 
3431 rajveer 7495 
  def validate(self):
7496 
    return
7497 
 
7498 
 
1894 vikas 7499 
  def __repr__(self):
7500 
    L = ['%s=%r' % (key, value)
7501 
      for key, value in self.__dict__.iteritems()]
7502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7503 
 
7504 
  def __eq__(self, other):
7505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7506 
 
7507 
  def __ne__(self, other):
7508 
    return not (self == other)
7509 
 
7510 
class getAddressById_result:
7511 
  """
7512 
  Attributes:
7513 
   - success
7514 
   - ucx
7515 
  """
7516 
 
7517 
  thrift_spec = (
7518 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7519 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7520 
  )
7521 
 
7522 
  def __init__(self, success=None, ucx=None,):
7523 
    self.success = success
7524 
    self.ucx = ucx
7525 
 
7526 
  def read(self, iprot):
7527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7529 
      return
7530 
    iprot.readStructBegin()
7531 
    while True:
7532 
      (fname, ftype, fid) = iprot.readFieldBegin()
7533 
      if ftype == TType.STOP:
7534 
        break
7535 
      if fid == 0:
7536 
        if ftype == TType.STRUCT:
7537 
          self.success = Address()
7538 
          self.success.read(iprot)
7539 
        else:
7540 
          iprot.skip(ftype)
7541 
      elif fid == 1:
7542 
        if ftype == TType.STRUCT:
7543 
          self.ucx = UserContextException()
7544 
          self.ucx.read(iprot)
7545 
        else:
7546 
          iprot.skip(ftype)
7547 
      else:
7548 
        iprot.skip(ftype)
7549 
      iprot.readFieldEnd()
7550 
    iprot.readStructEnd()
7551 
 
7552 
  def write(self, oprot):
7553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7555 
      return
7556 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7557 
    if self.success is not None:
1894 vikas 7558 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7559 
      self.success.write(oprot)
7560 
      oprot.writeFieldEnd()
3431 rajveer 7561 
    if self.ucx is not None:
1894 vikas 7562 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7563 
      self.ucx.write(oprot)
7564 
      oprot.writeFieldEnd()
7565 
    oprot.writeFieldStop()
7566 
    oprot.writeStructEnd()
7567 
 
3431 rajveer 7568 
  def validate(self):
7569 
    return
7570 
 
7571 
 
1894 vikas 7572 
  def __repr__(self):
7573 
    L = ['%s=%r' % (key, value)
7574 
      for key, value in self.__dict__.iteritems()]
7575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7576 
 
7577 
  def __eq__(self, other):
7578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7579 
 
7580 
  def __ne__(self, other):
7581 
    return not (self == other)
7582 
 
594 rajveer 7583 
class getDefaultAddressId_args:
7584 
  """
7585 
  Attributes:
7586 
   - userId
7587 
  """
7588 
 
7589 
  thrift_spec = (
7590 
    None, # 0
7591 
    (1, TType.I64, 'userId', None, None, ), # 1
7592 
  )
7593 
 
7594 
  def __init__(self, userId=None,):
7595 
    self.userId = userId
7596 
 
7597 
  def read(self, iprot):
7598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7600 
      return
7601 
    iprot.readStructBegin()
7602 
    while True:
7603 
      (fname, ftype, fid) = iprot.readFieldBegin()
7604 
      if ftype == TType.STOP:
7605 
        break
7606 
      if fid == 1:
7607 
        if ftype == TType.I64:
7608 
          self.userId = iprot.readI64();
7609 
        else:
7610 
          iprot.skip(ftype)
7611 
      else:
7612 
        iprot.skip(ftype)
7613 
      iprot.readFieldEnd()
7614 
    iprot.readStructEnd()
7615 
 
7616 
  def write(self, oprot):
7617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7619 
      return
7620 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7621 
    if self.userId is not None:
594 rajveer 7622 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7623 
      oprot.writeI64(self.userId)
7624 
      oprot.writeFieldEnd()
7625 
    oprot.writeFieldStop()
7626 
    oprot.writeStructEnd()
7627 
 
3431 rajveer 7628 
  def validate(self):
7629 
    return
7630 
 
7631 
 
594 rajveer 7632 
  def __repr__(self):
7633 
    L = ['%s=%r' % (key, value)
7634 
      for key, value in self.__dict__.iteritems()]
7635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7636 
 
7637 
  def __eq__(self, other):
7638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7639 
 
7640 
  def __ne__(self, other):
7641 
    return not (self == other)
7642 
 
7643 
class getDefaultAddressId_result:
7644 
  """
7645 
  Attributes:
7646 
   - success
7647 
   - ucx
7648 
  """
7649 
 
7650 
  thrift_spec = (
7651 
    (0, TType.I64, 'success', None, None, ), # 0
7652 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7653 
  )
7654 
 
7655 
  def __init__(self, success=None, ucx=None,):
7656 
    self.success = success
7657 
    self.ucx = ucx
7658 
 
7659 
  def read(self, iprot):
7660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7662 
      return
7663 
    iprot.readStructBegin()
7664 
    while True:
7665 
      (fname, ftype, fid) = iprot.readFieldBegin()
7666 
      if ftype == TType.STOP:
7667 
        break
7668 
      if fid == 0:
7669 
        if ftype == TType.I64:
7670 
          self.success = iprot.readI64();
7671 
        else:
7672 
          iprot.skip(ftype)
7673 
      elif fid == 1:
7674 
        if ftype == TType.STRUCT:
7675 
          self.ucx = UserContextException()
7676 
          self.ucx.read(iprot)
7677 
        else:
7678 
          iprot.skip(ftype)
7679 
      else:
7680 
        iprot.skip(ftype)
7681 
      iprot.readFieldEnd()
7682 
    iprot.readStructEnd()
7683 
 
7684 
  def write(self, oprot):
7685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7687 
      return
7688 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7689 
    if self.success is not None:
594 rajveer 7690 
      oprot.writeFieldBegin('success', TType.I64, 0)
7691 
      oprot.writeI64(self.success)
7692 
      oprot.writeFieldEnd()
3431 rajveer 7693 
    if self.ucx is not None:
594 rajveer 7694 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7695 
      self.ucx.write(oprot)
7696 
      oprot.writeFieldEnd()
7697 
    oprot.writeFieldStop()
7698 
    oprot.writeStructEnd()
7699 
 
3431 rajveer 7700 
  def validate(self):
7701 
    return
7702 
 
7703 
 
594 rajveer 7704 
  def __repr__(self):
7705 
    L = ['%s=%r' % (key, value)
7706 
      for key, value in self.__dict__.iteritems()]
7707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7708 
 
7709 
  def __eq__(self, other):
7710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7711 
 
7712 
  def __ne__(self, other):
7713 
    return not (self == other)
7714 
 
785 rajveer 7715 
class getDefaultPincode_args:
7716 
  """
7717 
  Attributes:
7718 
   - userId
7719 
  """
7720 
 
7721 
  thrift_spec = (
7722 
    None, # 0
7723 
    (1, TType.I64, 'userId', None, None, ), # 1
7724 
  )
7725 
 
7726 
  def __init__(self, userId=None,):
7727 
    self.userId = userId
7728 
 
7729 
  def read(self, iprot):
7730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7732 
      return
7733 
    iprot.readStructBegin()
7734 
    while True:
7735 
      (fname, ftype, fid) = iprot.readFieldBegin()
7736 
      if ftype == TType.STOP:
7737 
        break
7738 
      if fid == 1:
7739 
        if ftype == TType.I64:
7740 
          self.userId = iprot.readI64();
7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      else:
7744 
        iprot.skip(ftype)
7745 
      iprot.readFieldEnd()
7746 
    iprot.readStructEnd()
7747 
 
7748 
  def write(self, oprot):
7749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7751 
      return
7752 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7753 
    if self.userId is not None:
785 rajveer 7754 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7755 
      oprot.writeI64(self.userId)
7756 
      oprot.writeFieldEnd()
7757 
    oprot.writeFieldStop()
7758 
    oprot.writeStructEnd()
7759 
 
3431 rajveer 7760 
  def validate(self):
7761 
    return
7762 
 
7763 
 
785 rajveer 7764 
  def __repr__(self):
7765 
    L = ['%s=%r' % (key, value)
7766 
      for key, value in self.__dict__.iteritems()]
7767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7768 
 
7769 
  def __eq__(self, other):
7770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7771 
 
7772 
  def __ne__(self, other):
7773 
    return not (self == other)
7774 
 
7775 
class getDefaultPincode_result:
7776 
  """
7777 
  Attributes:
7778 
   - success
7779 
   - ucx
7780 
  """
7781 
 
7782 
  thrift_spec = (
7783 
    (0, TType.STRING, 'success', None, None, ), # 0
7784 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7785 
  )
7786 
 
7787 
  def __init__(self, success=None, ucx=None,):
7788 
    self.success = success
7789 
    self.ucx = ucx
7790 
 
7791 
  def read(self, iprot):
7792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7794 
      return
7795 
    iprot.readStructBegin()
7796 
    while True:
7797 
      (fname, ftype, fid) = iprot.readFieldBegin()
7798 
      if ftype == TType.STOP:
7799 
        break
7800 
      if fid == 0:
7801 
        if ftype == TType.STRING:
7802 
          self.success = iprot.readString();
7803 
        else:
7804 
          iprot.skip(ftype)
7805 
      elif fid == 1:
7806 
        if ftype == TType.STRUCT:
7807 
          self.ucx = UserContextException()
7808 
          self.ucx.read(iprot)
7809 
        else:
7810 
          iprot.skip(ftype)
7811 
      else:
7812 
        iprot.skip(ftype)
7813 
      iprot.readFieldEnd()
7814 
    iprot.readStructEnd()
7815 
 
7816 
  def write(self, oprot):
7817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7819 
      return
7820 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7821 
    if self.success is not None:
785 rajveer 7822 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7823 
      oprot.writeString(self.success)
7824 
      oprot.writeFieldEnd()
3431 rajveer 7825 
    if self.ucx is not None:
785 rajveer 7826 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7827 
      self.ucx.write(oprot)
7828 
      oprot.writeFieldEnd()
7829 
    oprot.writeFieldStop()
7830 
    oprot.writeStructEnd()
7831 
 
3431 rajveer 7832 
  def validate(self):
7833 
    return
7834 
 
7835 
 
785 rajveer 7836 
  def __repr__(self):
7837 
    L = ['%s=%r' % (key, value)
7838 
      for key, value in self.__dict__.iteritems()]
7839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7840 
 
7841 
  def __eq__(self, other):
7842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7843 
 
7844 
  def __ne__(self, other):
7845 
    return not (self == other)
7846 
 
1274 varun.gupt 7847 
class saveUserCommunication_args:
7848 
  """
7849 
  Attributes:
7850 
   - userId
7851 
   - replyTo
7852 
   - communicationType
7853 
   - orderId
7854 
   - airwaybillNo
7855 
   - productName
7856 
   - subject
7857 
   - message
7858 
  """
7859 
 
7860 
  thrift_spec = (
7861 
    None, # 0
7862 
    (1, TType.I64, 'userId', None, None, ), # 1
7863 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7864 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7865 
    (4, TType.I64, 'orderId', None, None, ), # 4
7866 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7867 
    (6, TType.STRING, 'productName', None, None, ), # 6
7868 
    (7, TType.STRING, 'subject', None, None, ), # 7
7869 
    (8, TType.STRING, 'message', None, None, ), # 8
7870 
  )
7871 
 
7872 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7873 
    self.userId = userId
7874 
    self.replyTo = replyTo
7875 
    self.communicationType = communicationType
7876 
    self.orderId = orderId
7877 
    self.airwaybillNo = airwaybillNo
7878 
    self.productName = productName
7879 
    self.subject = subject
7880 
    self.message = message
7881 
 
7882 
  def read(self, iprot):
7883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7885 
      return
7886 
    iprot.readStructBegin()
7887 
    while True:
7888 
      (fname, ftype, fid) = iprot.readFieldBegin()
7889 
      if ftype == TType.STOP:
7890 
        break
7891 
      if fid == 1:
7892 
        if ftype == TType.I64:
7893 
          self.userId = iprot.readI64();
7894 
        else:
7895 
          iprot.skip(ftype)
7896 
      elif fid == 2:
7897 
        if ftype == TType.STRING:
7898 
          self.replyTo = iprot.readString();
7899 
        else:
7900 
          iprot.skip(ftype)
7901 
      elif fid == 3:
7902 
        if ftype == TType.I64:
7903 
          self.communicationType = iprot.readI64();
7904 
        else:
7905 
          iprot.skip(ftype)
7906 
      elif fid == 4:
7907 
        if ftype == TType.I64:
7908 
          self.orderId = iprot.readI64();
7909 
        else:
7910 
          iprot.skip(ftype)
7911 
      elif fid == 5:
7912 
        if ftype == TType.STRING:
7913 
          self.airwaybillNo = iprot.readString();
7914 
        else:
7915 
          iprot.skip(ftype)
7916 
      elif fid == 6:
7917 
        if ftype == TType.STRING:
7918 
          self.productName = iprot.readString();
7919 
        else:
7920 
          iprot.skip(ftype)
7921 
      elif fid == 7:
7922 
        if ftype == TType.STRING:
7923 
          self.subject = iprot.readString();
7924 
        else:
7925 
          iprot.skip(ftype)
7926 
      elif fid == 8:
7927 
        if ftype == TType.STRING:
7928 
          self.message = iprot.readString();
7929 
        else:
7930 
          iprot.skip(ftype)
7931 
      else:
7932 
        iprot.skip(ftype)
7933 
      iprot.readFieldEnd()
7934 
    iprot.readStructEnd()
7935 
 
7936 
  def write(self, oprot):
7937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7939 
      return
7940 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7941 
    if self.userId is not None:
1274 varun.gupt 7942 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7943 
      oprot.writeI64(self.userId)
7944 
      oprot.writeFieldEnd()
3431 rajveer 7945 
    if self.replyTo is not None:
1274 varun.gupt 7946 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7947 
      oprot.writeString(self.replyTo)
7948 
      oprot.writeFieldEnd()
3431 rajveer 7949 
    if self.communicationType is not None:
1274 varun.gupt 7950 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7951 
      oprot.writeI64(self.communicationType)
7952 
      oprot.writeFieldEnd()
3431 rajveer 7953 
    if self.orderId is not None:
1274 varun.gupt 7954 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7955 
      oprot.writeI64(self.orderId)
7956 
      oprot.writeFieldEnd()
3431 rajveer 7957 
    if self.airwaybillNo is not None:
1274 varun.gupt 7958 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7959 
      oprot.writeString(self.airwaybillNo)
7960 
      oprot.writeFieldEnd()
3431 rajveer 7961 
    if self.productName is not None:
1274 varun.gupt 7962 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7963 
      oprot.writeString(self.productName)
7964 
      oprot.writeFieldEnd()
3431 rajveer 7965 
    if self.subject is not None:
1274 varun.gupt 7966 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7967 
      oprot.writeString(self.subject)
7968 
      oprot.writeFieldEnd()
3431 rajveer 7969 
    if self.message is not None:
1274 varun.gupt 7970 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7971 
      oprot.writeString(self.message)
7972 
      oprot.writeFieldEnd()
7973 
    oprot.writeFieldStop()
7974 
    oprot.writeStructEnd()
7975 
 
3431 rajveer 7976 
  def validate(self):
7977 
    return
7978 
 
7979 
 
1274 varun.gupt 7980 
  def __repr__(self):
7981 
    L = ['%s=%r' % (key, value)
7982 
      for key, value in self.__dict__.iteritems()]
7983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7984 
 
7985 
  def __eq__(self, other):
7986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7987 
 
7988 
  def __ne__(self, other):
7989 
    return not (self == other)
7990 
 
7991 
class saveUserCommunication_result:
7992 
  """
7993 
  Attributes:
7994 
   - success
7995 
   - ucx
7996 
  """
7997 
 
7998 
  thrift_spec = (
7999 
    (0, TType.BOOL, 'success', None, None, ), # 0
8000 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8001 
  )
8002 
 
8003 
  def __init__(self, success=None, ucx=None,):
8004 
    self.success = success
8005 
    self.ucx = ucx
8006 
 
8007 
  def read(self, iprot):
8008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8010 
      return
8011 
    iprot.readStructBegin()
8012 
    while True:
8013 
      (fname, ftype, fid) = iprot.readFieldBegin()
8014 
      if ftype == TType.STOP:
8015 
        break
8016 
      if fid == 0:
8017 
        if ftype == TType.BOOL:
8018 
          self.success = iprot.readBool();
8019 
        else:
8020 
          iprot.skip(ftype)
8021 
      elif fid == 1:
8022 
        if ftype == TType.STRUCT:
8023 
          self.ucx = UserCommunicationException()
8024 
          self.ucx.read(iprot)
8025 
        else:
8026 
          iprot.skip(ftype)
8027 
      else:
8028 
        iprot.skip(ftype)
8029 
      iprot.readFieldEnd()
8030 
    iprot.readStructEnd()
8031 
 
8032 
  def write(self, oprot):
8033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8035 
      return
8036 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8037 
    if self.success is not None:
1274 varun.gupt 8038 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8039 
      oprot.writeBool(self.success)
8040 
      oprot.writeFieldEnd()
3431 rajveer 8041 
    if self.ucx is not None:
1274 varun.gupt 8042 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8043 
      self.ucx.write(oprot)
8044 
      oprot.writeFieldEnd()
8045 
    oprot.writeFieldStop()
8046 
    oprot.writeStructEnd()
8047 
 
3431 rajveer 8048 
  def validate(self):
8049 
    return
8050 
 
8051 
 
1274 varun.gupt 8052 
  def __repr__(self):
8053 
    L = ['%s=%r' % (key, value)
8054 
      for key, value in self.__dict__.iteritems()]
8055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8056 
 
8057 
  def __eq__(self, other):
8058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8059 
 
8060 
  def __ne__(self, other):
8061 
    return not (self == other)
8062 
 
1590 varun.gupt 8063 
class getUserCommunicationById_args:
8064 
  """
8065 
  Attributes:
8066 
   - id
8067 
  """
8068 
 
8069 
  thrift_spec = (
8070 
    None, # 0
8071 
    (1, TType.I64, 'id', None, None, ), # 1
8072 
  )
8073 
 
8074 
  def __init__(self, id=None,):
8075 
    self.id = id
8076 
 
8077 
  def read(self, iprot):
8078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8080 
      return
8081 
    iprot.readStructBegin()
8082 
    while True:
8083 
      (fname, ftype, fid) = iprot.readFieldBegin()
8084 
      if ftype == TType.STOP:
8085 
        break
8086 
      if fid == 1:
8087 
        if ftype == TType.I64:
8088 
          self.id = iprot.readI64();
8089 
        else:
8090 
          iprot.skip(ftype)
8091 
      else:
8092 
        iprot.skip(ftype)
8093 
      iprot.readFieldEnd()
8094 
    iprot.readStructEnd()
8095 
 
8096 
  def write(self, oprot):
8097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8099 
      return
8100 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8101 
    if self.id is not None:
1590 varun.gupt 8102 
      oprot.writeFieldBegin('id', TType.I64, 1)
8103 
      oprot.writeI64(self.id)
8104 
      oprot.writeFieldEnd()
8105 
    oprot.writeFieldStop()
8106 
    oprot.writeStructEnd()
8107 
 
3431 rajveer 8108 
  def validate(self):
8109 
    return
8110 
 
8111 
 
1590 varun.gupt 8112 
  def __repr__(self):
8113 
    L = ['%s=%r' % (key, value)
8114 
      for key, value in self.__dict__.iteritems()]
8115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8116 
 
8117 
  def __eq__(self, other):
8118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8119 
 
8120 
  def __ne__(self, other):
8121 
    return not (self == other)
8122 
 
8123 
class getUserCommunicationById_result:
8124 
  """
8125 
  Attributes:
8126 
   - success
8127 
   - ucx
8128 
  """
8129 
 
8130 
  thrift_spec = (
8131 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8132 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8133 
  )
8134 
 
8135 
  def __init__(self, success=None, ucx=None,):
8136 
    self.success = success
8137 
    self.ucx = ucx
8138 
 
8139 
  def read(self, iprot):
8140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8142 
      return
8143 
    iprot.readStructBegin()
8144 
    while True:
8145 
      (fname, ftype, fid) = iprot.readFieldBegin()
8146 
      if ftype == TType.STOP:
8147 
        break
8148 
      if fid == 0:
8149 
        if ftype == TType.STRUCT:
8150 
          self.success = UserCommunication()
8151 
          self.success.read(iprot)
8152 
        else:
8153 
          iprot.skip(ftype)
8154 
      elif fid == 1:
8155 
        if ftype == TType.STRUCT:
8156 
          self.ucx = UserCommunicationException()
8157 
          self.ucx.read(iprot)
8158 
        else:
8159 
          iprot.skip(ftype)
8160 
      else:
8161 
        iprot.skip(ftype)
8162 
      iprot.readFieldEnd()
8163 
    iprot.readStructEnd()
8164 
 
8165 
  def write(self, oprot):
8166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8168 
      return
8169 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8170 
    if self.success is not None:
1590 varun.gupt 8171 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8172 
      self.success.write(oprot)
8173 
      oprot.writeFieldEnd()
3431 rajveer 8174 
    if self.ucx is not None:
1590 varun.gupt 8175 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8176 
      self.ucx.write(oprot)
8177 
      oprot.writeFieldEnd()
8178 
    oprot.writeFieldStop()
8179 
    oprot.writeStructEnd()
8180 
 
3431 rajveer 8181 
  def validate(self):
8182 
    return
8183 
 
8184 
 
1590 varun.gupt 8185 
  def __repr__(self):
8186 
    L = ['%s=%r' % (key, value)
8187 
      for key, value in self.__dict__.iteritems()]
8188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8189 
 
8190 
  def __eq__(self, other):
8191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8192 
 
8193 
  def __ne__(self, other):
8194 
    return not (self == other)
8195 
 
8196 
class getUserCommunicationByUser_args:
8197 
  """
8198 
  Attributes:
8199 
   - userId
8200 
  """
8201 
 
8202 
  thrift_spec = (
8203 
    None, # 0
8204 
    (1, TType.I64, 'userId', None, None, ), # 1
8205 
  )
8206 
 
8207 
  def __init__(self, userId=None,):
8208 
    self.userId = userId
8209 
 
8210 
  def read(self, iprot):
8211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8213 
      return
8214 
    iprot.readStructBegin()
8215 
    while True:
8216 
      (fname, ftype, fid) = iprot.readFieldBegin()
8217 
      if ftype == TType.STOP:
8218 
        break
8219 
      if fid == 1:
8220 
        if ftype == TType.I64:
8221 
          self.userId = iprot.readI64();
8222 
        else:
8223 
          iprot.skip(ftype)
8224 
      else:
8225 
        iprot.skip(ftype)
8226 
      iprot.readFieldEnd()
8227 
    iprot.readStructEnd()
8228 
 
8229 
  def write(self, oprot):
8230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8232 
      return
8233 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8234 
    if self.userId is not None:
1590 varun.gupt 8235 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8236 
      oprot.writeI64(self.userId)
8237 
      oprot.writeFieldEnd()
8238 
    oprot.writeFieldStop()
8239 
    oprot.writeStructEnd()
8240 
 
3431 rajveer 8241 
  def validate(self):
8242 
    return
8243 
 
8244 
 
1590 varun.gupt 8245 
  def __repr__(self):
8246 
    L = ['%s=%r' % (key, value)
8247 
      for key, value in self.__dict__.iteritems()]
8248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8249 
 
8250 
  def __eq__(self, other):
8251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8252 
 
8253 
  def __ne__(self, other):
8254 
    return not (self == other)
8255 
 
8256 
class getUserCommunicationByUser_result:
8257 
  """
8258 
  Attributes:
8259 
   - success
8260 
   - ucx
8261 
  """
8262 
 
8263 
  thrift_spec = (
8264 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8265 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8266 
  )
8267 
 
8268 
  def __init__(self, success=None, ucx=None,):
8269 
    self.success = success
8270 
    self.ucx = ucx
8271 
 
8272 
  def read(self, iprot):
8273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8275 
      return
8276 
    iprot.readStructBegin()
8277 
    while True:
8278 
      (fname, ftype, fid) = iprot.readFieldBegin()
8279 
      if ftype == TType.STOP:
8280 
        break
8281 
      if fid == 0:
8282 
        if ftype == TType.LIST:
8283 
          self.success = []
11592 amit.gupta 8284 
          (_etype107, _size104) = iprot.readListBegin()
8285 
          for _i108 in xrange(_size104):
8286 
            _elem109 = UserCommunication()
8287 
            _elem109.read(iprot)
8288 
            self.success.append(_elem109)
1590 varun.gupt 8289 
          iprot.readListEnd()
8290 
        else:
8291 
          iprot.skip(ftype)
8292 
      elif fid == 1:
8293 
        if ftype == TType.STRUCT:
8294 
          self.ucx = UserCommunicationException()
8295 
          self.ucx.read(iprot)
8296 
        else:
8297 
          iprot.skip(ftype)
8298 
      else:
8299 
        iprot.skip(ftype)
8300 
      iprot.readFieldEnd()
8301 
    iprot.readStructEnd()
8302 
 
8303 
  def write(self, oprot):
8304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8306 
      return
8307 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8308 
    if self.success is not None:
1590 varun.gupt 8309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8311 
      for iter110 in self.success:
8312 
        iter110.write(oprot)
1590 varun.gupt 8313 
      oprot.writeListEnd()
8314 
      oprot.writeFieldEnd()
3431 rajveer 8315 
    if self.ucx is not None:
1590 varun.gupt 8316 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8317 
      self.ucx.write(oprot)
8318 
      oprot.writeFieldEnd()
8319 
    oprot.writeFieldStop()
8320 
    oprot.writeStructEnd()
8321 
 
3431 rajveer 8322 
  def validate(self):
8323 
    return
8324 
 
8325 
 
1590 varun.gupt 8326 
  def __repr__(self):
8327 
    L = ['%s=%r' % (key, value)
8328 
      for key, value in self.__dict__.iteritems()]
8329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8330 
 
8331 
  def __eq__(self, other):
8332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8333 
 
8334 
  def __ne__(self, other):
8335 
    return not (self == other)
8336 
 
8337 
class getAllUserCommunications_args:
8338 
 
8339 
  thrift_spec = (
8340 
  )
8341 
 
8342 
  def read(self, iprot):
8343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8345 
      return
8346 
    iprot.readStructBegin()
8347 
    while True:
8348 
      (fname, ftype, fid) = iprot.readFieldBegin()
8349 
      if ftype == TType.STOP:
8350 
        break
8351 
      else:
8352 
        iprot.skip(ftype)
8353 
      iprot.readFieldEnd()
8354 
    iprot.readStructEnd()
8355 
 
8356 
  def write(self, oprot):
8357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8359 
      return
8360 
    oprot.writeStructBegin('getAllUserCommunications_args')
8361 
    oprot.writeFieldStop()
8362 
    oprot.writeStructEnd()
8363 
 
3431 rajveer 8364 
  def validate(self):
8365 
    return
8366 
 
8367 
 
1590 varun.gupt 8368 
  def __repr__(self):
8369 
    L = ['%s=%r' % (key, value)
8370 
      for key, value in self.__dict__.iteritems()]
8371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8372 
 
8373 
  def __eq__(self, other):
8374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8375 
 
8376 
  def __ne__(self, other):
8377 
    return not (self == other)
8378 
 
8379 
class getAllUserCommunications_result:
8380 
  """
8381 
  Attributes:
8382 
   - success
8383 
   - ucx
8384 
  """
8385 
 
8386 
  thrift_spec = (
8387 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8388 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8389 
  )
8390 
 
8391 
  def __init__(self, success=None, ucx=None,):
8392 
    self.success = success
8393 
    self.ucx = ucx
8394 
 
8395 
  def read(self, iprot):
8396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8398 
      return
8399 
    iprot.readStructBegin()
8400 
    while True:
8401 
      (fname, ftype, fid) = iprot.readFieldBegin()
8402 
      if ftype == TType.STOP:
8403 
        break
8404 
      if fid == 0:
8405 
        if ftype == TType.LIST:
8406 
          self.success = []
11592 amit.gupta 8407 
          (_etype114, _size111) = iprot.readListBegin()
8408 
          for _i115 in xrange(_size111):
8409 
            _elem116 = UserCommunication()
8410 
            _elem116.read(iprot)
8411 
            self.success.append(_elem116)
1590 varun.gupt 8412 
          iprot.readListEnd()
8413 
        else:
8414 
          iprot.skip(ftype)
8415 
      elif fid == 1:
8416 
        if ftype == TType.STRUCT:
8417 
          self.ucx = UserCommunicationException()
8418 
          self.ucx.read(iprot)
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('getAllUserCommunications_result')
3431 rajveer 8431 
    if self.success is not None:
1590 varun.gupt 8432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8434 
      for iter117 in self.success:
8435 
        iter117.write(oprot)
1590 varun.gupt 8436 
      oprot.writeListEnd()
8437 
      oprot.writeFieldEnd()
3431 rajveer 8438 
    if self.ucx is not None:
1590 varun.gupt 8439 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8440 
      self.ucx.write(oprot)
8441 
      oprot.writeFieldEnd()
8442 
    oprot.writeFieldStop()
8443 
    oprot.writeStructEnd()
8444 
 
3431 rajveer 8445 
  def validate(self):
8446 
    return
8447 
 
8448 
 
1590 varun.gupt 8449 
  def __repr__(self):
8450 
    L = ['%s=%r' % (key, value)
8451 
      for key, value in self.__dict__.iteritems()]
8452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8453 
 
8454 
  def __eq__(self, other):
8455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8456 
 
8457 
  def __ne__(self, other):
8458 
    return not (self == other)
8459 
 
5407 amar.kumar 8460 
class removeUserCommunication_args:
8461 
  """
8462 
  Attributes:
8463 
   - id
8464 
  """
8465 
 
8466 
  thrift_spec = (
8467 
    None, # 0
8468 
    (1, TType.I64, 'id', None, None, ), # 1
8469 
  )
8470 
 
8471 
  def __init__(self, id=None,):
8472 
    self.id = id
8473 
 
8474 
  def read(self, iprot):
8475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8477 
      return
8478 
    iprot.readStructBegin()
8479 
    while True:
8480 
      (fname, ftype, fid) = iprot.readFieldBegin()
8481 
      if ftype == TType.STOP:
8482 
        break
8483 
      if fid == 1:
8484 
        if ftype == TType.I64:
8485 
          self.id = iprot.readI64();
8486 
        else:
8487 
          iprot.skip(ftype)
8488 
      else:
8489 
        iprot.skip(ftype)
8490 
      iprot.readFieldEnd()
8491 
    iprot.readStructEnd()
8492 
 
8493 
  def write(self, oprot):
8494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8496 
      return
8497 
    oprot.writeStructBegin('removeUserCommunication_args')
8498 
    if self.id is not None:
8499 
      oprot.writeFieldBegin('id', TType.I64, 1)
8500 
      oprot.writeI64(self.id)
8501 
      oprot.writeFieldEnd()
8502 
    oprot.writeFieldStop()
8503 
    oprot.writeStructEnd()
8504 
 
8505 
  def validate(self):
8506 
    return
8507 
 
8508 
 
8509 
  def __repr__(self):
8510 
    L = ['%s=%r' % (key, value)
8511 
      for key, value in self.__dict__.iteritems()]
8512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8513 
 
8514 
  def __eq__(self, other):
8515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8516 
 
8517 
  def __ne__(self, other):
8518 
    return not (self == other)
8519 
 
8520 
class removeUserCommunication_result:
8521 
  """
8522 
  Attributes:
8523 
   - ucx
8524 
  """
8525 
 
8526 
  thrift_spec = (
8527 
    None, # 0
8528 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8529 
  )
8530 
 
8531 
  def __init__(self, ucx=None,):
8532 
    self.ucx = ucx
8533 
 
8534 
  def read(self, iprot):
8535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8537 
      return
8538 
    iprot.readStructBegin()
8539 
    while True:
8540 
      (fname, ftype, fid) = iprot.readFieldBegin()
8541 
      if ftype == TType.STOP:
8542 
        break
8543 
      if fid == 1:
8544 
        if ftype == TType.STRUCT:
8545 
          self.ucx = UserCommunicationException()
8546 
          self.ucx.read(iprot)
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      else:
8550 
        iprot.skip(ftype)
8551 
      iprot.readFieldEnd()
8552 
    iprot.readStructEnd()
8553 
 
8554 
  def write(self, oprot):
8555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8557 
      return
8558 
    oprot.writeStructBegin('removeUserCommunication_result')
8559 
    if self.ucx is not None:
8560 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8561 
      self.ucx.write(oprot)
8562 
      oprot.writeFieldEnd()
8563 
    oprot.writeFieldStop()
8564 
    oprot.writeStructEnd()
8565 
 
8566 
  def validate(self):
8567 
    return
8568 
 
8569 
 
8570 
  def __repr__(self):
8571 
    L = ['%s=%r' % (key, value)
8572 
      for key, value in self.__dict__.iteritems()]
8573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8574 
 
8575 
  def __eq__(self, other):
8576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8577 
 
8578 
  def __ne__(self, other):
8579 
    return not (self == other)
8580 
 
1845 vikas 8581 
class createMasterAffiliate_args:
8582 
  """
8583 
  Attributes:
8584 
   - name
1859 vikas 8585 
   - addedOn
1845 vikas 8586 
  """
8587 
 
8588 
  thrift_spec = (
8589 
    None, # 0
8590 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8591 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8592 
  )
8593 
 
1859 vikas 8594 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8595 
    self.name = name
1859 vikas 8596 
    self.addedOn = addedOn
1845 vikas 8597 
 
8598 
  def read(self, iprot):
8599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8601 
      return
8602 
    iprot.readStructBegin()
8603 
    while True:
8604 
      (fname, ftype, fid) = iprot.readFieldBegin()
8605 
      if ftype == TType.STOP:
8606 
        break
8607 
      if fid == 1:
8608 
        if ftype == TType.STRING:
8609 
          self.name = iprot.readString();
8610 
        else:
8611 
          iprot.skip(ftype)
1859 vikas 8612 
      elif fid == 2:
8613 
        if ftype == TType.I64:
8614 
          self.addedOn = iprot.readI64();
8615 
        else:
8616 
          iprot.skip(ftype)
1845 vikas 8617 
      else:
8618 
        iprot.skip(ftype)
8619 
      iprot.readFieldEnd()
8620 
    iprot.readStructEnd()
8621 
 
8622 
  def write(self, oprot):
8623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8625 
      return
8626 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8627 
    if self.name is not None:
1845 vikas 8628 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8629 
      oprot.writeString(self.name)
8630 
      oprot.writeFieldEnd()
3431 rajveer 8631 
    if self.addedOn is not None:
1859 vikas 8632 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8633 
      oprot.writeI64(self.addedOn)
8634 
      oprot.writeFieldEnd()
1845 vikas 8635 
    oprot.writeFieldStop()
8636 
    oprot.writeStructEnd()
8637 
 
3431 rajveer 8638 
  def validate(self):
8639 
    return
8640 
 
8641 
 
1845 vikas 8642 
  def __repr__(self):
8643 
    L = ['%s=%r' % (key, value)
8644 
      for key, value in self.__dict__.iteritems()]
8645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8646 
 
8647 
  def __eq__(self, other):
8648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8649 
 
8650 
  def __ne__(self, other):
8651 
    return not (self == other)
8652 
 
8653 
class createMasterAffiliate_result:
8654 
  """
8655 
  Attributes:
8656 
   - success
8657 
   - utx
8658 
  """
8659 
 
8660 
  thrift_spec = (
8661 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8662 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8663 
  )
8664 
 
8665 
  def __init__(self, success=None, utx=None,):
8666 
    self.success = success
8667 
    self.utx = utx
8668 
 
8669 
  def read(self, iprot):
8670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8672 
      return
8673 
    iprot.readStructBegin()
8674 
    while True:
8675 
      (fname, ftype, fid) = iprot.readFieldBegin()
8676 
      if ftype == TType.STOP:
8677 
        break
8678 
      if fid == 0:
8679 
        if ftype == TType.STRUCT:
8680 
          self.success = MasterAffiliate()
8681 
          self.success.read(iprot)
8682 
        else:
8683 
          iprot.skip(ftype)
8684 
      elif fid == 1:
8685 
        if ftype == TType.STRUCT:
1996 vikas 8686 
          self.utx = UserAffiliateException()
1845 vikas 8687 
          self.utx.read(iprot)
8688 
        else:
8689 
          iprot.skip(ftype)
8690 
      else:
8691 
        iprot.skip(ftype)
8692 
      iprot.readFieldEnd()
8693 
    iprot.readStructEnd()
8694 
 
8695 
  def write(self, oprot):
8696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8698 
      return
8699 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8700 
    if self.success is not None:
1845 vikas 8701 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8702 
      self.success.write(oprot)
8703 
      oprot.writeFieldEnd()
3431 rajveer 8704 
    if self.utx is not None:
1845 vikas 8705 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8706 
      self.utx.write(oprot)
8707 
      oprot.writeFieldEnd()
8708 
    oprot.writeFieldStop()
8709 
    oprot.writeStructEnd()
8710 
 
3431 rajveer 8711 
  def validate(self):
8712 
    return
8713 
 
8714 
 
1845 vikas 8715 
  def __repr__(self):
8716 
    L = ['%s=%r' % (key, value)
8717 
      for key, value in self.__dict__.iteritems()]
8718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8719 
 
8720 
  def __eq__(self, other):
8721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8722 
 
8723 
  def __ne__(self, other):
8724 
    return not (self == other)
8725 
 
1899 vikas 8726 
class getAllMasterAffiliates_args:
8727 
 
8728 
  thrift_spec = (
8729 
  )
8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      else:
8741 
        iprot.skip(ftype)
8742 
      iprot.readFieldEnd()
8743 
    iprot.readStructEnd()
8744 
 
8745 
  def write(self, oprot):
8746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8748 
      return
8749 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8750 
    oprot.writeFieldStop()
8751 
    oprot.writeStructEnd()
8752 
 
3431 rajveer 8753 
  def validate(self):
8754 
    return
8755 
 
8756 
 
1899 vikas 8757 
  def __repr__(self):
8758 
    L = ['%s=%r' % (key, value)
8759 
      for key, value in self.__dict__.iteritems()]
8760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8761 
 
8762 
  def __eq__(self, other):
8763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8764 
 
8765 
  def __ne__(self, other):
8766 
    return not (self == other)
8767 
 
8768 
class getAllMasterAffiliates_result:
8769 
  """
8770 
  Attributes:
8771 
   - success
8772 
   - utx
8773 
  """
8774 
 
8775 
  thrift_spec = (
8776 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8777 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8778 
  )
8779 
 
8780 
  def __init__(self, success=None, utx=None,):
8781 
    self.success = success
8782 
    self.utx = utx
8783 
 
8784 
  def read(self, iprot):
8785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8787 
      return
8788 
    iprot.readStructBegin()
8789 
    while True:
8790 
      (fname, ftype, fid) = iprot.readFieldBegin()
8791 
      if ftype == TType.STOP:
8792 
        break
8793 
      if fid == 0:
8794 
        if ftype == TType.LIST:
8795 
          self.success = []
11592 amit.gupta 8796 
          (_etype121, _size118) = iprot.readListBegin()
8797 
          for _i122 in xrange(_size118):
8798 
            _elem123 = MasterAffiliate()
8799 
            _elem123.read(iprot)
8800 
            self.success.append(_elem123)
1899 vikas 8801 
          iprot.readListEnd()
8802 
        else:
8803 
          iprot.skip(ftype)
8804 
      elif fid == 1:
8805 
        if ftype == TType.STRUCT:
1996 vikas 8806 
          self.utx = UserAffiliateException()
1899 vikas 8807 
          self.utx.read(iprot)
8808 
        else:
8809 
          iprot.skip(ftype)
8810 
      else:
8811 
        iprot.skip(ftype)
8812 
      iprot.readFieldEnd()
8813 
    iprot.readStructEnd()
8814 
 
8815 
  def write(self, oprot):
8816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8818 
      return
8819 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8820 
    if self.success is not None:
1899 vikas 8821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8823 
      for iter124 in self.success:
8824 
        iter124.write(oprot)
1899 vikas 8825 
      oprot.writeListEnd()
8826 
      oprot.writeFieldEnd()
3431 rajveer 8827 
    if self.utx is not None:
1899 vikas 8828 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8829 
      self.utx.write(oprot)
8830 
      oprot.writeFieldEnd()
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
3431 rajveer 8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
1899 vikas 8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
1845 vikas 8849 
class getMasterAffiliateById_args:
8850 
  """
8851 
  Attributes:
8852 
   - id
8853 
  """
8854 
 
8855 
  thrift_spec = (
8856 
    None, # 0
8857 
    (1, TType.I64, 'id', None, None, ), # 1
8858 
  )
8859 
 
8860 
  def __init__(self, id=None,):
8861 
    self.id = id
8862 
 
8863 
  def read(self, iprot):
8864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8866 
      return
8867 
    iprot.readStructBegin()
8868 
    while True:
8869 
      (fname, ftype, fid) = iprot.readFieldBegin()
8870 
      if ftype == TType.STOP:
8871 
        break
8872 
      if fid == 1:
8873 
        if ftype == TType.I64:
8874 
          self.id = iprot.readI64();
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      else:
8878 
        iprot.skip(ftype)
8879 
      iprot.readFieldEnd()
8880 
    iprot.readStructEnd()
8881 
 
8882 
  def write(self, oprot):
8883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8885 
      return
8886 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8887 
    if self.id is not None:
1845 vikas 8888 
      oprot.writeFieldBegin('id', TType.I64, 1)
8889 
      oprot.writeI64(self.id)
8890 
      oprot.writeFieldEnd()
8891 
    oprot.writeFieldStop()
8892 
    oprot.writeStructEnd()
8893 
 
3431 rajveer 8894 
  def validate(self):
8895 
    return
8896 
 
8897 
 
1845 vikas 8898 
  def __repr__(self):
8899 
    L = ['%s=%r' % (key, value)
8900 
      for key, value in self.__dict__.iteritems()]
8901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8902 
 
8903 
  def __eq__(self, other):
8904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8905 
 
8906 
  def __ne__(self, other):
8907 
    return not (self == other)
8908 
 
8909 
class getMasterAffiliateById_result:
8910 
  """
8911 
  Attributes:
8912 
   - success
8913 
   - utx
8914 
  """
8915 
 
8916 
  thrift_spec = (
8917 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8918 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8919 
  )
8920 
 
8921 
  def __init__(self, success=None, utx=None,):
8922 
    self.success = success
8923 
    self.utx = utx
8924 
 
8925 
  def read(self, iprot):
8926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8928 
      return
8929 
    iprot.readStructBegin()
8930 
    while True:
8931 
      (fname, ftype, fid) = iprot.readFieldBegin()
8932 
      if ftype == TType.STOP:
8933 
        break
8934 
      if fid == 0:
8935 
        if ftype == TType.STRUCT:
8936 
          self.success = MasterAffiliate()
8937 
          self.success.read(iprot)
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      elif fid == 1:
8941 
        if ftype == TType.STRUCT:
1996 vikas 8942 
          self.utx = UserAffiliateException()
1845 vikas 8943 
          self.utx.read(iprot)
8944 
        else:
8945 
          iprot.skip(ftype)
8946 
      else:
8947 
        iprot.skip(ftype)
8948 
      iprot.readFieldEnd()
8949 
    iprot.readStructEnd()
8950 
 
8951 
  def write(self, oprot):
8952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8954 
      return
8955 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8956 
    if self.success is not None:
1845 vikas 8957 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8958 
      self.success.write(oprot)
8959 
      oprot.writeFieldEnd()
3431 rajveer 8960 
    if self.utx is not None:
1845 vikas 8961 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8962 
      self.utx.write(oprot)
8963 
      oprot.writeFieldEnd()
8964 
    oprot.writeFieldStop()
8965 
    oprot.writeStructEnd()
8966 
 
3431 rajveer 8967 
  def validate(self):
8968 
    return
8969 
 
8970 
 
1845 vikas 8971 
  def __repr__(self):
8972 
    L = ['%s=%r' % (key, value)
8973 
      for key, value in self.__dict__.iteritems()]
8974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8975 
 
8976 
  def __eq__(self, other):
8977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8978 
 
8979 
  def __ne__(self, other):
8980 
    return not (self == other)
8981 
 
8982 
class getMasterAffiliateByName_args:
8983 
  """
8984 
  Attributes:
8985 
   - name
8986 
  """
8987 
 
8988 
  thrift_spec = (
8989 
    None, # 0
8990 
    (1, TType.STRING, 'name', None, None, ), # 1
8991 
  )
8992 
 
8993 
  def __init__(self, name=None,):
8994 
    self.name = name
8995 
 
8996 
  def read(self, iprot):
8997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8999 
      return
9000 
    iprot.readStructBegin()
9001 
    while True:
9002 
      (fname, ftype, fid) = iprot.readFieldBegin()
9003 
      if ftype == TType.STOP:
9004 
        break
9005 
      if fid == 1:
9006 
        if ftype == TType.STRING:
9007 
          self.name = iprot.readString();
9008 
        else:
9009 
          iprot.skip(ftype)
9010 
      else:
9011 
        iprot.skip(ftype)
9012 
      iprot.readFieldEnd()
9013 
    iprot.readStructEnd()
9014 
 
9015 
  def write(self, oprot):
9016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9018 
      return
9019 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9020 
    if self.name is not None:
1845 vikas 9021 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9022 
      oprot.writeString(self.name)
9023 
      oprot.writeFieldEnd()
9024 
    oprot.writeFieldStop()
9025 
    oprot.writeStructEnd()
9026 
 
3431 rajveer 9027 
  def validate(self):
9028 
    return
9029 
 
9030 
 
1845 vikas 9031 
  def __repr__(self):
9032 
    L = ['%s=%r' % (key, value)
9033 
      for key, value in self.__dict__.iteritems()]
9034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9035 
 
9036 
  def __eq__(self, other):
9037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9038 
 
9039 
  def __ne__(self, other):
9040 
    return not (self == other)
9041 
 
9042 
class getMasterAffiliateByName_result:
9043 
  """
9044 
  Attributes:
9045 
   - success
9046 
   - utx
9047 
  """
9048 
 
9049 
  thrift_spec = (
9050 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9051 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9052 
  )
9053 
 
9054 
  def __init__(self, success=None, utx=None,):
9055 
    self.success = success
9056 
    self.utx = utx
9057 
 
9058 
  def read(self, iprot):
9059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9061 
      return
9062 
    iprot.readStructBegin()
9063 
    while True:
9064 
      (fname, ftype, fid) = iprot.readFieldBegin()
9065 
      if ftype == TType.STOP:
9066 
        break
9067 
      if fid == 0:
9068 
        if ftype == TType.STRUCT:
9069 
          self.success = MasterAffiliate()
9070 
          self.success.read(iprot)
9071 
        else:
9072 
          iprot.skip(ftype)
9073 
      elif fid == 1:
9074 
        if ftype == TType.STRUCT:
1996 vikas 9075 
          self.utx = UserAffiliateException()
1845 vikas 9076 
          self.utx.read(iprot)
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      else:
9080 
        iprot.skip(ftype)
9081 
      iprot.readFieldEnd()
9082 
    iprot.readStructEnd()
9083 
 
9084 
  def write(self, oprot):
9085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9087 
      return
9088 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9089 
    if self.success is not None:
1845 vikas 9090 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9091 
      self.success.write(oprot)
9092 
      oprot.writeFieldEnd()
3431 rajveer 9093 
    if self.utx is not None:
1845 vikas 9094 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9095 
      self.utx.write(oprot)
9096 
      oprot.writeFieldEnd()
9097 
    oprot.writeFieldStop()
9098 
    oprot.writeStructEnd()
9099 
 
3431 rajveer 9100 
  def validate(self):
9101 
    return
9102 
 
9103 
 
1845 vikas 9104 
  def __repr__(self):
9105 
    L = ['%s=%r' % (key, value)
9106 
      for key, value in self.__dict__.iteritems()]
9107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9108 
 
9109 
  def __eq__(self, other):
9110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9111 
 
9112 
  def __ne__(self, other):
9113 
    return not (self == other)
9114 
 
9115 
class createAffiliate_args:
9116 
  """
9117 
  Attributes:
9118 
   - name
9119 
   - url
9120 
   - masterAffiliateId
1859 vikas 9121 
   - addedOn
1845 vikas 9122 
  """
9123 
 
9124 
  thrift_spec = (
9125 
    None, # 0
9126 
    (1, TType.STRING, 'name', None, None, ), # 1
9127 
    (2, TType.STRING, 'url', None, None, ), # 2
9128 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9129 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9130 
  )
9131 
 
1859 vikas 9132 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9133 
    self.name = name
9134 
    self.url = url
9135 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9136 
    self.addedOn = addedOn
1845 vikas 9137 
 
9138 
  def read(self, iprot):
9139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9141 
      return
9142 
    iprot.readStructBegin()
9143 
    while True:
9144 
      (fname, ftype, fid) = iprot.readFieldBegin()
9145 
      if ftype == TType.STOP:
9146 
        break
9147 
      if fid == 1:
9148 
        if ftype == TType.STRING:
9149 
          self.name = iprot.readString();
9150 
        else:
9151 
          iprot.skip(ftype)
9152 
      elif fid == 2:
9153 
        if ftype == TType.STRING:
9154 
          self.url = iprot.readString();
9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      elif fid == 3:
9158 
        if ftype == TType.I64:
9159 
          self.masterAffiliateId = iprot.readI64();
9160 
        else:
9161 
          iprot.skip(ftype)
1859 vikas 9162 
      elif fid == 4:
9163 
        if ftype == TType.I64:
9164 
          self.addedOn = iprot.readI64();
9165 
        else:
9166 
          iprot.skip(ftype)
1845 vikas 9167 
      else:
9168 
        iprot.skip(ftype)
9169 
      iprot.readFieldEnd()
9170 
    iprot.readStructEnd()
9171 
 
9172 
  def write(self, oprot):
9173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9175 
      return
9176 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9177 
    if self.name is not None:
1845 vikas 9178 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9179 
      oprot.writeString(self.name)
9180 
      oprot.writeFieldEnd()
3431 rajveer 9181 
    if self.url is not None:
1845 vikas 9182 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9183 
      oprot.writeString(self.url)
9184 
      oprot.writeFieldEnd()
3431 rajveer 9185 
    if self.masterAffiliateId is not None:
1845 vikas 9186 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9187 
      oprot.writeI64(self.masterAffiliateId)
9188 
      oprot.writeFieldEnd()
3431 rajveer 9189 
    if self.addedOn is not None:
1859 vikas 9190 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9191 
      oprot.writeI64(self.addedOn)
9192 
      oprot.writeFieldEnd()
1845 vikas 9193 
    oprot.writeFieldStop()
9194 
    oprot.writeStructEnd()
9195 
 
3431 rajveer 9196 
  def validate(self):
9197 
    return
9198 
 
9199 
 
1845 vikas 9200 
  def __repr__(self):
9201 
    L = ['%s=%r' % (key, value)
9202 
      for key, value in self.__dict__.iteritems()]
9203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9204 
 
9205 
  def __eq__(self, other):
9206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9207 
 
9208 
  def __ne__(self, other):
9209 
    return not (self == other)
9210 
 
9211 
class createAffiliate_result:
9212 
  """
9213 
  Attributes:
9214 
   - success
9215 
   - utx
9216 
  """
9217 
 
9218 
  thrift_spec = (
9219 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9220 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9221 
  )
9222 
 
9223 
  def __init__(self, success=None, utx=None,):
9224 
    self.success = success
9225 
    self.utx = utx
9226 
 
9227 
  def read(self, iprot):
9228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9230 
      return
9231 
    iprot.readStructBegin()
9232 
    while True:
9233 
      (fname, ftype, fid) = iprot.readFieldBegin()
9234 
      if ftype == TType.STOP:
9235 
        break
9236 
      if fid == 0:
9237 
        if ftype == TType.STRUCT:
9238 
          self.success = Affiliate()
9239 
          self.success.read(iprot)
9240 
        else:
9241 
          iprot.skip(ftype)
9242 
      elif fid == 1:
9243 
        if ftype == TType.STRUCT:
1996 vikas 9244 
          self.utx = UserAffiliateException()
1845 vikas 9245 
          self.utx.read(iprot)
9246 
        else:
9247 
          iprot.skip(ftype)
9248 
      else:
9249 
        iprot.skip(ftype)
9250 
      iprot.readFieldEnd()
9251 
    iprot.readStructEnd()
9252 
 
9253 
  def write(self, oprot):
9254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9256 
      return
9257 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9258 
    if self.success is not None:
1845 vikas 9259 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9260 
      self.success.write(oprot)
9261 
      oprot.writeFieldEnd()
3431 rajveer 9262 
    if self.utx is not None:
1845 vikas 9263 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9264 
      self.utx.write(oprot)
9265 
      oprot.writeFieldEnd()
9266 
    oprot.writeFieldStop()
9267 
    oprot.writeStructEnd()
9268 
 
3431 rajveer 9269 
  def validate(self):
9270 
    return
9271 
 
9272 
 
1845 vikas 9273 
  def __repr__(self):
9274 
    L = ['%s=%r' % (key, value)
9275 
      for key, value in self.__dict__.iteritems()]
9276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9277 
 
9278 
  def __eq__(self, other):
9279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9280 
 
9281 
  def __ne__(self, other):
9282 
    return not (self == other)
9283 
 
9284 
class getAffiliateById_args:
9285 
  """
9286 
  Attributes:
9287 
   - id
9288 
  """
9289 
 
9290 
  thrift_spec = (
9291 
    None, # 0
9292 
    (1, TType.I64, 'id', None, None, ), # 1
9293 
  )
9294 
 
9295 
  def __init__(self, id=None,):
9296 
    self.id = id
9297 
 
9298 
  def read(self, iprot):
9299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9301 
      return
9302 
    iprot.readStructBegin()
9303 
    while True:
9304 
      (fname, ftype, fid) = iprot.readFieldBegin()
9305 
      if ftype == TType.STOP:
9306 
        break
9307 
      if fid == 1:
9308 
        if ftype == TType.I64:
9309 
          self.id = iprot.readI64();
9310 
        else:
9311 
          iprot.skip(ftype)
9312 
      else:
9313 
        iprot.skip(ftype)
9314 
      iprot.readFieldEnd()
9315 
    iprot.readStructEnd()
9316 
 
9317 
  def write(self, oprot):
9318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9320 
      return
9321 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9322 
    if self.id is not None:
1845 vikas 9323 
      oprot.writeFieldBegin('id', TType.I64, 1)
9324 
      oprot.writeI64(self.id)
9325 
      oprot.writeFieldEnd()
9326 
    oprot.writeFieldStop()
9327 
    oprot.writeStructEnd()
9328 
 
3431 rajveer 9329 
  def validate(self):
9330 
    return
9331 
 
9332 
 
1845 vikas 9333 
  def __repr__(self):
9334 
    L = ['%s=%r' % (key, value)
9335 
      for key, value in self.__dict__.iteritems()]
9336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9337 
 
9338 
  def __eq__(self, other):
9339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9340 
 
9341 
  def __ne__(self, other):
9342 
    return not (self == other)
9343 
 
9344 
class getAffiliateById_result:
9345 
  """
9346 
  Attributes:
9347 
   - success
9348 
   - utx
9349 
  """
9350 
 
9351 
  thrift_spec = (
9352 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9353 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9354 
  )
9355 
 
9356 
  def __init__(self, success=None, utx=None,):
9357 
    self.success = success
9358 
    self.utx = utx
9359 
 
9360 
  def read(self, iprot):
9361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9363 
      return
9364 
    iprot.readStructBegin()
9365 
    while True:
9366 
      (fname, ftype, fid) = iprot.readFieldBegin()
9367 
      if ftype == TType.STOP:
9368 
        break
9369 
      if fid == 0:
9370 
        if ftype == TType.STRUCT:
9371 
          self.success = Affiliate()
9372 
          self.success.read(iprot)
9373 
        else:
9374 
          iprot.skip(ftype)
9375 
      elif fid == 1:
9376 
        if ftype == TType.STRUCT:
1996 vikas 9377 
          self.utx = UserAffiliateException()
1845 vikas 9378 
          self.utx.read(iprot)
9379 
        else:
9380 
          iprot.skip(ftype)
9381 
      else:
9382 
        iprot.skip(ftype)
9383 
      iprot.readFieldEnd()
9384 
    iprot.readStructEnd()
9385 
 
9386 
  def write(self, oprot):
9387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9389 
      return
9390 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9391 
    if self.success is not None:
1845 vikas 9392 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9393 
      self.success.write(oprot)
9394 
      oprot.writeFieldEnd()
3431 rajveer 9395 
    if self.utx is not None:
1845 vikas 9396 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9397 
      self.utx.write(oprot)
9398 
      oprot.writeFieldEnd()
9399 
    oprot.writeFieldStop()
9400 
    oprot.writeStructEnd()
9401 
 
3431 rajveer 9402 
  def validate(self):
9403 
    return
9404 
 
9405 
 
1845 vikas 9406 
  def __repr__(self):
9407 
    L = ['%s=%r' % (key, value)
9408 
      for key, value in self.__dict__.iteritems()]
9409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9410 
 
9411 
  def __eq__(self, other):
9412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9413 
 
9414 
  def __ne__(self, other):
9415 
    return not (self == other)
9416 
 
9417 
class getAffiliateByName_args:
9418 
  """
9419 
  Attributes:
9420 
   - name
9421 
  """
9422 
 
9423 
  thrift_spec = (
9424 
    None, # 0
9425 
    (1, TType.STRING, 'name', None, None, ), # 1
9426 
  )
9427 
 
9428 
  def __init__(self, name=None,):
9429 
    self.name = name
9430 
 
9431 
  def read(self, iprot):
9432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9434 
      return
9435 
    iprot.readStructBegin()
9436 
    while True:
9437 
      (fname, ftype, fid) = iprot.readFieldBegin()
9438 
      if ftype == TType.STOP:
9439 
        break
9440 
      if fid == 1:
9441 
        if ftype == TType.STRING:
9442 
          self.name = iprot.readString();
9443 
        else:
9444 
          iprot.skip(ftype)
9445 
      else:
9446 
        iprot.skip(ftype)
9447 
      iprot.readFieldEnd()
9448 
    iprot.readStructEnd()
9449 
 
9450 
  def write(self, oprot):
9451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9453 
      return
9454 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9455 
    if self.name is not None:
1845 vikas 9456 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9457 
      oprot.writeString(self.name)
9458 
      oprot.writeFieldEnd()
9459 
    oprot.writeFieldStop()
9460 
    oprot.writeStructEnd()
9461 
 
3431 rajveer 9462 
  def validate(self):
9463 
    return
9464 
 
9465 
 
1845 vikas 9466 
  def __repr__(self):
9467 
    L = ['%s=%r' % (key, value)
9468 
      for key, value in self.__dict__.iteritems()]
9469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9470 
 
9471 
  def __eq__(self, other):
9472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9473 
 
9474 
  def __ne__(self, other):
9475 
    return not (self == other)
9476 
 
9477 
class getAffiliateByName_result:
9478 
  """
9479 
  Attributes:
9480 
   - success
9481 
   - utx
9482 
  """
9483 
 
9484 
  thrift_spec = (
9485 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9486 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9487 
  )
9488 
 
9489 
  def __init__(self, success=None, utx=None,):
9490 
    self.success = success
9491 
    self.utx = utx
9492 
 
9493 
  def read(self, iprot):
9494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9496 
      return
9497 
    iprot.readStructBegin()
9498 
    while True:
9499 
      (fname, ftype, fid) = iprot.readFieldBegin()
9500 
      if ftype == TType.STOP:
9501 
        break
9502 
      if fid == 0:
9503 
        if ftype == TType.STRUCT:
9504 
          self.success = Affiliate()
9505 
          self.success.read(iprot)
9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      elif fid == 1:
9509 
        if ftype == TType.STRUCT:
1996 vikas 9510 
          self.utx = UserAffiliateException()
1845 vikas 9511 
          self.utx.read(iprot)
9512 
        else:
9513 
          iprot.skip(ftype)
9514 
      else:
9515 
        iprot.skip(ftype)
9516 
      iprot.readFieldEnd()
9517 
    iprot.readStructEnd()
9518 
 
9519 
  def write(self, oprot):
9520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9522 
      return
9523 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9524 
    if self.success is not None:
1845 vikas 9525 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9526 
      self.success.write(oprot)
9527 
      oprot.writeFieldEnd()
3431 rajveer 9528 
    if self.utx is not None:
1845 vikas 9529 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9530 
      self.utx.write(oprot)
9531 
      oprot.writeFieldEnd()
9532 
    oprot.writeFieldStop()
9533 
    oprot.writeStructEnd()
9534 
 
3431 rajveer 9535 
  def validate(self):
9536 
    return
9537 
 
9538 
 
1845 vikas 9539 
  def __repr__(self):
9540 
    L = ['%s=%r' % (key, value)
9541 
      for key, value in self.__dict__.iteritems()]
9542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9543 
 
9544 
  def __eq__(self, other):
9545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9546 
 
9547 
  def __ne__(self, other):
9548 
    return not (self == other)
9549 
 
1996 vikas 9550 
class getTrackerById_args:
1845 vikas 9551 
  """
9552 
  Attributes:
9553 
   - id
9554 
  """
9555 
 
9556 
  thrift_spec = (
9557 
    None, # 0
9558 
    (1, TType.I64, 'id', None, None, ), # 1
9559 
  )
9560 
 
9561 
  def __init__(self, id=None,):
9562 
    self.id = id
9563 
 
9564 
  def read(self, iprot):
9565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9567 
      return
9568 
    iprot.readStructBegin()
9569 
    while True:
9570 
      (fname, ftype, fid) = iprot.readFieldBegin()
9571 
      if ftype == TType.STOP:
9572 
        break
9573 
      if fid == 1:
9574 
        if ftype == TType.I64:
9575 
          self.id = iprot.readI64();
9576 
        else:
9577 
          iprot.skip(ftype)
9578 
      else:
9579 
        iprot.skip(ftype)
9580 
      iprot.readFieldEnd()
9581 
    iprot.readStructEnd()
9582 
 
9583 
  def write(self, oprot):
9584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9586 
      return
1996 vikas 9587 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9588 
    if self.id is not None:
1845 vikas 9589 
      oprot.writeFieldBegin('id', TType.I64, 1)
9590 
      oprot.writeI64(self.id)
9591 
      oprot.writeFieldEnd()
9592 
    oprot.writeFieldStop()
9593 
    oprot.writeStructEnd()
9594 
 
3431 rajveer 9595 
  def validate(self):
9596 
    return
9597 
 
9598 
 
1845 vikas 9599 
  def __repr__(self):
9600 
    L = ['%s=%r' % (key, value)
9601 
      for key, value in self.__dict__.iteritems()]
9602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9603 
 
9604 
  def __eq__(self, other):
9605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9606 
 
9607 
  def __ne__(self, other):
9608 
    return not (self == other)
9609 
 
9610 
class getTrackerById_result:
9611 
  """
9612 
  Attributes:
9613 
   - success
9614 
   - utx
9615 
  """
9616 
 
9617 
  thrift_spec = (
9618 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9619 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9620 
  )
9621 
 
9622 
  def __init__(self, success=None, utx=None,):
9623 
    self.success = success
9624 
    self.utx = utx
9625 
 
9626 
  def read(self, iprot):
9627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9629 
      return
9630 
    iprot.readStructBegin()
9631 
    while True:
9632 
      (fname, ftype, fid) = iprot.readFieldBegin()
9633 
      if ftype == TType.STOP:
9634 
        break
9635 
      if fid == 0:
9636 
        if ftype == TType.STRUCT:
9637 
          self.success = Tracker()
9638 
          self.success.read(iprot)
9639 
        else:
9640 
          iprot.skip(ftype)
9641 
      elif fid == 1:
9642 
        if ftype == TType.STRUCT:
1996 vikas 9643 
          self.utx = UserAffiliateException()
1845 vikas 9644 
          self.utx.read(iprot)
9645 
        else:
9646 
          iprot.skip(ftype)
9647 
      else:
9648 
        iprot.skip(ftype)
9649 
      iprot.readFieldEnd()
9650 
    iprot.readStructEnd()
9651 
 
9652 
  def write(self, oprot):
9653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9655 
      return
9656 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9657 
    if self.success is not None:
1845 vikas 9658 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9659 
      self.success.write(oprot)
9660 
      oprot.writeFieldEnd()
3431 rajveer 9661 
    if self.utx is not None:
1845 vikas 9662 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9663 
      self.utx.write(oprot)
9664 
      oprot.writeFieldEnd()
9665 
    oprot.writeFieldStop()
9666 
    oprot.writeStructEnd()
9667 
 
3431 rajveer 9668 
  def validate(self):
9669 
    return
9670 
 
9671 
 
1845 vikas 9672 
  def __repr__(self):
9673 
    L = ['%s=%r' % (key, value)
9674 
      for key, value in self.__dict__.iteritems()]
9675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9676 
 
9677 
  def __eq__(self, other):
9678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9679 
 
9680 
  def __ne__(self, other):
9681 
    return not (self == other)
9682 
 
1996 vikas 9683 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9684 
  """
9685 
  Attributes:
1996 vikas 9686 
   - id
1845 vikas 9687 
  """
9688 
 
9689 
  thrift_spec = (
9690 
    None, # 0
1996 vikas 9691 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9692 
  )
9693 
 
1996 vikas 9694 
  def __init__(self, id=None,):
9695 
    self.id = id
1845 vikas 9696 
 
9697 
  def read(self, iprot):
9698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9700 
      return
9701 
    iprot.readStructBegin()
9702 
    while True:
9703 
      (fname, ftype, fid) = iprot.readFieldBegin()
9704 
      if ftype == TType.STOP:
9705 
        break
9706 
      if fid == 1:
9707 
        if ftype == TType.I64:
1996 vikas 9708 
          self.id = iprot.readI64();
1845 vikas 9709 
        else:
9710 
          iprot.skip(ftype)
9711 
      else:
9712 
        iprot.skip(ftype)
9713 
      iprot.readFieldEnd()
9714 
    iprot.readStructEnd()
9715 
 
9716 
  def write(self, oprot):
9717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9719 
      return
1996 vikas 9720 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9721 
    if self.id is not None:
1996 vikas 9722 
      oprot.writeFieldBegin('id', TType.I64, 1)
9723 
      oprot.writeI64(self.id)
1845 vikas 9724 
      oprot.writeFieldEnd()
9725 
    oprot.writeFieldStop()
9726 
    oprot.writeStructEnd()
9727 
 
3431 rajveer 9728 
  def validate(self):
9729 
    return
9730 
 
9731 
 
1845 vikas 9732 
  def __repr__(self):
9733 
    L = ['%s=%r' % (key, value)
9734 
      for key, value in self.__dict__.iteritems()]
9735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9736 
 
9737 
  def __eq__(self, other):
9738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9739 
 
9740 
  def __ne__(self, other):
9741 
    return not (self == other)
9742 
 
1996 vikas 9743 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9744 
  """
9745 
  Attributes:
9746 
   - success
9747 
   - utx
9748 
  """
9749 
 
9750 
  thrift_spec = (
1996 vikas 9751 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9752 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9753 
  )
9754 
 
9755 
  def __init__(self, success=None, utx=None,):
9756 
    self.success = success
9757 
    self.utx = utx
9758 
 
9759 
  def read(self, iprot):
9760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9762 
      return
9763 
    iprot.readStructBegin()
9764 
    while True:
9765 
      (fname, ftype, fid) = iprot.readFieldBegin()
9766 
      if ftype == TType.STOP:
9767 
        break
9768 
      if fid == 0:
9769 
        if ftype == TType.LIST:
9770 
          self.success = []
11592 amit.gupta 9771 
          (_etype128, _size125) = iprot.readListBegin()
9772 
          for _i129 in xrange(_size125):
9773 
            _elem130 = Affiliate()
9774 
            _elem130.read(iprot)
9775 
            self.success.append(_elem130)
1845 vikas 9776 
          iprot.readListEnd()
9777 
        else:
9778 
          iprot.skip(ftype)
9779 
      elif fid == 1:
9780 
        if ftype == TType.STRUCT:
1996 vikas 9781 
          self.utx = UserAffiliateException()
1845 vikas 9782 
          self.utx.read(iprot)
9783 
        else:
9784 
          iprot.skip(ftype)
9785 
      else:
9786 
        iprot.skip(ftype)
9787 
      iprot.readFieldEnd()
9788 
    iprot.readStructEnd()
9789 
 
9790 
  def write(self, oprot):
9791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9793 
      return
1996 vikas 9794 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9795 
    if self.success is not None:
1845 vikas 9796 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9797 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9798 
      for iter131 in self.success:
9799 
        iter131.write(oprot)
1845 vikas 9800 
      oprot.writeListEnd()
9801 
      oprot.writeFieldEnd()
3431 rajveer 9802 
    if self.utx is not None:
1845 vikas 9803 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9804 
      self.utx.write(oprot)
9805 
      oprot.writeFieldEnd()
9806 
    oprot.writeFieldStop()
9807 
    oprot.writeStructEnd()
9808 
 
3431 rajveer 9809 
  def validate(self):
9810 
    return
9811 
 
9812 
 
1845 vikas 9813 
  def __repr__(self):
9814 
    L = ['%s=%r' % (key, value)
9815 
      for key, value in self.__dict__.iteritems()]
9816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9817 
 
9818 
  def __eq__(self, other):
9819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9820 
 
9821 
  def __ne__(self, other):
9822 
    return not (self == other)
9823 
 
9824 
class addTrackLog_args:
9825 
  """
9826 
  Attributes:
1996 vikas 9827 
   - affiliateId
1845 vikas 9828 
   - userId
9829 
   - event
9830 
   - url
9831 
   - data
1859 vikas 9832 
   - addedOn
1845 vikas 9833 
  """
9834 
 
9835 
  thrift_spec = (
9836 
    None, # 0
1996 vikas 9837 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9838 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9839 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9840 
    (4, TType.STRING, 'url', None, None, ), # 4
9841 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9842 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9843 
  )
9844 
 
1996 vikas 9845 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9846 
    self.affiliateId = affiliateId
1845 vikas 9847 
    self.userId = userId
9848 
    self.event = event
9849 
    self.url = url
9850 
    self.data = data
1859 vikas 9851 
    self.addedOn = addedOn
1845 vikas 9852 
 
9853 
  def read(self, iprot):
9854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9856 
      return
9857 
    iprot.readStructBegin()
9858 
    while True:
9859 
      (fname, ftype, fid) = iprot.readFieldBegin()
9860 
      if ftype == TType.STOP:
9861 
        break
9862 
      if fid == 1:
9863 
        if ftype == TType.I64:
1996 vikas 9864 
          self.affiliateId = iprot.readI64();
1845 vikas 9865 
        else:
9866 
          iprot.skip(ftype)
9867 
      elif fid == 2:
9868 
        if ftype == TType.I64:
9869 
          self.userId = iprot.readI64();
9870 
        else:
9871 
          iprot.skip(ftype)
9872 
      elif fid == 3:
3378 vikas 9873 
        if ftype == TType.I32:
9874 
          self.event = iprot.readI32();
1845 vikas 9875 
        else:
9876 
          iprot.skip(ftype)
9877 
      elif fid == 4:
9878 
        if ftype == TType.STRING:
9879 
          self.url = iprot.readString();
9880 
        else:
9881 
          iprot.skip(ftype)
9882 
      elif fid == 5:
9883 
        if ftype == TType.STRING:
9884 
          self.data = iprot.readString();
9885 
        else:
9886 
          iprot.skip(ftype)
1859 vikas 9887 
      elif fid == 6:
9888 
        if ftype == TType.I64:
9889 
          self.addedOn = iprot.readI64();
9890 
        else:
9891 
          iprot.skip(ftype)
1845 vikas 9892 
      else:
9893 
        iprot.skip(ftype)
9894 
      iprot.readFieldEnd()
9895 
    iprot.readStructEnd()
9896 
 
9897 
  def write(self, oprot):
9898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9900 
      return
9901 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9902 
    if self.affiliateId is not None:
1996 vikas 9903 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9904 
      oprot.writeI64(self.affiliateId)
1845 vikas 9905 
      oprot.writeFieldEnd()
3431 rajveer 9906 
    if self.userId is not None:
1845 vikas 9907 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9908 
      oprot.writeI64(self.userId)
9909 
      oprot.writeFieldEnd()
3431 rajveer 9910 
    if self.event is not None:
3378 vikas 9911 
      oprot.writeFieldBegin('event', TType.I32, 3)
9912 
      oprot.writeI32(self.event)
1845 vikas 9913 
      oprot.writeFieldEnd()
3431 rajveer 9914 
    if self.url is not None:
1845 vikas 9915 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9916 
      oprot.writeString(self.url)
9917 
      oprot.writeFieldEnd()
3431 rajveer 9918 
    if self.data is not None:
1845 vikas 9919 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9920 
      oprot.writeString(self.data)
9921 
      oprot.writeFieldEnd()
3431 rajveer 9922 
    if self.addedOn is not None:
1859 vikas 9923 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9924 
      oprot.writeI64(self.addedOn)
9925 
      oprot.writeFieldEnd()
1845 vikas 9926 
    oprot.writeFieldStop()
9927 
    oprot.writeStructEnd()
9928 
 
3431 rajveer 9929 
  def validate(self):
9930 
    return
9931 
 
9932 
 
1845 vikas 9933 
  def __repr__(self):
9934 
    L = ['%s=%r' % (key, value)
9935 
      for key, value in self.__dict__.iteritems()]
9936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9937 
 
9938 
  def __eq__(self, other):
9939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9940 
 
9941 
  def __ne__(self, other):
9942 
    return not (self == other)
9943 
 
9944 
class addTrackLog_result:
9945 
  """
9946 
  Attributes:
9947 
   - success
9948 
   - utx
9949 
  """
9950 
 
9951 
  thrift_spec = (
9952 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9953 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9954 
  )
9955 
 
9956 
  def __init__(self, success=None, utx=None,):
9957 
    self.success = success
9958 
    self.utx = utx
9959 
 
9960 
  def read(self, iprot):
9961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9963 
      return
9964 
    iprot.readStructBegin()
9965 
    while True:
9966 
      (fname, ftype, fid) = iprot.readFieldBegin()
9967 
      if ftype == TType.STOP:
9968 
        break
9969 
      if fid == 0:
9970 
        if ftype == TType.I64:
9971 
          self.success = iprot.readI64();
9972 
        else:
9973 
          iprot.skip(ftype)
9974 
      elif fid == 1:
9975 
        if ftype == TType.STRUCT:
1996 vikas 9976 
          self.utx = UserAffiliateException()
1845 vikas 9977 
          self.utx.read(iprot)
9978 
        else:
9979 
          iprot.skip(ftype)
9980 
      else:
9981 
        iprot.skip(ftype)
9982 
      iprot.readFieldEnd()
9983 
    iprot.readStructEnd()
9984 
 
9985 
  def write(self, oprot):
9986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9988 
      return
9989 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9990 
    if self.success is not None:
1845 vikas 9991 
      oprot.writeFieldBegin('success', TType.I64, 0)
9992 
      oprot.writeI64(self.success)
9993 
      oprot.writeFieldEnd()
3431 rajveer 9994 
    if self.utx is not None:
1845 vikas 9995 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9996 
      self.utx.write(oprot)
9997 
      oprot.writeFieldEnd()
9998 
    oprot.writeFieldStop()
9999 
    oprot.writeStructEnd()
10000 
 
3431 rajveer 10001 
  def validate(self):
10002 
    return
10003 
 
10004 
 
1845 vikas 10005 
  def __repr__(self):
10006 
    L = ['%s=%r' % (key, value)
10007 
      for key, value in self.__dict__.iteritems()]
10008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10009 
 
10010 
  def __eq__(self, other):
10011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10012 
 
10013 
  def __ne__(self, other):
10014 
    return not (self == other)
10015 
 
10016 
class getTrackLogById_args:
10017 
  """
10018 
  Attributes:
10019 
   - id
10020 
  """
10021 
 
10022 
  thrift_spec = (
10023 
    None, # 0
10024 
    (1, TType.I64, 'id', None, None, ), # 1
10025 
  )
10026 
 
10027 
  def __init__(self, id=None,):
10028 
    self.id = id
10029 
 
10030 
  def read(self, iprot):
10031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10033 
      return
10034 
    iprot.readStructBegin()
10035 
    while True:
10036 
      (fname, ftype, fid) = iprot.readFieldBegin()
10037 
      if ftype == TType.STOP:
10038 
        break
10039 
      if fid == 1:
10040 
        if ftype == TType.I64:
10041 
          self.id = iprot.readI64();
10042 
        else:
10043 
          iprot.skip(ftype)
10044 
      else:
10045 
        iprot.skip(ftype)
10046 
      iprot.readFieldEnd()
10047 
    iprot.readStructEnd()
10048 
 
10049 
  def write(self, oprot):
10050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10052 
      return
10053 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10054 
    if self.id is not None:
1845 vikas 10055 
      oprot.writeFieldBegin('id', TType.I64, 1)
10056 
      oprot.writeI64(self.id)
10057 
      oprot.writeFieldEnd()
10058 
    oprot.writeFieldStop()
10059 
    oprot.writeStructEnd()
10060 
 
3431 rajveer 10061 
  def validate(self):
10062 
    return
10063 
 
10064 
 
1845 vikas 10065 
  def __repr__(self):
10066 
    L = ['%s=%r' % (key, value)
10067 
      for key, value in self.__dict__.iteritems()]
10068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10069 
 
10070 
  def __eq__(self, other):
10071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10072 
 
10073 
  def __ne__(self, other):
10074 
    return not (self == other)
10075 
 
10076 
class getTrackLogById_result:
10077 
  """
10078 
  Attributes:
10079 
   - success
10080 
   - utx
10081 
  """
10082 
 
10083 
  thrift_spec = (
10084 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10085 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10086 
  )
10087 
 
10088 
  def __init__(self, success=None, utx=None,):
10089 
    self.success = success
10090 
    self.utx = utx
10091 
 
10092 
  def read(self, iprot):
10093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10095 
      return
10096 
    iprot.readStructBegin()
10097 
    while True:
10098 
      (fname, ftype, fid) = iprot.readFieldBegin()
10099 
      if ftype == TType.STOP:
10100 
        break
10101 
      if fid == 0:
10102 
        if ftype == TType.STRUCT:
10103 
          self.success = TrackLog()
10104 
          self.success.read(iprot)
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      elif fid == 1:
10108 
        if ftype == TType.STRUCT:
1996 vikas 10109 
          self.utx = UserAffiliateException()
1845 vikas 10110 
          self.utx.read(iprot)
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      else:
10114 
        iprot.skip(ftype)
10115 
      iprot.readFieldEnd()
10116 
    iprot.readStructEnd()
10117 
 
10118 
  def write(self, oprot):
10119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10121 
      return
10122 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10123 
    if self.success is not None:
1845 vikas 10124 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10125 
      self.success.write(oprot)
10126 
      oprot.writeFieldEnd()
3431 rajveer 10127 
    if self.utx is not None:
1845 vikas 10128 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10129 
      self.utx.write(oprot)
10130 
      oprot.writeFieldEnd()
10131 
    oprot.writeFieldStop()
10132 
    oprot.writeStructEnd()
10133 
 
3431 rajveer 10134 
  def validate(self):
10135 
    return
10136 
 
10137 
 
1845 vikas 10138 
  def __repr__(self):
10139 
    L = ['%s=%r' % (key, value)
10140 
      for key, value in self.__dict__.iteritems()]
10141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10142 
 
10143 
  def __eq__(self, other):
10144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10145 
 
10146 
  def __ne__(self, other):
10147 
    return not (self == other)
10148 
 
1996 vikas 10149 
class getTrackLogsByAffiliate_args:
1845 vikas 10150 
  """
10151 
  Attributes:
1996 vikas 10152 
   - affiliateId
3293 vikas 10153 
   - startDate
10154 
   - endDate
1845 vikas 10155 
  """
10156 
 
10157 
  thrift_spec = (
10158 
    None, # 0
1996 vikas 10159 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10160 
    (2, TType.I64, 'startDate', None, None, ), # 2
10161 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10162 
  )
10163 
 
3293 vikas 10164 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10165 
    self.affiliateId = affiliateId
3293 vikas 10166 
    self.startDate = startDate
10167 
    self.endDate = endDate
1845 vikas 10168 
 
10169 
  def read(self, iprot):
10170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10172 
      return
10173 
    iprot.readStructBegin()
10174 
    while True:
10175 
      (fname, ftype, fid) = iprot.readFieldBegin()
10176 
      if ftype == TType.STOP:
10177 
        break
10178 
      if fid == 1:
10179 
        if ftype == TType.I64:
1996 vikas 10180 
          self.affiliateId = iprot.readI64();
1845 vikas 10181 
        else:
10182 
          iprot.skip(ftype)
3293 vikas 10183 
      elif fid == 2:
10184 
        if ftype == TType.I64:
10185 
          self.startDate = iprot.readI64();
10186 
        else:
10187 
          iprot.skip(ftype)
10188 
      elif fid == 3:
10189 
        if ftype == TType.I64:
10190 
          self.endDate = iprot.readI64();
10191 
        else:
10192 
          iprot.skip(ftype)
1845 vikas 10193 
      else:
10194 
        iprot.skip(ftype)
10195 
      iprot.readFieldEnd()
10196 
    iprot.readStructEnd()
10197 
 
10198 
  def write(self, oprot):
10199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10201 
      return
1996 vikas 10202 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10203 
    if self.affiliateId is not None:
1996 vikas 10204 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10205 
      oprot.writeI64(self.affiliateId)
1845 vikas 10206 
      oprot.writeFieldEnd()
3431 rajveer 10207 
    if self.startDate is not None:
3293 vikas 10208 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10209 
      oprot.writeI64(self.startDate)
10210 
      oprot.writeFieldEnd()
3431 rajveer 10211 
    if self.endDate is not None:
3293 vikas 10212 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10213 
      oprot.writeI64(self.endDate)
10214 
      oprot.writeFieldEnd()
1845 vikas 10215 
    oprot.writeFieldStop()
10216 
    oprot.writeStructEnd()
10217 
 
3431 rajveer 10218 
  def validate(self):
10219 
    return
10220 
 
10221 
 
1845 vikas 10222 
  def __repr__(self):
10223 
    L = ['%s=%r' % (key, value)
10224 
      for key, value in self.__dict__.iteritems()]
10225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10226 
 
10227 
  def __eq__(self, other):
10228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10229 
 
10230 
  def __ne__(self, other):
10231 
    return not (self == other)
10232 
 
1996 vikas 10233 
class getTrackLogsByAffiliate_result:
1845 vikas 10234 
  """
10235 
  Attributes:
10236 
   - success
10237 
   - utx
10238 
  """
10239 
 
10240 
  thrift_spec = (
10241 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10242 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10243 
  )
10244 
 
10245 
  def __init__(self, success=None, utx=None,):
10246 
    self.success = success
10247 
    self.utx = utx
10248 
 
10249 
  def read(self, iprot):
10250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10252 
      return
10253 
    iprot.readStructBegin()
10254 
    while True:
10255 
      (fname, ftype, fid) = iprot.readFieldBegin()
10256 
      if ftype == TType.STOP:
10257 
        break
10258 
      if fid == 0:
10259 
        if ftype == TType.LIST:
10260 
          self.success = []
11592 amit.gupta 10261 
          (_etype135, _size132) = iprot.readListBegin()
10262 
          for _i136 in xrange(_size132):
10263 
            _elem137 = TrackLog()
10264 
            _elem137.read(iprot)
10265 
            self.success.append(_elem137)
1845 vikas 10266 
          iprot.readListEnd()
10267 
        else:
10268 
          iprot.skip(ftype)
10269 
      elif fid == 1:
10270 
        if ftype == TType.STRUCT:
1996 vikas 10271 
          self.utx = UserAffiliateException()
1845 vikas 10272 
          self.utx.read(iprot)
10273 
        else:
10274 
          iprot.skip(ftype)
10275 
      else:
10276 
        iprot.skip(ftype)
10277 
      iprot.readFieldEnd()
10278 
    iprot.readStructEnd()
10279 
 
10280 
  def write(self, oprot):
10281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10283 
      return
1996 vikas 10284 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10285 
    if self.success is not None:
1845 vikas 10286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10287 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10288 
      for iter138 in self.success:
10289 
        iter138.write(oprot)
1845 vikas 10290 
      oprot.writeListEnd()
10291 
      oprot.writeFieldEnd()
3431 rajveer 10292 
    if self.utx is not None:
1845 vikas 10293 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10294 
      self.utx.write(oprot)
10295 
      oprot.writeFieldEnd()
10296 
    oprot.writeFieldStop()
10297 
    oprot.writeStructEnd()
10298 
 
3431 rajveer 10299 
  def validate(self):
10300 
    return
10301 
 
10302 
 
1845 vikas 10303 
  def __repr__(self):
10304 
    L = ['%s=%r' % (key, value)
10305 
      for key, value in self.__dict__.iteritems()]
10306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10307 
 
10308 
  def __eq__(self, other):
10309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10310 
 
10311 
  def __ne__(self, other):
10312 
    return not (self == other)
10313 
 
10314 
class getTrackLogsByUser_args:
10315 
  """
10316 
  Attributes:
10317 
   - userId
10318 
  """
10319 
 
10320 
  thrift_spec = (
10321 
    None, # 0
10322 
    (1, TType.I64, 'userId', None, None, ), # 1
10323 
  )
10324 
 
10325 
  def __init__(self, userId=None,):
10326 
    self.userId = userId
10327 
 
10328 
  def read(self, iprot):
10329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10331 
      return
10332 
    iprot.readStructBegin()
10333 
    while True:
10334 
      (fname, ftype, fid) = iprot.readFieldBegin()
10335 
      if ftype == TType.STOP:
10336 
        break
10337 
      if fid == 1:
10338 
        if ftype == TType.I64:
10339 
          self.userId = iprot.readI64();
10340 
        else:
10341 
          iprot.skip(ftype)
10342 
      else:
10343 
        iprot.skip(ftype)
10344 
      iprot.readFieldEnd()
10345 
    iprot.readStructEnd()
10346 
 
10347 
  def write(self, oprot):
10348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10350 
      return
10351 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10352 
    if self.userId is not None:
1845 vikas 10353 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10354 
      oprot.writeI64(self.userId)
10355 
      oprot.writeFieldEnd()
10356 
    oprot.writeFieldStop()
10357 
    oprot.writeStructEnd()
10358 
 
3431 rajveer 10359 
  def validate(self):
10360 
    return
10361 
 
10362 
 
1845 vikas 10363 
  def __repr__(self):
10364 
    L = ['%s=%r' % (key, value)
10365 
      for key, value in self.__dict__.iteritems()]
10366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10367 
 
10368 
  def __eq__(self, other):
10369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10370 
 
10371 
  def __ne__(self, other):
10372 
    return not (self == other)
10373 
 
10374 
class getTrackLogsByUser_result:
10375 
  """
10376 
  Attributes:
10377 
   - success
10378 
   - utx
10379 
  """
10380 
 
10381 
  thrift_spec = (
10382 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10383 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10384 
  )
10385 
 
10386 
  def __init__(self, success=None, utx=None,):
10387 
    self.success = success
10388 
    self.utx = utx
10389 
 
10390 
  def read(self, iprot):
10391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10393 
      return
10394 
    iprot.readStructBegin()
10395 
    while True:
10396 
      (fname, ftype, fid) = iprot.readFieldBegin()
10397 
      if ftype == TType.STOP:
10398 
        break
10399 
      if fid == 0:
10400 
        if ftype == TType.LIST:
10401 
          self.success = []
11592 amit.gupta 10402 
          (_etype142, _size139) = iprot.readListBegin()
10403 
          for _i143 in xrange(_size139):
10404 
            _elem144 = TrackLog()
10405 
            _elem144.read(iprot)
10406 
            self.success.append(_elem144)
1845 vikas 10407 
          iprot.readListEnd()
10408 
        else:
10409 
          iprot.skip(ftype)
10410 
      elif fid == 1:
10411 
        if ftype == TType.STRUCT:
1996 vikas 10412 
          self.utx = UserAffiliateException()
1845 vikas 10413 
          self.utx.read(iprot)
10414 
        else:
10415 
          iprot.skip(ftype)
10416 
      else:
10417 
        iprot.skip(ftype)
10418 
      iprot.readFieldEnd()
10419 
    iprot.readStructEnd()
10420 
 
10421 
  def write(self, oprot):
10422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10424 
      return
10425 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10426 
    if self.success is not None:
1845 vikas 10427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10428 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10429 
      for iter145 in self.success:
10430 
        iter145.write(oprot)
1845 vikas 10431 
      oprot.writeListEnd()
10432 
      oprot.writeFieldEnd()
3431 rajveer 10433 
    if self.utx is not None:
1845 vikas 10434 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10435 
      self.utx.write(oprot)
10436 
      oprot.writeFieldEnd()
10437 
    oprot.writeFieldStop()
10438 
    oprot.writeStructEnd()
10439 
 
3431 rajveer 10440 
  def validate(self):
10441 
    return
10442 
 
10443 
 
1845 vikas 10444 
  def __repr__(self):
10445 
    L = ['%s=%r' % (key, value)
10446 
      for key, value in self.__dict__.iteritems()]
10447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10448 
 
10449 
  def __eq__(self, other):
10450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10451 
 
10452 
  def __ne__(self, other):
10453 
    return not (self == other)
10454 
 
10455 
class getTrackLogs_args:
10456 
  """
10457 
  Attributes:
10458 
   - userId
10459 
   - event
10460 
   - url
10461 
  """
10462 
 
10463 
  thrift_spec = (
10464 
    None, # 0
1996 vikas 10465 
    (1, TType.I64, 'userId', None, None, ), # 1
10466 
    (2, TType.STRING, 'event', None, None, ), # 2
10467 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10468 
  )
10469 
 
1996 vikas 10470 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10471 
    self.userId = userId
10472 
    self.event = event
10473 
    self.url = url
10474 
 
10475 
  def read(self, iprot):
10476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10478 
      return
10479 
    iprot.readStructBegin()
10480 
    while True:
10481 
      (fname, ftype, fid) = iprot.readFieldBegin()
10482 
      if ftype == TType.STOP:
10483 
        break
10484 
      if fid == 1:
10485 
        if ftype == TType.I64:
1996 vikas 10486 
          self.userId = iprot.readI64();
1845 vikas 10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 2:
10490 
        if ftype == TType.STRING:
10491 
          self.event = iprot.readString();
10492 
        else:
10493 
          iprot.skip(ftype)
1996 vikas 10494 
      elif fid == 3:
1845 vikas 10495 
        if ftype == TType.STRING:
10496 
          self.url = iprot.readString();
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      else:
10500 
        iprot.skip(ftype)
10501 
      iprot.readFieldEnd()
10502 
    iprot.readStructEnd()
10503 
 
10504 
  def write(self, oprot):
10505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10507 
      return
10508 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10509 
    if self.userId is not None:
1996 vikas 10510 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10511 
      oprot.writeI64(self.userId)
10512 
      oprot.writeFieldEnd()
3431 rajveer 10513 
    if self.event is not None:
1996 vikas 10514 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10515 
      oprot.writeString(self.event)
10516 
      oprot.writeFieldEnd()
3431 rajveer 10517 
    if self.url is not None:
1996 vikas 10518 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10519 
      oprot.writeString(self.url)
10520 
      oprot.writeFieldEnd()
10521 
    oprot.writeFieldStop()
10522 
    oprot.writeStructEnd()
10523 
 
3431 rajveer 10524 
  def validate(self):
10525 
    return
10526 
 
10527 
 
1845 vikas 10528 
  def __repr__(self):
10529 
    L = ['%s=%r' % (key, value)
10530 
      for key, value in self.__dict__.iteritems()]
10531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10532 
 
10533 
  def __eq__(self, other):
10534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10535 
 
10536 
  def __ne__(self, other):
10537 
    return not (self == other)
10538 
 
10539 
class getTrackLogs_result:
10540 
  """
10541 
  Attributes:
10542 
   - success
10543 
   - utx
10544 
  """
10545 
 
10546 
  thrift_spec = (
10547 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10548 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10549 
  )
10550 
 
10551 
  def __init__(self, success=None, utx=None,):
10552 
    self.success = success
10553 
    self.utx = utx
10554 
 
10555 
  def read(self, iprot):
10556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10558 
      return
10559 
    iprot.readStructBegin()
10560 
    while True:
10561 
      (fname, ftype, fid) = iprot.readFieldBegin()
10562 
      if ftype == TType.STOP:
10563 
        break
10564 
      if fid == 0:
10565 
        if ftype == TType.LIST:
10566 
          self.success = []
11592 amit.gupta 10567 
          (_etype149, _size146) = iprot.readListBegin()
10568 
          for _i150 in xrange(_size146):
10569 
            _elem151 = TrackLog()
10570 
            _elem151.read(iprot)
10571 
            self.success.append(_elem151)
1845 vikas 10572 
          iprot.readListEnd()
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      elif fid == 1:
10576 
        if ftype == TType.STRUCT:
1996 vikas 10577 
          self.utx = UserAffiliateException()
1845 vikas 10578 
          self.utx.read(iprot)
10579 
        else:
10580 
          iprot.skip(ftype)
10581 
      else:
10582 
        iprot.skip(ftype)
10583 
      iprot.readFieldEnd()
10584 
    iprot.readStructEnd()
10585 
 
10586 
  def write(self, oprot):
10587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10589 
      return
10590 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10591 
    if self.success is not None:
1845 vikas 10592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10593 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10594 
      for iter152 in self.success:
10595 
        iter152.write(oprot)
1845 vikas 10596 
      oprot.writeListEnd()
10597 
      oprot.writeFieldEnd()
3431 rajveer 10598 
    if self.utx is not None:
1845 vikas 10599 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10600 
      self.utx.write(oprot)
10601 
      oprot.writeFieldEnd()
10602 
    oprot.writeFieldStop()
10603 
    oprot.writeStructEnd()
10604 
 
3431 rajveer 10605 
  def validate(self):
10606 
    return
10607 
 
10608 
 
1845 vikas 10609 
  def __repr__(self):
10610 
    L = ['%s=%r' % (key, value)
10611 
      for key, value in self.__dict__.iteritems()]
10612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10613 
 
10614 
  def __eq__(self, other):
10615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10616 
 
10617 
  def __ne__(self, other):
10618 
    return not (self == other)
10619 
 
559 chandransh 10620 
class getCurrentCart_args:
94 ashish 10621 
  """
10622 
  Attributes:
559 chandransh 10623 
   - userId
10624 
  """
10625 
 
10626 
  thrift_spec = (
10627 
    None, # 0
10628 
    (1, TType.I64, 'userId', None, None, ), # 1
10629 
  )
10630 
 
10631 
  def __init__(self, userId=None,):
10632 
    self.userId = userId
10633 
 
10634 
  def read(self, iprot):
10635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10637 
      return
10638 
    iprot.readStructBegin()
10639 
    while True:
10640 
      (fname, ftype, fid) = iprot.readFieldBegin()
10641 
      if ftype == TType.STOP:
10642 
        break
10643 
      if fid == 1:
10644 
        if ftype == TType.I64:
10645 
          self.userId = iprot.readI64();
10646 
        else:
10647 
          iprot.skip(ftype)
10648 
      else:
10649 
        iprot.skip(ftype)
10650 
      iprot.readFieldEnd()
10651 
    iprot.readStructEnd()
10652 
 
10653 
  def write(self, oprot):
10654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10656 
      return
10657 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10658 
    if self.userId is not None:
559 chandransh 10659 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10660 
      oprot.writeI64(self.userId)
10661 
      oprot.writeFieldEnd()
10662 
    oprot.writeFieldStop()
10663 
    oprot.writeStructEnd()
10664 
 
3431 rajveer 10665 
  def validate(self):
10666 
    return
10667 
 
10668 
 
559 chandransh 10669 
  def __repr__(self):
10670 
    L = ['%s=%r' % (key, value)
10671 
      for key, value in self.__dict__.iteritems()]
10672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10673 
 
10674 
  def __eq__(self, other):
10675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10676 
 
10677 
  def __ne__(self, other):
10678 
    return not (self == other)
10679 
 
10680 
class getCurrentCart_result:
10681 
  """
10682 
  Attributes:
94 ashish 10683 
   - success
559 chandransh 10684 
   - scx
94 ashish 10685 
  """
10686 
 
10687 
  thrift_spec = (
559 chandransh 10688 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10689 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10690 
  )
10691 
 
559 chandransh 10692 
  def __init__(self, success=None, scx=None,):
94 ashish 10693 
    self.success = success
559 chandransh 10694 
    self.scx = scx
94 ashish 10695 
 
10696 
  def read(self, iprot):
10697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10699 
      return
10700 
    iprot.readStructBegin()
10701 
    while True:
10702 
      (fname, ftype, fid) = iprot.readFieldBegin()
10703 
      if ftype == TType.STOP:
10704 
        break
10705 
      if fid == 0:
559 chandransh 10706 
        if ftype == TType.STRUCT:
10707 
          self.success = Cart()
10708 
          self.success.read(iprot)
94 ashish 10709 
        else:
10710 
          iprot.skip(ftype)
10711 
      elif fid == 1:
10712 
        if ftype == TType.STRUCT:
559 chandransh 10713 
          self.scx = ShoppingCartException()
10714 
          self.scx.read(iprot)
94 ashish 10715 
        else:
10716 
          iprot.skip(ftype)
10717 
      else:
10718 
        iprot.skip(ftype)
10719 
      iprot.readFieldEnd()
10720 
    iprot.readStructEnd()
10721 
 
10722 
  def write(self, oprot):
10723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10725 
      return
559 chandransh 10726 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10727 
    if self.success is not None:
559 chandransh 10728 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10729 
      self.success.write(oprot)
94 ashish 10730 
      oprot.writeFieldEnd()
3431 rajveer 10731 
    if self.scx is not None:
559 chandransh 10732 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10733 
      self.scx.write(oprot)
94 ashish 10734 
      oprot.writeFieldEnd()
10735 
    oprot.writeFieldStop()
10736 
    oprot.writeStructEnd()
10737 
 
3431 rajveer 10738 
  def validate(self):
10739 
    return
10740 
 
10741 
 
94 ashish 10742 
  def __repr__(self):
10743 
    L = ['%s=%r' % (key, value)
10744 
      for key, value in self.__dict__.iteritems()]
10745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10746 
 
10747 
  def __eq__(self, other):
10748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10749 
 
10750 
  def __ne__(self, other):
10751 
    return not (self == other)
10752 
 
559 chandransh 10753 
class getCart_args:
504 rajveer 10754 
  """
10755 
  Attributes:
559 chandransh 10756 
   - cartId
504 rajveer 10757 
  """
10758 
 
10759 
  thrift_spec = (
10760 
    None, # 0
559 chandransh 10761 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10762 
  )
10763 
 
559 chandransh 10764 
  def __init__(self, cartId=None,):
10765 
    self.cartId = cartId
504 rajveer 10766 
 
10767 
  def read(self, iprot):
10768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10770 
      return
10771 
    iprot.readStructBegin()
10772 
    while True:
10773 
      (fname, ftype, fid) = iprot.readFieldBegin()
10774 
      if ftype == TType.STOP:
10775 
        break
10776 
      if fid == 1:
10777 
        if ftype == TType.I64:
559 chandransh 10778 
          self.cartId = iprot.readI64();
504 rajveer 10779 
        else:
10780 
          iprot.skip(ftype)
10781 
      else:
10782 
        iprot.skip(ftype)
10783 
      iprot.readFieldEnd()
10784 
    iprot.readStructEnd()
10785 
 
10786 
  def write(self, oprot):
10787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10789 
      return
559 chandransh 10790 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10791 
    if self.cartId is not None:
559 chandransh 10792 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10793 
      oprot.writeI64(self.cartId)
504 rajveer 10794 
      oprot.writeFieldEnd()
10795 
    oprot.writeFieldStop()
10796 
    oprot.writeStructEnd()
10797 
 
3431 rajveer 10798 
  def validate(self):
10799 
    return
10800 
 
10801 
 
504 rajveer 10802 
  def __repr__(self):
10803 
    L = ['%s=%r' % (key, value)
10804 
      for key, value in self.__dict__.iteritems()]
10805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10806 
 
10807 
  def __eq__(self, other):
10808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10809 
 
10810 
  def __ne__(self, other):
10811 
    return not (self == other)
10812 
 
559 chandransh 10813 
class getCart_result:
504 rajveer 10814 
  """
10815 
  Attributes:
10816 
   - success
559 chandransh 10817 
   - scx
504 rajveer 10818 
  """
10819 
 
10820 
  thrift_spec = (
559 chandransh 10821 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10822 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10823 
  )
10824 
 
559 chandransh 10825 
  def __init__(self, success=None, scx=None,):
504 rajveer 10826 
    self.success = success
559 chandransh 10827 
    self.scx = scx
504 rajveer 10828 
 
10829 
  def read(self, iprot):
10830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10832 
      return
10833 
    iprot.readStructBegin()
10834 
    while True:
10835 
      (fname, ftype, fid) = iprot.readFieldBegin()
10836 
      if ftype == TType.STOP:
10837 
        break
10838 
      if fid == 0:
559 chandransh 10839 
        if ftype == TType.STRUCT:
10840 
          self.success = Cart()
10841 
          self.success.read(iprot)
504 rajveer 10842 
        else:
10843 
          iprot.skip(ftype)
10844 
      elif fid == 1:
10845 
        if ftype == TType.STRUCT:
559 chandransh 10846 
          self.scx = ShoppingCartException()
10847 
          self.scx.read(iprot)
504 rajveer 10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      else:
10851 
        iprot.skip(ftype)
10852 
      iprot.readFieldEnd()
10853 
    iprot.readStructEnd()
10854 
 
10855 
  def write(self, oprot):
10856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10858 
      return
559 chandransh 10859 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10860 
    if self.success is not None:
559 chandransh 10861 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10862 
      self.success.write(oprot)
504 rajveer 10863 
      oprot.writeFieldEnd()
3431 rajveer 10864 
    if self.scx is not None:
559 chandransh 10865 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10866 
      self.scx.write(oprot)
504 rajveer 10867 
      oprot.writeFieldEnd()
10868 
    oprot.writeFieldStop()
10869 
    oprot.writeStructEnd()
10870 
 
3431 rajveer 10871 
  def validate(self):
10872 
    return
10873 
 
10874 
 
504 rajveer 10875 
  def __repr__(self):
10876 
    L = ['%s=%r' % (key, value)
10877 
      for key, value in self.__dict__.iteritems()]
10878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10879 
 
10880 
  def __eq__(self, other):
10881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10882 
 
10883 
  def __ne__(self, other):
10884 
    return not (self == other)
10885 
 
559 chandransh 10886 
class getCartsByTime_args:
10887 
  """
10888 
  Attributes:
10889 
   - from_time
10890 
   - to_time
10891 
   - status
10892 
  """
10893 
 
10894 
  thrift_spec = (
10895 
    None, # 0
10896 
    (1, TType.I64, 'from_time', None, None, ), # 1
10897 
    (2, TType.I64, 'to_time', None, None, ), # 2
10898 
    (3, TType.I32, 'status', None, None, ), # 3
10899 
  )
10900 
 
10901 
  def __init__(self, from_time=None, to_time=None, status=None,):
10902 
    self.from_time = from_time
10903 
    self.to_time = to_time
10904 
    self.status = status
10905 
 
10906 
  def read(self, iprot):
10907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10909 
      return
10910 
    iprot.readStructBegin()
10911 
    while True:
10912 
      (fname, ftype, fid) = iprot.readFieldBegin()
10913 
      if ftype == TType.STOP:
10914 
        break
10915 
      if fid == 1:
94 ashish 10916 
        if ftype == TType.I64:
559 chandransh 10917 
          self.from_time = iprot.readI64();
94 ashish 10918 
        else:
10919 
          iprot.skip(ftype)
122 ashish 10920 
      elif fid == 2:
559 chandransh 10921 
        if ftype == TType.I64:
10922 
          self.to_time = iprot.readI64();
122 ashish 10923 
        else:
10924 
          iprot.skip(ftype)
559 chandransh 10925 
      elif fid == 3:
10926 
        if ftype == TType.I32:
10927 
          self.status = iprot.readI32();
10928 
        else:
10929 
          iprot.skip(ftype)
94 ashish 10930 
      else:
10931 
        iprot.skip(ftype)
10932 
      iprot.readFieldEnd()
10933 
    iprot.readStructEnd()
10934 
 
10935 
  def write(self, oprot):
10936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10938 
      return
559 chandransh 10939 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10940 
    if self.from_time is not None:
559 chandransh 10941 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10942 
      oprot.writeI64(self.from_time)
94 ashish 10943 
      oprot.writeFieldEnd()
3431 rajveer 10944 
    if self.to_time is not None:
559 chandransh 10945 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10946 
      oprot.writeI64(self.to_time)
122 ashish 10947 
      oprot.writeFieldEnd()
3431 rajveer 10948 
    if self.status is not None:
559 chandransh 10949 
      oprot.writeFieldBegin('status', TType.I32, 3)
10950 
      oprot.writeI32(self.status)
10951 
      oprot.writeFieldEnd()
94 ashish 10952 
    oprot.writeFieldStop()
10953 
    oprot.writeStructEnd()
10954 
 
3431 rajveer 10955 
  def validate(self):
10956 
    return
10957 
 
10958 
 
94 ashish 10959 
  def __repr__(self):
10960 
    L = ['%s=%r' % (key, value)
10961 
      for key, value in self.__dict__.iteritems()]
10962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10963 
 
10964 
  def __eq__(self, other):
10965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10966 
 
10967 
  def __ne__(self, other):
10968 
    return not (self == other)
10969 
 
559 chandransh 10970 
class getCartsByTime_result:
94 ashish 10971 
  """
10972 
  Attributes:
10973 
   - success
559 chandransh 10974 
   - scx
94 ashish 10975 
  """
10976 
 
10977 
  thrift_spec = (
559 chandransh 10978 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10979 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10980 
  )
10981 
 
559 chandransh 10982 
  def __init__(self, success=None, scx=None,):
94 ashish 10983 
    self.success = success
559 chandransh 10984 
    self.scx = scx
94 ashish 10985 
 
10986 
  def read(self, iprot):
10987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10989 
      return
10990 
    iprot.readStructBegin()
10991 
    while True:
10992 
      (fname, ftype, fid) = iprot.readFieldBegin()
10993 
      if ftype == TType.STOP:
10994 
        break
10995 
      if fid == 0:
559 chandransh 10996 
        if ftype == TType.LIST:
10997 
          self.success = []
11592 amit.gupta 10998 
          (_etype156, _size153) = iprot.readListBegin()
10999 
          for _i157 in xrange(_size153):
11000 
            _elem158 = Cart()
11001 
            _elem158.read(iprot)
11002 
            self.success.append(_elem158)
559 chandransh 11003 
          iprot.readListEnd()
94 ashish 11004 
        else:
11005 
          iprot.skip(ftype)
11006 
      elif fid == 1:
11007 
        if ftype == TType.STRUCT:
559 chandransh 11008 
          self.scx = ShoppingCartException()
11009 
          self.scx.read(iprot)
94 ashish 11010 
        else:
11011 
          iprot.skip(ftype)
11012 
      else:
11013 
        iprot.skip(ftype)
11014 
      iprot.readFieldEnd()
11015 
    iprot.readStructEnd()
11016 
 
11017 
  def write(self, oprot):
11018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11020 
      return
559 chandransh 11021 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11022 
    if self.success is not None:
559 chandransh 11023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11025 
      for iter159 in self.success:
11026 
        iter159.write(oprot)
559 chandransh 11027 
      oprot.writeListEnd()
94 ashish 11028 
      oprot.writeFieldEnd()
3431 rajveer 11029 
    if self.scx is not None:
559 chandransh 11030 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11031 
      self.scx.write(oprot)
94 ashish 11032 
      oprot.writeFieldEnd()
11033 
    oprot.writeFieldStop()
11034 
    oprot.writeStructEnd()
11035 
 
3431 rajveer 11036 
  def validate(self):
11037 
    return
11038 
 
11039 
 
94 ashish 11040 
  def __repr__(self):
11041 
    L = ['%s=%r' % (key, value)
11042 
      for key, value in self.__dict__.iteritems()]
11043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11044 
 
11045 
  def __eq__(self, other):
11046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11047 
 
11048 
  def __ne__(self, other):
11049 
    return not (self == other)
11050 
 
559 chandransh 11051 
class addItemToCart_args:
11052 
  """
11053 
  Attributes:
11054 
   - cartId
11055 
   - itemId
11056 
   - quantity
3557 rajveer 11057 
   - sourceId
559 chandransh 11058 
  """
11059 
 
11060 
  thrift_spec = (
11061 
    None, # 0
11062 
    (1, TType.I64, 'cartId', None, None, ), # 1
11063 
    (2, TType.I64, 'itemId', None, None, ), # 2
11064 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11065 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11066 
  )
11067 
 
3557 rajveer 11068 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11069 
    self.cartId = cartId
11070 
    self.itemId = itemId
11071 
    self.quantity = quantity
3557 rajveer 11072 
    self.sourceId = sourceId
559 chandransh 11073 
 
11074 
  def read(self, iprot):
11075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11077 
      return
11078 
    iprot.readStructBegin()
11079 
    while True:
11080 
      (fname, ftype, fid) = iprot.readFieldBegin()
11081 
      if ftype == TType.STOP:
11082 
        break
11083 
      if fid == 1:
11084 
        if ftype == TType.I64:
11085 
          self.cartId = iprot.readI64();
11086 
        else:
11087 
          iprot.skip(ftype)
11088 
      elif fid == 2:
11089 
        if ftype == TType.I64:
11090 
          self.itemId = iprot.readI64();
11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      elif fid == 3:
11094 
        if ftype == TType.I64:
11095 
          self.quantity = iprot.readI64();
11096 
        else:
11097 
          iprot.skip(ftype)
3557 rajveer 11098 
      elif fid == 4:
11099 
        if ftype == TType.I64:
11100 
          self.sourceId = iprot.readI64();
11101 
        else:
11102 
          iprot.skip(ftype)
559 chandransh 11103 
      else:
11104 
        iprot.skip(ftype)
11105 
      iprot.readFieldEnd()
11106 
    iprot.readStructEnd()
11107 
 
11108 
  def write(self, oprot):
11109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11111 
      return
11112 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11113 
    if self.cartId is not None:
559 chandransh 11114 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11115 
      oprot.writeI64(self.cartId)
11116 
      oprot.writeFieldEnd()
3431 rajveer 11117 
    if self.itemId is not None:
559 chandransh 11118 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11119 
      oprot.writeI64(self.itemId)
11120 
      oprot.writeFieldEnd()
3431 rajveer 11121 
    if self.quantity is not None:
559 chandransh 11122 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11123 
      oprot.writeI64(self.quantity)
11124 
      oprot.writeFieldEnd()
3557 rajveer 11125 
    if self.sourceId is not None:
11126 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11127 
      oprot.writeI64(self.sourceId)
11128 
      oprot.writeFieldEnd()
559 chandransh 11129 
    oprot.writeFieldStop()
11130 
    oprot.writeStructEnd()
11131 
 
3431 rajveer 11132 
  def validate(self):
11133 
    return
11134 
 
11135 
 
559 chandransh 11136 
  def __repr__(self):
11137 
    L = ['%s=%r' % (key, value)
11138 
      for key, value in self.__dict__.iteritems()]
11139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11140 
 
11141 
  def __eq__(self, other):
11142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11143 
 
11144 
  def __ne__(self, other):
11145 
    return not (self == other)
11146 
 
11147 
class addItemToCart_result:
11148 
  """
11149 
  Attributes:
2035 rajveer 11150 
   - success
559 chandransh 11151 
   - scx
11152 
  """
11153 
 
11154 
  thrift_spec = (
2035 rajveer 11155 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11156 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11157 
  )
11158 
 
2035 rajveer 11159 
  def __init__(self, success=None, scx=None,):
11160 
    self.success = success
559 chandransh 11161 
    self.scx = scx
11162 
 
11163 
  def read(self, iprot):
11164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11166 
      return
11167 
    iprot.readStructBegin()
11168 
    while True:
11169 
      (fname, ftype, fid) = iprot.readFieldBegin()
11170 
      if ftype == TType.STOP:
11171 
        break
2035 rajveer 11172 
      if fid == 0:
11173 
        if ftype == TType.STRING:
11174 
          self.success = iprot.readString();
11175 
        else:
11176 
          iprot.skip(ftype)
11177 
      elif fid == 1:
559 chandransh 11178 
        if ftype == TType.STRUCT:
11179 
          self.scx = ShoppingCartException()
11180 
          self.scx.read(iprot)
11181 
        else:
11182 
          iprot.skip(ftype)
11183 
      else:
11184 
        iprot.skip(ftype)
11185 
      iprot.readFieldEnd()
11186 
    iprot.readStructEnd()
11187 
 
11188 
  def write(self, oprot):
11189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11191 
      return
11192 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11193 
    if self.success is not None:
2035 rajveer 11194 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11195 
      oprot.writeString(self.success)
11196 
      oprot.writeFieldEnd()
3431 rajveer 11197 
    if self.scx is not None:
559 chandransh 11198 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11199 
      self.scx.write(oprot)
11200 
      oprot.writeFieldEnd()
11201 
    oprot.writeFieldStop()
11202 
    oprot.writeStructEnd()
11203 
 
3431 rajveer 11204 
  def validate(self):
11205 
    return
11206 
 
11207 
 
559 chandransh 11208 
  def __repr__(self):
11209 
    L = ['%s=%r' % (key, value)
11210 
      for key, value in self.__dict__.iteritems()]
11211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11212 
 
11213 
  def __eq__(self, other):
11214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11215 
 
11216 
  def __ne__(self, other):
11217 
    return not (self == other)
11218 
 
11219 
class deleteItemFromCart_args:
11220 
  """
11221 
  Attributes:
11222 
   - cartId
11223 
   - itemId
11224 
  """
11225 
 
11226 
  thrift_spec = (
11227 
    None, # 0
11228 
    (1, TType.I64, 'cartId', None, None, ), # 1
11229 
    (2, TType.I64, 'itemId', None, None, ), # 2
11230 
  )
11231 
 
11232 
  def __init__(self, cartId=None, itemId=None,):
11233 
    self.cartId = cartId
11234 
    self.itemId = itemId
11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      if fid == 1:
11246 
        if ftype == TType.I64:
11247 
          self.cartId = iprot.readI64();
11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      elif fid == 2:
11251 
        if ftype == TType.I64:
11252 
          self.itemId = iprot.readI64();
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
11264 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11265 
    if self.cartId is not None:
559 chandransh 11266 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11267 
      oprot.writeI64(self.cartId)
11268 
      oprot.writeFieldEnd()
3431 rajveer 11269 
    if self.itemId is not None:
559 chandransh 11270 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11271 
      oprot.writeI64(self.itemId)
11272 
      oprot.writeFieldEnd()
11273 
    oprot.writeFieldStop()
11274 
    oprot.writeStructEnd()
11275 
 
3431 rajveer 11276 
  def validate(self):
11277 
    return
11278 
 
11279 
 
559 chandransh 11280 
  def __repr__(self):
11281 
    L = ['%s=%r' % (key, value)
11282 
      for key, value in self.__dict__.iteritems()]
11283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11284 
 
11285 
  def __eq__(self, other):
11286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11287 
 
11288 
  def __ne__(self, other):
11289 
    return not (self == other)
11290 
 
11291 
class deleteItemFromCart_result:
11292 
  """
11293 
  Attributes:
11294 
   - scx
11295 
  """
11296 
 
11297 
  thrift_spec = (
11298 
    None, # 0
11299 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11300 
  )
11301 
 
11302 
  def __init__(self, scx=None,):
11303 
    self.scx = scx
11304 
 
11305 
  def read(self, iprot):
11306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11308 
      return
11309 
    iprot.readStructBegin()
11310 
    while True:
11311 
      (fname, ftype, fid) = iprot.readFieldBegin()
11312 
      if ftype == TType.STOP:
11313 
        break
11314 
      if fid == 1:
11315 
        if ftype == TType.STRUCT:
11316 
          self.scx = ShoppingCartException()
11317 
          self.scx.read(iprot)
11318 
        else:
11319 
          iprot.skip(ftype)
11320 
      else:
11321 
        iprot.skip(ftype)
11322 
      iprot.readFieldEnd()
11323 
    iprot.readStructEnd()
11324 
 
11325 
  def write(self, oprot):
11326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11328 
      return
11329 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11330 
    if self.scx is not None:
559 chandransh 11331 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11332 
      self.scx.write(oprot)
11333 
      oprot.writeFieldEnd()
11334 
    oprot.writeFieldStop()
11335 
    oprot.writeStructEnd()
11336 
 
3431 rajveer 11337 
  def validate(self):
11338 
    return
11339 
 
11340 
 
559 chandransh 11341 
  def __repr__(self):
11342 
    L = ['%s=%r' % (key, value)
11343 
      for key, value in self.__dict__.iteritems()]
11344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11345 
 
11346 
  def __eq__(self, other):
11347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11348 
 
11349 
  def __ne__(self, other):
11350 
    return not (self == other)
11351 
 
11352 
class addAddressToCart_args:
11353 
  """
11354 
  Attributes:
11355 
   - cartId
11356 
   - addressId
11357 
  """
11358 
 
11359 
  thrift_spec = (
11360 
    None, # 0
11361 
    (1, TType.I64, 'cartId', None, None, ), # 1
11362 
    (2, TType.I64, 'addressId', None, None, ), # 2
11363 
  )
11364 
 
11365 
  def __init__(self, cartId=None, addressId=None,):
11366 
    self.cartId = cartId
11367 
    self.addressId = addressId
11368 
 
11369 
  def read(self, iprot):
11370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11372 
      return
11373 
    iprot.readStructBegin()
11374 
    while True:
11375 
      (fname, ftype, fid) = iprot.readFieldBegin()
11376 
      if ftype == TType.STOP:
11377 
        break
11378 
      if fid == 1:
11379 
        if ftype == TType.I64:
11380 
          self.cartId = iprot.readI64();
11381 
        else:
11382 
          iprot.skip(ftype)
11383 
      elif fid == 2:
11384 
        if ftype == TType.I64:
11385 
          self.addressId = iprot.readI64();
11386 
        else:
11387 
          iprot.skip(ftype)
11388 
      else:
11389 
        iprot.skip(ftype)
11390 
      iprot.readFieldEnd()
11391 
    iprot.readStructEnd()
11392 
 
11393 
  def write(self, oprot):
11394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11396 
      return
11397 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11398 
    if self.cartId is not None:
559 chandransh 11399 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11400 
      oprot.writeI64(self.cartId)
11401 
      oprot.writeFieldEnd()
3431 rajveer 11402 
    if self.addressId is not None:
559 chandransh 11403 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11404 
      oprot.writeI64(self.addressId)
11405 
      oprot.writeFieldEnd()
11406 
    oprot.writeFieldStop()
11407 
    oprot.writeStructEnd()
11408 
 
3431 rajveer 11409 
  def validate(self):
11410 
    return
11411 
 
11412 
 
559 chandransh 11413 
  def __repr__(self):
11414 
    L = ['%s=%r' % (key, value)
11415 
      for key, value in self.__dict__.iteritems()]
11416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11417 
 
11418 
  def __eq__(self, other):
11419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11420 
 
11421 
  def __ne__(self, other):
11422 
    return not (self == other)
11423 
 
11424 
class addAddressToCart_result:
575 chandransh 11425 
  """
11426 
  Attributes:
11427 
   - scx
11428 
  """
559 chandransh 11429 
 
11430 
  thrift_spec = (
575 chandransh 11431 
    None, # 0
11432 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11433 
  )
11434 
 
575 chandransh 11435 
  def __init__(self, scx=None,):
11436 
    self.scx = scx
11437 
 
559 chandransh 11438 
  def read(self, iprot):
11439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11441 
      return
11442 
    iprot.readStructBegin()
11443 
    while True:
11444 
      (fname, ftype, fid) = iprot.readFieldBegin()
11445 
      if ftype == TType.STOP:
11446 
        break
575 chandransh 11447 
      if fid == 1:
11448 
        if ftype == TType.STRUCT:
11449 
          self.scx = ShoppingCartException()
11450 
          self.scx.read(iprot)
11451 
        else:
11452 
          iprot.skip(ftype)
559 chandransh 11453 
      else:
11454 
        iprot.skip(ftype)
11455 
      iprot.readFieldEnd()
11456 
    iprot.readStructEnd()
11457 
 
11458 
  def write(self, oprot):
11459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11461 
      return
11462 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11463 
    if self.scx is not None:
575 chandransh 11464 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11465 
      self.scx.write(oprot)
11466 
      oprot.writeFieldEnd()
559 chandransh 11467 
    oprot.writeFieldStop()
11468 
    oprot.writeStructEnd()
11469 
 
3431 rajveer 11470 
  def validate(self):
11471 
    return
11472 
 
11473 
 
559 chandransh 11474 
  def __repr__(self):
11475 
    L = ['%s=%r' % (key, value)
11476 
      for key, value in self.__dict__.iteritems()]
11477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11478 
 
11479 
  def __eq__(self, other):
11480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11481 
 
11482 
  def __ne__(self, other):
11483 
    return not (self == other)
11484 
 
5553 rajveer 11485 
class addStoreToCart_args:
11486 
  """
11487 
  Attributes:
11488 
   - cartId
11489 
   - storeId
11490 
  """
11491 
 
11492 
  thrift_spec = (
11493 
    None, # 0
11494 
    (1, TType.I64, 'cartId', None, None, ), # 1
11495 
    (2, TType.I64, 'storeId', None, None, ), # 2
11496 
  )
11497 
 
11498 
  def __init__(self, cartId=None, storeId=None,):
11499 
    self.cartId = cartId
11500 
    self.storeId = storeId
11501 
 
11502 
  def read(self, iprot):
11503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11505 
      return
11506 
    iprot.readStructBegin()
11507 
    while True:
11508 
      (fname, ftype, fid) = iprot.readFieldBegin()
11509 
      if ftype == TType.STOP:
11510 
        break
11511 
      if fid == 1:
11512 
        if ftype == TType.I64:
11513 
          self.cartId = iprot.readI64();
11514 
        else:
11515 
          iprot.skip(ftype)
11516 
      elif fid == 2:
11517 
        if ftype == TType.I64:
11518 
          self.storeId = iprot.readI64();
11519 
        else:
11520 
          iprot.skip(ftype)
11521 
      else:
11522 
        iprot.skip(ftype)
11523 
      iprot.readFieldEnd()
11524 
    iprot.readStructEnd()
11525 
 
11526 
  def write(self, oprot):
11527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11529 
      return
11530 
    oprot.writeStructBegin('addStoreToCart_args')
11531 
    if self.cartId is not None:
11532 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11533 
      oprot.writeI64(self.cartId)
11534 
      oprot.writeFieldEnd()
11535 
    if self.storeId is not None:
11536 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11537 
      oprot.writeI64(self.storeId)
11538 
      oprot.writeFieldEnd()
11539 
    oprot.writeFieldStop()
11540 
    oprot.writeStructEnd()
11541 
 
11542 
  def validate(self):
11543 
    return
11544 
 
11545 
 
11546 
  def __repr__(self):
11547 
    L = ['%s=%r' % (key, value)
11548 
      for key, value in self.__dict__.iteritems()]
11549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11550 
 
11551 
  def __eq__(self, other):
11552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11553 
 
11554 
  def __ne__(self, other):
11555 
    return not (self == other)
11556 
 
11557 
class addStoreToCart_result:
11558 
  """
11559 
  Attributes:
11560 
   - scx
11561 
  """
11562 
 
11563 
  thrift_spec = (
11564 
    None, # 0
11565 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11566 
  )
11567 
 
11568 
  def __init__(self, scx=None,):
11569 
    self.scx = scx
11570 
 
11571 
  def read(self, iprot):
11572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11574 
      return
11575 
    iprot.readStructBegin()
11576 
    while True:
11577 
      (fname, ftype, fid) = iprot.readFieldBegin()
11578 
      if ftype == TType.STOP:
11579 
        break
11580 
      if fid == 1:
11581 
        if ftype == TType.STRUCT:
11582 
          self.scx = ShoppingCartException()
11583 
          self.scx.read(iprot)
11584 
        else:
11585 
          iprot.skip(ftype)
11586 
      else:
11587 
        iprot.skip(ftype)
11588 
      iprot.readFieldEnd()
11589 
    iprot.readStructEnd()
11590 
 
11591 
  def write(self, oprot):
11592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11594 
      return
11595 
    oprot.writeStructBegin('addStoreToCart_result')
11596 
    if self.scx is not None:
11597 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11598 
      self.scx.write(oprot)
11599 
      oprot.writeFieldEnd()
11600 
    oprot.writeFieldStop()
11601 
    oprot.writeStructEnd()
11602 
 
11603 
  def validate(self):
11604 
    return
11605 
 
11606 
 
11607 
  def __repr__(self):
11608 
    L = ['%s=%r' % (key, value)
11609 
      for key, value in self.__dict__.iteritems()]
11610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11611 
 
11612 
  def __eq__(self, other):
11613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11614 
 
11615 
  def __ne__(self, other):
11616 
    return not (self == other)
11617 
 
1976 varun.gupt 11618 
class applyCouponToCart_args:
11619 
  """
11620 
  Attributes:
6922 anupam.sin 11621 
   - cart
1976 varun.gupt 11622 
   - couponCode
11623 
  """
11624 
 
11625 
  thrift_spec = (
11626 
    None, # 0
6922 anupam.sin 11627 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11628 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11629 
  )
11630 
 
6922 anupam.sin 11631 
  def __init__(self, cart=None, couponCode=None,):
11632 
    self.cart = cart
1976 varun.gupt 11633 
    self.couponCode = couponCode
11634 
 
11635 
  def read(self, iprot):
11636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11638 
      return
11639 
    iprot.readStructBegin()
11640 
    while True:
11641 
      (fname, ftype, fid) = iprot.readFieldBegin()
11642 
      if ftype == TType.STOP:
11643 
        break
11644 
      if fid == 1:
6922 anupam.sin 11645 
        if ftype == TType.STRUCT:
11646 
          self.cart = Cart()
11647 
          self.cart.read(iprot)
1976 varun.gupt 11648 
        else:
11649 
          iprot.skip(ftype)
11650 
      elif fid == 2:
11651 
        if ftype == TType.STRING:
11652 
          self.couponCode = iprot.readString();
11653 
        else:
11654 
          iprot.skip(ftype)
11655 
      else:
11656 
        iprot.skip(ftype)
11657 
      iprot.readFieldEnd()
11658 
    iprot.readStructEnd()
11659 
 
11660 
  def write(self, oprot):
11661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11663 
      return
11664 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11665 
    if self.cart is not None:
11666 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11667 
      self.cart.write(oprot)
1976 varun.gupt 11668 
      oprot.writeFieldEnd()
3431 rajveer 11669 
    if self.couponCode is not None:
1976 varun.gupt 11670 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11671 
      oprot.writeString(self.couponCode)
11672 
      oprot.writeFieldEnd()
11673 
    oprot.writeFieldStop()
11674 
    oprot.writeStructEnd()
11675 
 
3431 rajveer 11676 
  def validate(self):
11677 
    return
11678 
 
11679 
 
1976 varun.gupt 11680 
  def __repr__(self):
11681 
    L = ['%s=%r' % (key, value)
11682 
      for key, value in self.__dict__.iteritems()]
11683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11684 
 
11685 
  def __eq__(self, other):
11686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11687 
 
11688 
  def __ne__(self, other):
11689 
    return not (self == other)
11690 
 
11691 
class applyCouponToCart_result:
11692 
  """
11693 
  Attributes:
11694 
   - scx
11695 
  """
11696 
 
11697 
  thrift_spec = (
11698 
    None, # 0
11699 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11700 
  )
11701 
 
11702 
  def __init__(self, scx=None,):
11703 
    self.scx = scx
11704 
 
11705 
  def read(self, iprot):
11706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11708 
      return
11709 
    iprot.readStructBegin()
11710 
    while True:
11711 
      (fname, ftype, fid) = iprot.readFieldBegin()
11712 
      if ftype == TType.STOP:
11713 
        break
11714 
      if fid == 1:
11715 
        if ftype == TType.STRUCT:
11716 
          self.scx = ShoppingCartException()
11717 
          self.scx.read(iprot)
11718 
        else:
11719 
          iprot.skip(ftype)
11720 
      else:
11721 
        iprot.skip(ftype)
11722 
      iprot.readFieldEnd()
11723 
    iprot.readStructEnd()
11724 
 
11725 
  def write(self, oprot):
11726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11728 
      return
11729 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11730 
    if self.scx is not None:
1976 varun.gupt 11731 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11732 
      self.scx.write(oprot)
11733 
      oprot.writeFieldEnd()
11734 
    oprot.writeFieldStop()
11735 
    oprot.writeStructEnd()
11736 
 
3431 rajveer 11737 
  def validate(self):
11738 
    return
11739 
 
11740 
 
1976 varun.gupt 11741 
  def __repr__(self):
11742 
    L = ['%s=%r' % (key, value)
11743 
      for key, value in self.__dict__.iteritems()]
11744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11745 
 
11746 
  def __eq__(self, other):
11747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11748 
 
11749 
  def __ne__(self, other):
11750 
    return not (self == other)
11751 
 
11752 
class removeCoupon_args:
11753 
  """
11754 
  Attributes:
11755 
   - cartId
11756 
  """
11757 
 
11758 
  thrift_spec = (
11759 
    None, # 0
11760 
    (1, TType.I64, 'cartId', None, None, ), # 1
11761 
  )
11762 
 
11763 
  def __init__(self, cartId=None,):
11764 
    self.cartId = cartId
11765 
 
11766 
  def read(self, iprot):
11767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11769 
      return
11770 
    iprot.readStructBegin()
11771 
    while True:
11772 
      (fname, ftype, fid) = iprot.readFieldBegin()
11773 
      if ftype == TType.STOP:
11774 
        break
11775 
      if fid == 1:
11776 
        if ftype == TType.I64:
11777 
          self.cartId = iprot.readI64();
11778 
        else:
11779 
          iprot.skip(ftype)
11780 
      else:
11781 
        iprot.skip(ftype)
11782 
      iprot.readFieldEnd()
11783 
    iprot.readStructEnd()
11784 
 
11785 
  def write(self, oprot):
11786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11788 
      return
11789 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11790 
    if self.cartId is not None:
1976 varun.gupt 11791 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11792 
      oprot.writeI64(self.cartId)
11793 
      oprot.writeFieldEnd()
11794 
    oprot.writeFieldStop()
11795 
    oprot.writeStructEnd()
11796 
 
3431 rajveer 11797 
  def validate(self):
11798 
    return
11799 
 
11800 
 
1976 varun.gupt 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 
 
11812 
class removeCoupon_result:
11813 
  """
11814 
  Attributes:
11815 
   - scx
11816 
  """
11817 
 
11818 
  thrift_spec = (
11819 
    None, # 0
11820 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11821 
  )
11822 
 
11823 
  def __init__(self, scx=None,):
11824 
    self.scx = scx
11825 
 
11826 
  def read(self, iprot):
11827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11829 
      return
11830 
    iprot.readStructBegin()
11831 
    while True:
11832 
      (fname, ftype, fid) = iprot.readFieldBegin()
11833 
      if ftype == TType.STOP:
11834 
        break
11835 
      if fid == 1:
11836 
        if ftype == TType.STRUCT:
11837 
          self.scx = ShoppingCartException()
11838 
          self.scx.read(iprot)
11839 
        else:
11840 
          iprot.skip(ftype)
11841 
      else:
11842 
        iprot.skip(ftype)
11843 
      iprot.readFieldEnd()
11844 
    iprot.readStructEnd()
11845 
 
11846 
  def write(self, oprot):
11847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11849 
      return
11850 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11851 
    if self.scx is not None:
1976 varun.gupt 11852 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11853 
      self.scx.write(oprot)
11854 
      oprot.writeFieldEnd()
11855 
    oprot.writeFieldStop()
11856 
    oprot.writeStructEnd()
11857 
 
3431 rajveer 11858 
  def validate(self):
11859 
    return
11860 
 
11861 
 
1976 varun.gupt 11862 
  def __repr__(self):
11863 
    L = ['%s=%r' % (key, value)
11864 
      for key, value in self.__dict__.iteritems()]
11865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11866 
 
11867 
  def __eq__(self, other):
11868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11869 
 
11870 
  def __ne__(self, other):
11871 
    return not (self == other)
11872 
 
3554 varun.gupt 11873 
class deleteDiscountsFromCart_args:
11874 
  """
11875 
  Attributes:
11876 
   - cartId
11877 
  """
11878 
 
11879 
  thrift_spec = (
11880 
    None, # 0
11881 
    (1, TType.I64, 'cartId', None, None, ), # 1
11882 
  )
11883 
 
11884 
  def __init__(self, cartId=None,):
11885 
    self.cartId = cartId
11886 
 
11887 
  def read(self, iprot):
11888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11890 
      return
11891 
    iprot.readStructBegin()
11892 
    while True:
11893 
      (fname, ftype, fid) = iprot.readFieldBegin()
11894 
      if ftype == TType.STOP:
11895 
        break
11896 
      if fid == 1:
11897 
        if ftype == TType.I64:
11898 
          self.cartId = iprot.readI64();
11899 
        else:
11900 
          iprot.skip(ftype)
11901 
      else:
11902 
        iprot.skip(ftype)
11903 
      iprot.readFieldEnd()
11904 
    iprot.readStructEnd()
11905 
 
11906 
  def write(self, oprot):
11907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11909 
      return
11910 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11911 
    if self.cartId is not None:
11912 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11913 
      oprot.writeI64(self.cartId)
11914 
      oprot.writeFieldEnd()
11915 
    oprot.writeFieldStop()
11916 
    oprot.writeStructEnd()
11917 
 
11918 
  def validate(self):
11919 
    return
11920 
 
11921 
 
11922 
  def __repr__(self):
11923 
    L = ['%s=%r' % (key, value)
11924 
      for key, value in self.__dict__.iteritems()]
11925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11926 
 
11927 
  def __eq__(self, other):
11928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11929 
 
11930 
  def __ne__(self, other):
11931 
    return not (self == other)
11932 
 
11933 
class deleteDiscountsFromCart_result:
11934 
  """
11935 
  Attributes:
11936 
   - scx
11937 
  """
11938 
 
11939 
  thrift_spec = (
11940 
    None, # 0
11941 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11942 
  )
11943 
 
11944 
  def __init__(self, scx=None,):
11945 
    self.scx = scx
11946 
 
11947 
  def read(self, iprot):
11948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11950 
      return
11951 
    iprot.readStructBegin()
11952 
    while True:
11953 
      (fname, ftype, fid) = iprot.readFieldBegin()
11954 
      if ftype == TType.STOP:
11955 
        break
11956 
      if fid == 1:
11957 
        if ftype == TType.STRUCT:
11958 
          self.scx = ShoppingCartException()
11959 
          self.scx.read(iprot)
11960 
        else:
11961 
          iprot.skip(ftype)
11962 
      else:
11963 
        iprot.skip(ftype)
11964 
      iprot.readFieldEnd()
11965 
    iprot.readStructEnd()
11966 
 
11967 
  def write(self, oprot):
11968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11970 
      return
11971 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11972 
    if self.scx is not None:
11973 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11974 
      self.scx.write(oprot)
11975 
      oprot.writeFieldEnd()
11976 
    oprot.writeFieldStop()
11977 
    oprot.writeStructEnd()
11978 
 
11979 
  def validate(self):
11980 
    return
11981 
 
11982 
 
11983 
  def __repr__(self):
11984 
    L = ['%s=%r' % (key, value)
11985 
      for key, value in self.__dict__.iteritems()]
11986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11987 
 
11988 
  def __eq__(self, other):
11989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11990 
 
11991 
  def __ne__(self, other):
11992 
    return not (self == other)
11993 
 
11994 
class saveDiscounts_args:
11995 
  """
11996 
  Attributes:
11997 
   - discounts
11998 
  """
11999 
 
12000 
  thrift_spec = (
12001 
    None, # 0
12002 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12003 
  )
12004 
 
12005 
  def __init__(self, discounts=None,):
12006 
    self.discounts = discounts
12007 
 
12008 
  def read(self, iprot):
12009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12011 
      return
12012 
    iprot.readStructBegin()
12013 
    while True:
12014 
      (fname, ftype, fid) = iprot.readFieldBegin()
12015 
      if ftype == TType.STOP:
12016 
        break
12017 
      if fid == 1:
12018 
        if ftype == TType.LIST:
12019 
          self.discounts = []
11592 amit.gupta 12020 
          (_etype163, _size160) = iprot.readListBegin()
12021 
          for _i164 in xrange(_size160):
12022 
            _elem165 = Discount()
12023 
            _elem165.read(iprot)
12024 
            self.discounts.append(_elem165)
3554 varun.gupt 12025 
          iprot.readListEnd()
12026 
        else:
12027 
          iprot.skip(ftype)
12028 
      else:
12029 
        iprot.skip(ftype)
12030 
      iprot.readFieldEnd()
12031 
    iprot.readStructEnd()
12032 
 
12033 
  def write(self, oprot):
12034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12036 
      return
12037 
    oprot.writeStructBegin('saveDiscounts_args')
12038 
    if self.discounts is not None:
12039 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12040 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12041 
      for iter166 in self.discounts:
12042 
        iter166.write(oprot)
3554 varun.gupt 12043 
      oprot.writeListEnd()
12044 
      oprot.writeFieldEnd()
12045 
    oprot.writeFieldStop()
12046 
    oprot.writeStructEnd()
12047 
 
12048 
  def validate(self):
12049 
    return
12050 
 
12051 
 
12052 
  def __repr__(self):
12053 
    L = ['%s=%r' % (key, value)
12054 
      for key, value in self.__dict__.iteritems()]
12055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12056 
 
12057 
  def __eq__(self, other):
12058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12059 
 
12060 
  def __ne__(self, other):
12061 
    return not (self == other)
12062 
 
12063 
class saveDiscounts_result:
12064 
  """
12065 
  Attributes:
12066 
   - scx
12067 
  """
12068 
 
12069 
  thrift_spec = (
12070 
    None, # 0
12071 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12072 
  )
12073 
 
12074 
  def __init__(self, scx=None,):
12075 
    self.scx = scx
12076 
 
12077 
  def read(self, iprot):
12078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12080 
      return
12081 
    iprot.readStructBegin()
12082 
    while True:
12083 
      (fname, ftype, fid) = iprot.readFieldBegin()
12084 
      if ftype == TType.STOP:
12085 
        break
12086 
      if fid == 1:
12087 
        if ftype == TType.STRUCT:
12088 
          self.scx = ShoppingCartException()
12089 
          self.scx.read(iprot)
12090 
        else:
12091 
          iprot.skip(ftype)
12092 
      else:
12093 
        iprot.skip(ftype)
12094 
      iprot.readFieldEnd()
12095 
    iprot.readStructEnd()
12096 
 
12097 
  def write(self, oprot):
12098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12100 
      return
12101 
    oprot.writeStructBegin('saveDiscounts_result')
12102 
    if self.scx is not None:
12103 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12104 
      self.scx.write(oprot)
12105 
      oprot.writeFieldEnd()
12106 
    oprot.writeFieldStop()
12107 
    oprot.writeStructEnd()
12108 
 
12109 
  def validate(self):
12110 
    return
12111 
 
12112 
 
12113 
  def __repr__(self):
12114 
    L = ['%s=%r' % (key, value)
12115 
      for key, value in self.__dict__.iteritems()]
12116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12117 
 
12118 
  def __eq__(self, other):
12119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12120 
 
12121 
  def __ne__(self, other):
12122 
    return not (self == other)
12123 
 
690 chandransh 12124 
class createOrders_args:
559 chandransh 12125 
  """
12126 
  Attributes:
12127 
   - cartId
2815 vikas 12128 
   - sessionSource
12129 
   - sessionStartTime
3858 vikas 12130 
   - firstSource
12131 
   - firstSourceTime
5326 rajveer 12132 
   - userId
6389 rajveer 12133 
   - schemeId
11526 amit.gupta 12134 
   - orderSource
559 chandransh 12135 
  """
12136 
 
12137 
  thrift_spec = (
12138 
    None, # 0
12139 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12140 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12141 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12142 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12143 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12144 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12145 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12146 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12147 
  )
12148 
 
11526 amit.gupta 12149 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12150 
    self.cartId = cartId
2815 vikas 12151 
    self.sessionSource = sessionSource
12152 
    self.sessionStartTime = sessionStartTime
3858 vikas 12153 
    self.firstSource = firstSource
12154 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12155 
    self.userId = userId
6389 rajveer 12156 
    self.schemeId = schemeId
11526 amit.gupta 12157 
    self.orderSource = orderSource
559 chandransh 12158 
 
12159 
  def read(self, iprot):
12160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12162 
      return
12163 
    iprot.readStructBegin()
12164 
    while True:
12165 
      (fname, ftype, fid) = iprot.readFieldBegin()
12166 
      if ftype == TType.STOP:
12167 
        break
12168 
      if fid == 1:
12169 
        if ftype == TType.I64:
12170 
          self.cartId = iprot.readI64();
12171 
        else:
12172 
          iprot.skip(ftype)
2815 vikas 12173 
      elif fid == 2:
12174 
        if ftype == TType.STRING:
12175 
          self.sessionSource = iprot.readString();
12176 
        else:
12177 
          iprot.skip(ftype)
12178 
      elif fid == 3:
12179 
        if ftype == TType.I64:
12180 
          self.sessionStartTime = iprot.readI64();
12181 
        else:
12182 
          iprot.skip(ftype)
3858 vikas 12183 
      elif fid == 4:
12184 
        if ftype == TType.STRING:
12185 
          self.firstSource = iprot.readString();
12186 
        else:
12187 
          iprot.skip(ftype)
12188 
      elif fid == 5:
12189 
        if ftype == TType.I64:
12190 
          self.firstSourceTime = iprot.readI64();
12191 
        else:
12192 
          iprot.skip(ftype)
5326 rajveer 12193 
      elif fid == 6:
12194 
        if ftype == TType.I64:
12195 
          self.userId = iprot.readI64();
12196 
        else:
12197 
          iprot.skip(ftype)
6389 rajveer 12198 
      elif fid == 7:
12199 
        if ftype == TType.I64:
12200 
          self.schemeId = iprot.readI64();
12201 
        else:
12202 
          iprot.skip(ftype)
11526 amit.gupta 12203 
      elif fid == 8:
12204 
        if ftype == TType.I64:
12205 
          self.orderSource = iprot.readI64();
12206 
        else:
12207 
          iprot.skip(ftype)
559 chandransh 12208 
      else:
12209 
        iprot.skip(ftype)
12210 
      iprot.readFieldEnd()
12211 
    iprot.readStructEnd()
12212 
 
12213 
  def write(self, oprot):
12214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12216 
      return
690 chandransh 12217 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12218 
    if self.cartId is not None:
559 chandransh 12219 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12220 
      oprot.writeI64(self.cartId)
12221 
      oprot.writeFieldEnd()
3431 rajveer 12222 
    if self.sessionSource is not None:
2815 vikas 12223 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12224 
      oprot.writeString(self.sessionSource)
12225 
      oprot.writeFieldEnd()
3431 rajveer 12226 
    if self.sessionStartTime is not None:
2815 vikas 12227 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12228 
      oprot.writeI64(self.sessionStartTime)
12229 
      oprot.writeFieldEnd()
3858 vikas 12230 
    if self.firstSource is not None:
12231 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12232 
      oprot.writeString(self.firstSource)
12233 
      oprot.writeFieldEnd()
12234 
    if self.firstSourceTime is not None:
12235 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12236 
      oprot.writeI64(self.firstSourceTime)
12237 
      oprot.writeFieldEnd()
5326 rajveer 12238 
    if self.userId is not None:
12239 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12240 
      oprot.writeI64(self.userId)
12241 
      oprot.writeFieldEnd()
6389 rajveer 12242 
    if self.schemeId is not None:
12243 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12244 
      oprot.writeI64(self.schemeId)
12245 
      oprot.writeFieldEnd()
11526 amit.gupta 12246 
    if self.orderSource is not None:
12247 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12248 
      oprot.writeI64(self.orderSource)
12249 
      oprot.writeFieldEnd()
559 chandransh 12250 
    oprot.writeFieldStop()
12251 
    oprot.writeStructEnd()
12252 
 
3431 rajveer 12253 
  def validate(self):
12254 
    return
12255 
 
12256 
 
559 chandransh 12257 
  def __repr__(self):
12258 
    L = ['%s=%r' % (key, value)
12259 
      for key, value in self.__dict__.iteritems()]
12260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12261 
 
12262 
  def __eq__(self, other):
12263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12264 
 
12265 
  def __ne__(self, other):
12266 
    return not (self == other)
12267 
 
690 chandransh 12268 
class createOrders_result:
559 chandransh 12269 
  """
12270 
  Attributes:
94 ashish 12271 
   - success
559 chandransh 12272 
   - scx
94 ashish 12273 
  """
12274 
 
12275 
  thrift_spec = (
575 chandransh 12276 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12277 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12278 
  )
12279 
 
559 chandransh 12280 
  def __init__(self, success=None, scx=None,):
94 ashish 12281 
    self.success = success
559 chandransh 12282 
    self.scx = scx
94 ashish 12283 
 
12284 
  def read(self, iprot):
12285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12287 
      return
12288 
    iprot.readStructBegin()
12289 
    while True:
12290 
      (fname, ftype, fid) = iprot.readFieldBegin()
12291 
      if ftype == TType.STOP:
12292 
        break
12293 
      if fid == 0:
575 chandransh 12294 
        if ftype == TType.I64:
12295 
          self.success = iprot.readI64();
94 ashish 12296 
        else:
12297 
          iprot.skip(ftype)
12298 
      elif fid == 1:
12299 
        if ftype == TType.STRUCT:
559 chandransh 12300 
          self.scx = ShoppingCartException()
12301 
          self.scx.read(iprot)
94 ashish 12302 
        else:
12303 
          iprot.skip(ftype)
12304 
      else:
12305 
        iprot.skip(ftype)
12306 
      iprot.readFieldEnd()
12307 
    iprot.readStructEnd()
12308 
 
12309 
  def write(self, oprot):
12310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12312 
      return
690 chandransh 12313 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12314 
    if self.success is not None:
575 chandransh 12315 
      oprot.writeFieldBegin('success', TType.I64, 0)
12316 
      oprot.writeI64(self.success)
94 ashish 12317 
      oprot.writeFieldEnd()
3431 rajveer 12318 
    if self.scx is not None:
559 chandransh 12319 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12320 
      self.scx.write(oprot)
94 ashish 12321 
      oprot.writeFieldEnd()
12322 
    oprot.writeFieldStop()
12323 
    oprot.writeStructEnd()
12324 
 
3431 rajveer 12325 
  def validate(self):
12326 
    return
12327 
 
12328 
 
94 ashish 12329 
  def __repr__(self):
12330 
    L = ['%s=%r' % (key, value)
12331 
      for key, value in self.__dict__.iteritems()]
12332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12333 
 
12334 
  def __eq__(self, other):
12335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12336 
 
12337 
  def __ne__(self, other):
12338 
    return not (self == other)
12339 
 
559 chandransh 12340 
class validateCart_args:
94 ashish 12341 
  """
12342 
  Attributes:
559 chandransh 12343 
   - cartId
3557 rajveer 12344 
   - sourceId
94 ashish 12345 
  """
12346 
 
12347 
  thrift_spec = (
12348 
    None, # 0
559 chandransh 12349 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12350 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12351 
  )
12352 
 
3557 rajveer 12353 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12354 
    self.cartId = cartId
3557 rajveer 12355 
    self.sourceId = sourceId
94 ashish 12356 
 
12357 
  def read(self, iprot):
12358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12360 
      return
12361 
    iprot.readStructBegin()
12362 
    while True:
12363 
      (fname, ftype, fid) = iprot.readFieldBegin()
12364 
      if ftype == TType.STOP:
12365 
        break
12366 
      if fid == 1:
12367 
        if ftype == TType.I64:
559 chandransh 12368 
          self.cartId = iprot.readI64();
94 ashish 12369 
        else:
12370 
          iprot.skip(ftype)
3557 rajveer 12371 
      elif fid == 2:
12372 
        if ftype == TType.I64:
12373 
          self.sourceId = iprot.readI64();
12374 
        else:
12375 
          iprot.skip(ftype)
94 ashish 12376 
      else:
12377 
        iprot.skip(ftype)
12378 
      iprot.readFieldEnd()
12379 
    iprot.readStructEnd()
12380 
 
12381 
  def write(self, oprot):
12382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12384 
      return
559 chandransh 12385 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12386 
    if self.cartId is not None:
559 chandransh 12387 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12388 
      oprot.writeI64(self.cartId)
94 ashish 12389 
      oprot.writeFieldEnd()
3557 rajveer 12390 
    if self.sourceId is not None:
12391 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12392 
      oprot.writeI64(self.sourceId)
12393 
      oprot.writeFieldEnd()
94 ashish 12394 
    oprot.writeFieldStop()
12395 
    oprot.writeStructEnd()
12396 
 
3431 rajveer 12397 
  def validate(self):
12398 
    return
12399 
 
12400 
 
94 ashish 12401 
  def __repr__(self):
12402 
    L = ['%s=%r' % (key, value)
12403 
      for key, value in self.__dict__.iteritems()]
12404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12405 
 
12406 
  def __eq__(self, other):
12407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12408 
 
12409 
  def __ne__(self, other):
12410 
    return not (self == other)
12411 
 
559 chandransh 12412 
class validateCart_result:
94 ashish 12413 
  """
12414 
  Attributes:
12415 
   - success
575 chandransh 12416 
   - scex
94 ashish 12417 
  """
12418 
 
12419 
  thrift_spec = (
6736 amit.gupta 12420 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12421 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12422 
  )
12423 
 
575 chandransh 12424 
  def __init__(self, success=None, scex=None,):
94 ashish 12425 
    self.success = success
575 chandransh 12426 
    self.scex = scex
94 ashish 12427 
 
12428 
  def read(self, iprot):
12429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12431 
      return
12432 
    iprot.readStructBegin()
12433 
    while True:
12434 
      (fname, ftype, fid) = iprot.readFieldBegin()
12435 
      if ftype == TType.STOP:
12436 
        break
12437 
      if fid == 0:
6736 amit.gupta 12438 
        if ftype == TType.LIST:
12439 
          self.success = []
11592 amit.gupta 12440 
          (_etype170, _size167) = iprot.readListBegin()
12441 
          for _i171 in xrange(_size167):
12442 
            _elem172 = iprot.readString();
12443 
            self.success.append(_elem172)
6736 amit.gupta 12444 
          iprot.readListEnd()
94 ashish 12445 
        else:
12446 
          iprot.skip(ftype)
575 chandransh 12447 
      elif fid == 1:
12448 
        if ftype == TType.STRUCT:
12449 
          self.scex = ShoppingCartException()
12450 
          self.scex.read(iprot)
12451 
        else:
12452 
          iprot.skip(ftype)
94 ashish 12453 
      else:
12454 
        iprot.skip(ftype)
12455 
      iprot.readFieldEnd()
12456 
    iprot.readStructEnd()
12457 
 
12458 
  def write(self, oprot):
12459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12461 
      return
559 chandransh 12462 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12463 
    if self.success is not None:
6736 amit.gupta 12464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12465 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12466 
      for iter173 in self.success:
12467 
        oprot.writeString(iter173)
6736 amit.gupta 12468 
      oprot.writeListEnd()
94 ashish 12469 
      oprot.writeFieldEnd()
3431 rajveer 12470 
    if self.scex is not None:
575 chandransh 12471 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12472 
      self.scex.write(oprot)
12473 
      oprot.writeFieldEnd()
559 chandransh 12474 
    oprot.writeFieldStop()
12475 
    oprot.writeStructEnd()
12476 
 
3431 rajveer 12477 
  def validate(self):
12478 
    return
12479 
 
12480 
 
559 chandransh 12481 
  def __repr__(self):
12482 
    L = ['%s=%r' % (key, value)
12483 
      for key, value in self.__dict__.iteritems()]
12484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12485 
 
12486 
  def __eq__(self, other):
12487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12488 
 
12489 
  def __ne__(self, other):
12490 
    return not (self == other)
12491 
 
11980 amit.gupta 12492 
class validateCartWithDealerCoupon_args:
12493 
  """
12494 
  Attributes:
12495 
   - cartId
12496 
   - sourceId
12497 
   - dealCoupon
12498 
  """
12499 
 
12500 
  thrift_spec = (
12501 
    None, # 0
12502 
    (1, TType.I64, 'cartId', None, None, ), # 1
12503 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12504 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12505 
  )
12506 
 
12507 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12508 
    self.cartId = cartId
12509 
    self.sourceId = sourceId
12510 
    self.dealCoupon = dealCoupon
12511 
 
12512 
  def read(self, iprot):
12513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12515 
      return
12516 
    iprot.readStructBegin()
12517 
    while True:
12518 
      (fname, ftype, fid) = iprot.readFieldBegin()
12519 
      if ftype == TType.STOP:
12520 
        break
12521 
      if fid == 1:
12522 
        if ftype == TType.I64:
12523 
          self.cartId = iprot.readI64();
12524 
        else:
12525 
          iprot.skip(ftype)
12526 
      elif fid == 2:
12527 
        if ftype == TType.I64:
12528 
          self.sourceId = iprot.readI64();
12529 
        else:
12530 
          iprot.skip(ftype)
12531 
      elif fid == 3:
12532 
        if ftype == TType.STRING:
12533 
          self.dealCoupon = iprot.readString();
12534 
        else:
12535 
          iprot.skip(ftype)
12536 
      else:
12537 
        iprot.skip(ftype)
12538 
      iprot.readFieldEnd()
12539 
    iprot.readStructEnd()
12540 
 
12541 
  def write(self, oprot):
12542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12544 
      return
12545 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12546 
    if self.cartId is not None:
12547 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12548 
      oprot.writeI64(self.cartId)
12549 
      oprot.writeFieldEnd()
12550 
    if self.sourceId is not None:
12551 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12552 
      oprot.writeI64(self.sourceId)
12553 
      oprot.writeFieldEnd()
12554 
    if self.dealCoupon is not None:
12555 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12556 
      oprot.writeString(self.dealCoupon)
12557 
      oprot.writeFieldEnd()
12558 
    oprot.writeFieldStop()
12559 
    oprot.writeStructEnd()
12560 
 
12561 
  def validate(self):
12562 
    return
12563 
 
12564 
 
12565 
  def __repr__(self):
12566 
    L = ['%s=%r' % (key, value)
12567 
      for key, value in self.__dict__.iteritems()]
12568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12569 
 
12570 
  def __eq__(self, other):
12571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12572 
 
12573 
  def __ne__(self, other):
12574 
    return not (self == other)
12575 
 
12576 
class validateCartWithDealerCoupon_result:
12577 
  """
12578 
  Attributes:
12579 
   - success
12580 
   - scex
12581 
  """
12582 
 
12583 
  thrift_spec = (
12584 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12585 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12586 
  )
12587 
 
12588 
  def __init__(self, success=None, scex=None,):
12589 
    self.success = success
12590 
    self.scex = scex
12591 
 
12592 
  def read(self, iprot):
12593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12595 
      return
12596 
    iprot.readStructBegin()
12597 
    while True:
12598 
      (fname, ftype, fid) = iprot.readFieldBegin()
12599 
      if ftype == TType.STOP:
12600 
        break
12601 
      if fid == 0:
12602 
        if ftype == TType.LIST:
12603 
          self.success = []
12604 
          (_etype177, _size174) = iprot.readListBegin()
12605 
          for _i178 in xrange(_size174):
12606 
            _elem179 = iprot.readString();
12607 
            self.success.append(_elem179)
12608 
          iprot.readListEnd()
12609 
        else:
12610 
          iprot.skip(ftype)
12611 
      elif fid == 1:
12612 
        if ftype == TType.STRUCT:
12613 
          self.scex = ShoppingCartException()
12614 
          self.scex.read(iprot)
12615 
        else:
12616 
          iprot.skip(ftype)
12617 
      else:
12618 
        iprot.skip(ftype)
12619 
      iprot.readFieldEnd()
12620 
    iprot.readStructEnd()
12621 
 
12622 
  def write(self, oprot):
12623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12625 
      return
12626 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12627 
    if self.success is not None:
12628 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12629 
      oprot.writeListBegin(TType.STRING, len(self.success))
12630 
      for iter180 in self.success:
12631 
        oprot.writeString(iter180)
12632 
      oprot.writeListEnd()
12633 
      oprot.writeFieldEnd()
12634 
    if self.scex is not None:
12635 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12636 
      self.scex.write(oprot)
12637 
      oprot.writeFieldEnd()
12638 
    oprot.writeFieldStop()
12639 
    oprot.writeStructEnd()
12640 
 
12641 
  def validate(self):
12642 
    return
12643 
 
12644 
 
12645 
  def __repr__(self):
12646 
    L = ['%s=%r' % (key, value)
12647 
      for key, value in self.__dict__.iteritems()]
12648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12649 
 
12650 
  def __eq__(self, other):
12651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12652 
 
12653 
  def __ne__(self, other):
12654 
    return not (self == other)
12655 
 
690 chandransh 12656 
class mergeCart_args:
575 chandransh 12657 
  """
12658 
  Attributes:
690 chandransh 12659 
   - fromCartId
12660 
   - toCartId
12661 
  """
12662 
 
12663 
  thrift_spec = (
12664 
    None, # 0
12665 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12666 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12667 
  )
12668 
 
12669 
  def __init__(self, fromCartId=None, toCartId=None,):
12670 
    self.fromCartId = fromCartId
12671 
    self.toCartId = toCartId
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 == 1:
12683 
        if ftype == TType.I64:
12684 
          self.fromCartId = iprot.readI64();
12685 
        else:
12686 
          iprot.skip(ftype)
12687 
      elif fid == 2:
12688 
        if ftype == TType.I64:
12689 
          self.toCartId = iprot.readI64();
12690 
        else:
12691 
          iprot.skip(ftype)
12692 
      else:
12693 
        iprot.skip(ftype)
12694 
      iprot.readFieldEnd()
12695 
    iprot.readStructEnd()
12696 
 
12697 
  def write(self, oprot):
12698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12700 
      return
12701 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12702 
    if self.fromCartId is not None:
690 chandransh 12703 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12704 
      oprot.writeI64(self.fromCartId)
12705 
      oprot.writeFieldEnd()
3431 rajveer 12706 
    if self.toCartId is not None:
690 chandransh 12707 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12708 
      oprot.writeI64(self.toCartId)
12709 
      oprot.writeFieldEnd()
12710 
    oprot.writeFieldStop()
12711 
    oprot.writeStructEnd()
12712 
 
3431 rajveer 12713 
  def validate(self):
12714 
    return
12715 
 
12716 
 
690 chandransh 12717 
  def __repr__(self):
12718 
    L = ['%s=%r' % (key, value)
12719 
      for key, value in self.__dict__.iteritems()]
12720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12721 
 
12722 
  def __eq__(self, other):
12723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12724 
 
12725 
  def __ne__(self, other):
12726 
    return not (self == other)
12727 
 
12728 
class mergeCart_result:
12729 
 
12730 
  thrift_spec = (
12731 
  )
12732 
 
12733 
  def read(self, iprot):
12734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12736 
      return
12737 
    iprot.readStructBegin()
12738 
    while True:
12739 
      (fname, ftype, fid) = iprot.readFieldBegin()
12740 
      if ftype == TType.STOP:
12741 
        break
12742 
      else:
12743 
        iprot.skip(ftype)
12744 
      iprot.readFieldEnd()
12745 
    iprot.readStructEnd()
12746 
 
12747 
  def write(self, oprot):
12748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12750 
      return
12751 
    oprot.writeStructBegin('mergeCart_result')
12752 
    oprot.writeFieldStop()
12753 
    oprot.writeStructEnd()
12754 
 
3431 rajveer 12755 
  def validate(self):
12756 
    return
12757 
 
12758 
 
690 chandransh 12759 
  def __repr__(self):
12760 
    L = ['%s=%r' % (key, value)
12761 
      for key, value in self.__dict__.iteritems()]
12762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12763 
 
12764 
  def __eq__(self, other):
12765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12766 
 
12767 
  def __ne__(self, other):
12768 
    return not (self == other)
12769 
 
12770 
class checkOut_args:
12771 
  """
12772 
  Attributes:
575 chandransh 12773 
   - cartId
12774 
  """
12775 
 
12776 
  thrift_spec = (
12777 
    None, # 0
12778 
    (1, TType.I64, 'cartId', None, None, ), # 1
12779 
  )
12780 
 
12781 
  def __init__(self, cartId=None,):
12782 
    self.cartId = cartId
12783 
 
12784 
  def read(self, iprot):
12785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12787 
      return
12788 
    iprot.readStructBegin()
12789 
    while True:
12790 
      (fname, ftype, fid) = iprot.readFieldBegin()
12791 
      if ftype == TType.STOP:
12792 
        break
12793 
      if fid == 1:
12794 
        if ftype == TType.I64:
12795 
          self.cartId = iprot.readI64();
12796 
        else:
12797 
          iprot.skip(ftype)
12798 
      else:
12799 
        iprot.skip(ftype)
12800 
      iprot.readFieldEnd()
12801 
    iprot.readStructEnd()
12802 
 
12803 
  def write(self, oprot):
12804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12806 
      return
690 chandransh 12807 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12808 
    if self.cartId is not None:
575 chandransh 12809 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12810 
      oprot.writeI64(self.cartId)
12811 
      oprot.writeFieldEnd()
12812 
    oprot.writeFieldStop()
12813 
    oprot.writeStructEnd()
12814 
 
3431 rajveer 12815 
  def validate(self):
12816 
    return
12817 
 
12818 
 
575 chandransh 12819 
  def __repr__(self):
12820 
    L = ['%s=%r' % (key, value)
12821 
      for key, value in self.__dict__.iteritems()]
12822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12823 
 
12824 
  def __eq__(self, other):
12825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12826 
 
12827 
  def __ne__(self, other):
12828 
    return not (self == other)
12829 
 
690 chandransh 12830 
class checkOut_result:
575 chandransh 12831 
  """
12832 
  Attributes:
12833 
   - success
12834 
   - scex
12835 
  """
12836 
 
12837 
  thrift_spec = (
12838 
    (0, TType.BOOL, 'success', None, None, ), # 0
12839 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12840 
  )
12841 
 
12842 
  def __init__(self, success=None, scex=None,):
12843 
    self.success = success
12844 
    self.scex = scex
12845 
 
12846 
  def read(self, iprot):
12847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12849 
      return
12850 
    iprot.readStructBegin()
12851 
    while True:
12852 
      (fname, ftype, fid) = iprot.readFieldBegin()
12853 
      if ftype == TType.STOP:
12854 
        break
12855 
      if fid == 0:
12856 
        if ftype == TType.BOOL:
12857 
          self.success = iprot.readBool();
12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      elif fid == 1:
12861 
        if ftype == TType.STRUCT:
12862 
          self.scex = ShoppingCartException()
12863 
          self.scex.read(iprot)
12864 
        else:
12865 
          iprot.skip(ftype)
12866 
      else:
12867 
        iprot.skip(ftype)
12868 
      iprot.readFieldEnd()
12869 
    iprot.readStructEnd()
12870 
 
12871 
  def write(self, oprot):
12872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12874 
      return
690 chandransh 12875 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12876 
    if self.success is not None:
575 chandransh 12877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12878 
      oprot.writeBool(self.success)
12879 
      oprot.writeFieldEnd()
3431 rajveer 12880 
    if self.scex is not None:
575 chandransh 12881 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12882 
      self.scex.write(oprot)
12883 
      oprot.writeFieldEnd()
12884 
    oprot.writeFieldStop()
12885 
    oprot.writeStructEnd()
12886 
 
3431 rajveer 12887 
  def validate(self):
12888 
    return
12889 
 
12890 
 
575 chandransh 12891 
  def __repr__(self):
12892 
    L = ['%s=%r' % (key, value)
12893 
      for key, value in self.__dict__.iteritems()]
12894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12895 
 
12896 
  def __eq__(self, other):
12897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12898 
 
12899 
  def __ne__(self, other):
12900 
    return not (self == other)
12901 
 
690 chandransh 12902 
class resetCart_args:
559 chandransh 12903 
  """
12904 
  Attributes:
690 chandransh 12905 
   - cartId
12906 
   - items
559 chandransh 12907 
  """
12908 
 
12909 
  thrift_spec = (
12910 
    None, # 0
690 chandransh 12911 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12912 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12913 
  )
12914 
 
690 chandransh 12915 
  def __init__(self, cartId=None, items=None,):
12916 
    self.cartId = cartId
12917 
    self.items = items
559 chandransh 12918 
 
12919 
  def read(self, iprot):
12920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12922 
      return
12923 
    iprot.readStructBegin()
12924 
    while True:
12925 
      (fname, ftype, fid) = iprot.readFieldBegin()
12926 
      if ftype == TType.STOP:
12927 
        break
12928 
      if fid == 1:
12929 
        if ftype == TType.I64:
690 chandransh 12930 
          self.cartId = iprot.readI64();
559 chandransh 12931 
        else:
12932 
          iprot.skip(ftype)
12933 
      elif fid == 2:
690 chandransh 12934 
        if ftype == TType.MAP:
12935 
          self.items = {}
11980 amit.gupta 12936 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12937 
          for _i185 in xrange(_size181):
12938 
            _key186 = iprot.readI64();
12939 
            _val187 = iprot.readDouble();
12940 
            self.items[_key186] = _val187
690 chandransh 12941 
          iprot.readMapEnd()
559 chandransh 12942 
        else:
12943 
          iprot.skip(ftype)
12944 
      else:
12945 
        iprot.skip(ftype)
12946 
      iprot.readFieldEnd()
12947 
    iprot.readStructEnd()
12948 
 
12949 
  def write(self, oprot):
12950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12952 
      return
690 chandransh 12953 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12954 
    if self.cartId is not None:
690 chandransh 12955 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12956 
      oprot.writeI64(self.cartId)
94 ashish 12957 
      oprot.writeFieldEnd()
3431 rajveer 12958 
    if self.items is not None:
690 chandransh 12959 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12960 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12961 
      for kiter188,viter189 in self.items.items():
12962 
        oprot.writeI64(kiter188)
12963 
        oprot.writeDouble(viter189)
690 chandransh 12964 
      oprot.writeMapEnd()
559 chandransh 12965 
      oprot.writeFieldEnd()
94 ashish 12966 
    oprot.writeFieldStop()
12967 
    oprot.writeStructEnd()
12968 
 
3431 rajveer 12969 
  def validate(self):
12970 
    return
12971 
 
12972 
 
94 ashish 12973 
  def __repr__(self):
12974 
    L = ['%s=%r' % (key, value)
12975 
      for key, value in self.__dict__.iteritems()]
12976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12977 
 
12978 
  def __eq__(self, other):
12979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12980 
 
12981 
  def __ne__(self, other):
12982 
    return not (self == other)
12983 
 
690 chandransh 12984 
class resetCart_result:
12985 
  """
12986 
  Attributes:
12987 
   - success
12988 
   - scex
12989 
  """
559 chandransh 12990 
 
12991 
  thrift_spec = (
690 chandransh 12992 
    (0, TType.BOOL, 'success', None, None, ), # 0
12993 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12994 
  )
12995 
 
690 chandransh 12996 
  def __init__(self, success=None, scex=None,):
12997 
    self.success = success
12998 
    self.scex = scex
12999 
 
559 chandransh 13000 
  def read(self, iprot):
13001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13003 
      return
13004 
    iprot.readStructBegin()
13005 
    while True:
13006 
      (fname, ftype, fid) = iprot.readFieldBegin()
13007 
      if ftype == TType.STOP:
13008 
        break
690 chandransh 13009 
      if fid == 0:
13010 
        if ftype == TType.BOOL:
13011 
          self.success = iprot.readBool();
13012 
        else:
13013 
          iprot.skip(ftype)
13014 
      elif fid == 1:
13015 
        if ftype == TType.STRUCT:
13016 
          self.scex = ShoppingCartException()
13017 
          self.scex.read(iprot)
13018 
        else:
13019 
          iprot.skip(ftype)
559 chandransh 13020 
      else:
13021 
        iprot.skip(ftype)
13022 
      iprot.readFieldEnd()
13023 
    iprot.readStructEnd()
13024 
 
13025 
  def write(self, oprot):
13026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13028 
      return
690 chandransh 13029 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13030 
    if self.success is not None:
690 chandransh 13031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13032 
      oprot.writeBool(self.success)
13033 
      oprot.writeFieldEnd()
3431 rajveer 13034 
    if self.scex is not None:
690 chandransh 13035 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13036 
      self.scex.write(oprot)
13037 
      oprot.writeFieldEnd()
559 chandransh 13038 
    oprot.writeFieldStop()
13039 
    oprot.writeStructEnd()
13040 
 
3431 rajveer 13041 
  def validate(self):
13042 
    return
13043 
 
13044 
 
559 chandransh 13045 
  def __repr__(self):
13046 
    L = ['%s=%r' % (key, value)
13047 
      for key, value in self.__dict__.iteritems()]
13048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13049 
 
13050 
  def __eq__(self, other):
13051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13052 
 
13053 
  def __ne__(self, other):
13054 
    return not (self == other)
13055 
 
2981 rajveer 13056 
class getUserCount_args:
94 ashish 13057 
  """
13058 
  Attributes:
2981 rajveer 13059 
   - userType
559 chandransh 13060 
  """
13061 
 
13062 
  thrift_spec = (
13063 
    None, # 0
2981 rajveer 13064 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13065 
  )
13066 
 
2981 rajveer 13067 
  def __init__(self, userType=None,):
13068 
    self.userType = userType
559 chandransh 13069 
 
13070 
  def read(self, iprot):
13071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13073 
      return
13074 
    iprot.readStructBegin()
13075 
    while True:
13076 
      (fname, ftype, fid) = iprot.readFieldBegin()
13077 
      if ftype == TType.STOP:
13078 
        break
13079 
      if fid == 1:
2981 rajveer 13080 
        if ftype == TType.I32:
13081 
          self.userType = iprot.readI32();
559 chandransh 13082 
        else:
13083 
          iprot.skip(ftype)
13084 
      else:
13085 
        iprot.skip(ftype)
13086 
      iprot.readFieldEnd()
13087 
    iprot.readStructEnd()
13088 
 
13089 
  def write(self, oprot):
13090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13092 
      return
2981 rajveer 13093 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13094 
    if self.userType is not None:
2981 rajveer 13095 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13096 
      oprot.writeI32(self.userType)
559 chandransh 13097 
      oprot.writeFieldEnd()
13098 
    oprot.writeFieldStop()
13099 
    oprot.writeStructEnd()
13100 
 
3431 rajveer 13101 
  def validate(self):
13102 
    return
13103 
 
13104 
 
559 chandransh 13105 
  def __repr__(self):
13106 
    L = ['%s=%r' % (key, value)
13107 
      for key, value in self.__dict__.iteritems()]
13108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13109 
 
13110 
  def __eq__(self, other):
13111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13112 
 
13113 
  def __ne__(self, other):
13114 
    return not (self == other)
13115 
 
2981 rajveer 13116 
class getUserCount_result:
94 ashish 13117 
  """
13118 
  Attributes:
13119 
   - success
13120 
  """
13121 
 
13122 
  thrift_spec = (
2981 rajveer 13123 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13124 
  )
13125 
 
2981 rajveer 13126 
  def __init__(self, success=None,):
94 ashish 13127 
    self.success = success
13128 
 
13129 
  def read(self, iprot):
13130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13132 
      return
13133 
    iprot.readStructBegin()
13134 
    while True:
13135 
      (fname, ftype, fid) = iprot.readFieldBegin()
13136 
      if ftype == TType.STOP:
13137 
        break
13138 
      if fid == 0:
2981 rajveer 13139 
        if ftype == TType.I64:
13140 
          self.success = iprot.readI64();
94 ashish 13141 
        else:
13142 
          iprot.skip(ftype)
13143 
      else:
13144 
        iprot.skip(ftype)
13145 
      iprot.readFieldEnd()
13146 
    iprot.readStructEnd()
13147 
 
13148 
  def write(self, oprot):
13149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13151 
      return
2981 rajveer 13152 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13153 
    if self.success is not None:
2981 rajveer 13154 
      oprot.writeFieldBegin('success', TType.I64, 0)
13155 
      oprot.writeI64(self.success)
94 ashish 13156 
      oprot.writeFieldEnd()
13157 
    oprot.writeFieldStop()
13158 
    oprot.writeStructEnd()
13159 
 
3431 rajveer 13160 
  def validate(self):
13161 
    return
13162 
 
13163 
 
94 ashish 13164 
  def __repr__(self):
13165 
    L = ['%s=%r' % (key, value)
13166 
      for key, value in self.__dict__.iteritems()]
13167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13168 
 
13169 
  def __eq__(self, other):
13170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13171 
 
13172 
  def __ne__(self, other):
13173 
    return not (self == other)
13174 
 
2981 rajveer 13175 
class getAllUsers_args:
94 ashish 13176 
  """
13177 
  Attributes:
2981 rajveer 13178 
   - userType
13179 
   - startDate
13180 
   - endDate
94 ashish 13181 
  """
13182 
 
13183 
  thrift_spec = (
13184 
    None, # 0
2981 rajveer 13185 
    (1, TType.I32, 'userType', None, None, ), # 1
13186 
    (2, TType.I64, 'startDate', None, None, ), # 2
13187 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13188 
  )
13189 
 
2981 rajveer 13190 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13191 
    self.userType = userType
13192 
    self.startDate = startDate
13193 
    self.endDate = endDate
94 ashish 13194 
 
13195 
  def read(self, iprot):
13196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13198 
      return
13199 
    iprot.readStructBegin()
13200 
    while True:
13201 
      (fname, ftype, fid) = iprot.readFieldBegin()
13202 
      if ftype == TType.STOP:
13203 
        break
13204 
      if fid == 1:
2981 rajveer 13205 
        if ftype == TType.I32:
13206 
          self.userType = iprot.readI32();
94 ashish 13207 
        else:
13208 
          iprot.skip(ftype)
13209 
      elif fid == 2:
559 chandransh 13210 
        if ftype == TType.I64:
2981 rajveer 13211 
          self.startDate = iprot.readI64();
94 ashish 13212 
        else:
13213 
          iprot.skip(ftype)
2981 rajveer 13214 
      elif fid == 3:
13215 
        if ftype == TType.I64:
13216 
          self.endDate = iprot.readI64();
13217 
        else:
13218 
          iprot.skip(ftype)
94 ashish 13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
2981 rajveer 13228 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13229 
    if self.userType is not None:
2981 rajveer 13230 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13231 
      oprot.writeI32(self.userType)
94 ashish 13232 
      oprot.writeFieldEnd()
3431 rajveer 13233 
    if self.startDate is not None:
2981 rajveer 13234 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13235 
      oprot.writeI64(self.startDate)
94 ashish 13236 
      oprot.writeFieldEnd()
3431 rajveer 13237 
    if self.endDate is not None:
2981 rajveer 13238 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13239 
      oprot.writeI64(self.endDate)
13240 
      oprot.writeFieldEnd()
94 ashish 13241 
    oprot.writeFieldStop()
13242 
    oprot.writeStructEnd()
13243 
 
3431 rajveer 13244 
  def validate(self):
13245 
    return
13246 
 
13247 
 
94 ashish 13248 
  def __repr__(self):
13249 
    L = ['%s=%r' % (key, value)
13250 
      for key, value in self.__dict__.iteritems()]
13251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13252 
 
13253 
  def __eq__(self, other):
13254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13255 
 
13256 
  def __ne__(self, other):
13257 
    return not (self == other)
13258 
 
2981 rajveer 13259 
class getAllUsers_result:
94 ashish 13260 
  """
13261 
  Attributes:
13262 
   - success
13263 
  """
13264 
 
13265 
  thrift_spec = (
2981 rajveer 13266 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13267 
  )
13268 
 
2981 rajveer 13269 
  def __init__(self, success=None,):
94 ashish 13270 
    self.success = success
13271 
 
13272 
  def read(self, iprot):
13273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13275 
      return
13276 
    iprot.readStructBegin()
13277 
    while True:
13278 
      (fname, ftype, fid) = iprot.readFieldBegin()
13279 
      if ftype == TType.STOP:
13280 
        break
13281 
      if fid == 0:
2981 rajveer 13282 
        if ftype == TType.LIST:
13283 
          self.success = []
11980 amit.gupta 13284 
          (_etype193, _size190) = iprot.readListBegin()
13285 
          for _i194 in xrange(_size190):
13286 
            _elem195 = User()
13287 
            _elem195.read(iprot)
13288 
            self.success.append(_elem195)
2981 rajveer 13289 
          iprot.readListEnd()
94 ashish 13290 
        else:
13291 
          iprot.skip(ftype)
13292 
      else:
13293 
        iprot.skip(ftype)
13294 
      iprot.readFieldEnd()
13295 
    iprot.readStructEnd()
13296 
 
13297 
  def write(self, oprot):
13298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13300 
      return
2981 rajveer 13301 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13302 
    if self.success is not None:
2981 rajveer 13303 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13304 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13305 
      for iter196 in self.success:
13306 
        iter196.write(oprot)
2981 rajveer 13307 
      oprot.writeListEnd()
94 ashish 13308 
      oprot.writeFieldEnd()
13309 
    oprot.writeFieldStop()
13310 
    oprot.writeStructEnd()
13311 
 
3431 rajveer 13312 
  def validate(self):
13313 
    return
13314 
 
13315 
 
94 ashish 13316 
  def __repr__(self):
13317 
    L = ['%s=%r' % (key, value)
13318 
      for key, value in self.__dict__.iteritems()]
13319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13320 
 
13321 
  def __eq__(self, other):
13322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13323 
 
13324 
  def __ne__(self, other):
13325 
    return not (self == other)
13326 
 
2981 rajveer 13327 
class getMyResearchItems_args:
559 chandransh 13328 
  """
13329 
  Attributes:
772 rajveer 13330 
   - userId
559 chandransh 13331 
  """
13332 
 
13333 
  thrift_spec = (
13334 
    None, # 0
772 rajveer 13335 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13336 
  )
13337 
 
772 rajveer 13338 
  def __init__(self, userId=None,):
13339 
    self.userId = userId
559 chandransh 13340 
 
13341 
  def read(self, iprot):
13342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13344 
      return
13345 
    iprot.readStructBegin()
13346 
    while True:
13347 
      (fname, ftype, fid) = iprot.readFieldBegin()
13348 
      if ftype == TType.STOP:
13349 
        break
13350 
      if fid == 1:
13351 
        if ftype == TType.I64:
772 rajveer 13352 
          self.userId = iprot.readI64();
559 chandransh 13353 
        else:
13354 
          iprot.skip(ftype)
13355 
      else:
13356 
        iprot.skip(ftype)
13357 
      iprot.readFieldEnd()
13358 
    iprot.readStructEnd()
13359 
 
13360 
  def write(self, oprot):
13361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13363 
      return
2981 rajveer 13364 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13365 
    if self.userId is not None:
772 rajveer 13366 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13367 
      oprot.writeI64(self.userId)
559 chandransh 13368 
      oprot.writeFieldEnd()
13369 
    oprot.writeFieldStop()
13370 
    oprot.writeStructEnd()
13371 
 
3431 rajveer 13372 
  def validate(self):
13373 
    return
13374 
 
13375 
 
559 chandransh 13376 
  def __repr__(self):
13377 
    L = ['%s=%r' % (key, value)
13378 
      for key, value in self.__dict__.iteritems()]
13379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13380 
 
13381 
  def __eq__(self, other):
13382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13383 
 
13384 
  def __ne__(self, other):
13385 
    return not (self == other)
13386 
 
2981 rajveer 13387 
class getMyResearchItems_result:
559 chandransh 13388 
  """
13389 
  Attributes:
130 ashish 13390 
   - success
559 chandransh 13391 
   - scx
130 ashish 13392 
  """
13393 
 
13394 
  thrift_spec = (
2981 rajveer 13395 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13396 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13397 
  )
13398 
 
559 chandransh 13399 
  def __init__(self, success=None, scx=None,):
130 ashish 13400 
    self.success = success
559 chandransh 13401 
    self.scx = scx
130 ashish 13402 
 
13403 
  def read(self, iprot):
13404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13406 
      return
13407 
    iprot.readStructBegin()
13408 
    while True:
13409 
      (fname, ftype, fid) = iprot.readFieldBegin()
13410 
      if ftype == TType.STOP:
13411 
        break
13412 
      if fid == 0:
2981 rajveer 13413 
        if ftype == TType.LIST:
13414 
          self.success = []
11980 amit.gupta 13415 
          (_etype200, _size197) = iprot.readListBegin()
13416 
          for _i201 in xrange(_size197):
13417 
            _elem202 = iprot.readI64();
13418 
            self.success.append(_elem202)
2981 rajveer 13419 
          iprot.readListEnd()
130 ashish 13420 
        else:
13421 
          iprot.skip(ftype)
13422 
      elif fid == 1:
13423 
        if ftype == TType.STRUCT:
559 chandransh 13424 
          self.scx = WidgetException()
13425 
          self.scx.read(iprot)
130 ashish 13426 
        else:
13427 
          iprot.skip(ftype)
13428 
      else:
13429 
        iprot.skip(ftype)
13430 
      iprot.readFieldEnd()
13431 
    iprot.readStructEnd()
13432 
 
13433 
  def write(self, oprot):
13434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13436 
      return
2981 rajveer 13437 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13438 
    if self.success is not None:
2981 rajveer 13439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13440 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13441 
      for iter203 in self.success:
13442 
        oprot.writeI64(iter203)
2981 rajveer 13443 
      oprot.writeListEnd()
130 ashish 13444 
      oprot.writeFieldEnd()
3431 rajveer 13445 
    if self.scx is not None:
559 chandransh 13446 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13447 
      self.scx.write(oprot)
130 ashish 13448 
      oprot.writeFieldEnd()
13449 
    oprot.writeFieldStop()
13450 
    oprot.writeStructEnd()
13451 
 
3431 rajveer 13452 
  def validate(self):
13453 
    return
13454 
 
13455 
 
130 ashish 13456 
  def __repr__(self):
13457 
    L = ['%s=%r' % (key, value)
13458 
      for key, value in self.__dict__.iteritems()]
13459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13460 
 
13461 
  def __eq__(self, other):
13462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13463 
 
13464 
  def __ne__(self, other):
13465 
    return not (self == other)
13466 
 
2981 rajveer 13467 
class updateMyResearch_args:
130 ashish 13468 
  """
13469 
  Attributes:
2981 rajveer 13470 
   - userId
13471 
   - itemId
130 ashish 13472 
  """
13473 
 
13474 
  thrift_spec = (
13475 
    None, # 0
2981 rajveer 13476 
    (1, TType.I64, 'userId', None, None, ), # 1
13477 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13478 
  )
13479 
 
2981 rajveer 13480 
  def __init__(self, userId=None, itemId=None,):
13481 
    self.userId = userId
13482 
    self.itemId = itemId
130 ashish 13483 
 
13484 
  def read(self, iprot):
13485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13487 
      return
13488 
    iprot.readStructBegin()
13489 
    while True:
13490 
      (fname, ftype, fid) = iprot.readFieldBegin()
13491 
      if ftype == TType.STOP:
13492 
        break
13493 
      if fid == 1:
559 chandransh 13494 
        if ftype == TType.I64:
2981 rajveer 13495 
          self.userId = iprot.readI64();
130 ashish 13496 
        else:
13497 
          iprot.skip(ftype)
13498 
      elif fid == 2:
559 chandransh 13499 
        if ftype == TType.I64:
2981 rajveer 13500 
          self.itemId = iprot.readI64();
559 chandransh 13501 
        else:
13502 
          iprot.skip(ftype)
130 ashish 13503 
      else:
13504 
        iprot.skip(ftype)
13505 
      iprot.readFieldEnd()
13506 
    iprot.readStructEnd()
13507 
 
13508 
  def write(self, oprot):
13509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13511 
      return
2981 rajveer 13512 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13513 
    if self.userId is not None:
2981 rajveer 13514 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13515 
      oprot.writeI64(self.userId)
130 ashish 13516 
      oprot.writeFieldEnd()
3431 rajveer 13517 
    if self.itemId is not None:
2981 rajveer 13518 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13519 
      oprot.writeI64(self.itemId)
130 ashish 13520 
      oprot.writeFieldEnd()
13521 
    oprot.writeFieldStop()
13522 
    oprot.writeStructEnd()
13523 
 
3431 rajveer 13524 
  def validate(self):
13525 
    return
13526 
 
13527 
 
130 ashish 13528 
  def __repr__(self):
13529 
    L = ['%s=%r' % (key, value)
13530 
      for key, value in self.__dict__.iteritems()]
13531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13532 
 
13533 
  def __eq__(self, other):
13534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13535 
 
13536 
  def __ne__(self, other):
13537 
    return not (self == other)
13538 
 
2981 rajveer 13539 
class updateMyResearch_result:
13540 
  """
13541 
  Attributes:
13542 
   - success
13543 
   - scx
13544 
  """
559 chandransh 13545 
 
13546 
  thrift_spec = (
2981 rajveer 13547 
    (0, TType.BOOL, 'success', None, None, ), # 0
13548 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13549 
  )
13550 
 
2981 rajveer 13551 
  def __init__(self, success=None, scx=None,):
13552 
    self.success = success
13553 
    self.scx = scx
13554 
 
559 chandransh 13555 
  def read(self, iprot):
13556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13558 
      return
13559 
    iprot.readStructBegin()
13560 
    while True:
13561 
      (fname, ftype, fid) = iprot.readFieldBegin()
13562 
      if ftype == TType.STOP:
13563 
        break
2981 rajveer 13564 
      if fid == 0:
13565 
        if ftype == TType.BOOL:
13566 
          self.success = iprot.readBool();
13567 
        else:
13568 
          iprot.skip(ftype)
13569 
      elif fid == 1:
13570 
        if ftype == TType.STRUCT:
13571 
          self.scx = WidgetException()
13572 
          self.scx.read(iprot)
13573 
        else:
13574 
          iprot.skip(ftype)
559 chandransh 13575 
      else:
13576 
        iprot.skip(ftype)
13577 
      iprot.readFieldEnd()
13578 
    iprot.readStructEnd()
13579 
 
13580 
  def write(self, oprot):
13581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13583 
      return
2981 rajveer 13584 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13585 
    if self.success is not None:
2981 rajveer 13586 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13587 
      oprot.writeBool(self.success)
13588 
      oprot.writeFieldEnd()
3431 rajveer 13589 
    if self.scx is not None:
2981 rajveer 13590 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13591 
      self.scx.write(oprot)
13592 
      oprot.writeFieldEnd()
559 chandransh 13593 
    oprot.writeFieldStop()
13594 
    oprot.writeStructEnd()
13595 
 
3431 rajveer 13596 
  def validate(self):
13597 
    return
13598 
 
13599 
 
559 chandransh 13600 
  def __repr__(self):
13601 
    L = ['%s=%r' % (key, value)
13602 
      for key, value in self.__dict__.iteritems()]
13603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13604 
 
13605 
  def __eq__(self, other):
13606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13607 
 
13608 
  def __ne__(self, other):
13609 
    return not (self == other)
13610 
 
2981 rajveer 13611 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13612 
  """
13613 
  Attributes:
2981 rajveer 13614 
   - userId
13615 
   - itemId
1596 ankur.sing 13616 
  """
559 chandransh 13617 
 
1596 ankur.sing 13618 
  thrift_spec = (
13619 
    None, # 0
2981 rajveer 13620 
    (1, TType.I64, 'userId', None, None, ), # 1
13621 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13622 
  )
13623 
 
2981 rajveer 13624 
  def __init__(self, userId=None, itemId=None,):
13625 
    self.userId = userId
13626 
    self.itemId = itemId
1596 ankur.sing 13627 
 
13628 
  def read(self, iprot):
13629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13631 
      return
13632 
    iprot.readStructBegin()
13633 
    while True:
13634 
      (fname, ftype, fid) = iprot.readFieldBegin()
13635 
      if ftype == TType.STOP:
13636 
        break
13637 
      if fid == 1:
2981 rajveer 13638 
        if ftype == TType.I64:
13639 
          self.userId = iprot.readI64();
1596 ankur.sing 13640 
        else:
13641 
          iprot.skip(ftype)
2981 rajveer 13642 
      elif fid == 2:
13643 
        if ftype == TType.I64:
13644 
          self.itemId = iprot.readI64();
13645 
        else:
13646 
          iprot.skip(ftype)
1596 ankur.sing 13647 
      else:
13648 
        iprot.skip(ftype)
13649 
      iprot.readFieldEnd()
13650 
    iprot.readStructEnd()
13651 
 
13652 
  def write(self, oprot):
13653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13655 
      return
2981 rajveer 13656 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13657 
    if self.userId is not None:
2981 rajveer 13658 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13659 
      oprot.writeI64(self.userId)
1596 ankur.sing 13660 
      oprot.writeFieldEnd()
3431 rajveer 13661 
    if self.itemId is not None:
2981 rajveer 13662 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13663 
      oprot.writeI64(self.itemId)
13664 
      oprot.writeFieldEnd()
1596 ankur.sing 13665 
    oprot.writeFieldStop()
13666 
    oprot.writeStructEnd()
13667 
 
3431 rajveer 13668 
  def validate(self):
13669 
    return
13670 
 
13671 
 
1596 ankur.sing 13672 
  def __repr__(self):
13673 
    L = ['%s=%r' % (key, value)
13674 
      for key, value in self.__dict__.iteritems()]
13675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13676 
 
13677 
  def __eq__(self, other):
13678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13679 
 
13680 
  def __ne__(self, other):
13681 
    return not (self == other)
13682 
 
2981 rajveer 13683 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13684 
  """
13685 
  Attributes:
2981 rajveer 13686 
   - scx
1596 ankur.sing 13687 
  """
13688 
 
13689 
  thrift_spec = (
2981 rajveer 13690 
    None, # 0
13691 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13692 
  )
13693 
 
2981 rajveer 13694 
  def __init__(self, scx=None,):
13695 
    self.scx = scx
1596 ankur.sing 13696 
 
13697 
  def read(self, iprot):
13698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13700 
      return
13701 
    iprot.readStructBegin()
13702 
    while True:
13703 
      (fname, ftype, fid) = iprot.readFieldBegin()
13704 
      if ftype == TType.STOP:
13705 
        break
2981 rajveer 13706 
      if fid == 1:
13707 
        if ftype == TType.STRUCT:
13708 
          self.scx = WidgetException()
13709 
          self.scx.read(iprot)
1596 ankur.sing 13710 
        else:
13711 
          iprot.skip(ftype)
13712 
      else:
13713 
        iprot.skip(ftype)
13714 
      iprot.readFieldEnd()
13715 
    iprot.readStructEnd()
13716 
 
13717 
  def write(self, oprot):
13718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13720 
      return
2981 rajveer 13721 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13722 
    if self.scx is not None:
2981 rajveer 13723 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13724 
      self.scx.write(oprot)
1596 ankur.sing 13725 
      oprot.writeFieldEnd()
13726 
    oprot.writeFieldStop()
13727 
    oprot.writeStructEnd()
13728 
 
3431 rajveer 13729 
  def validate(self):
13730 
    return
13731 
 
13732 
 
1596 ankur.sing 13733 
  def __repr__(self):
13734 
    L = ['%s=%r' % (key, value)
13735 
      for key, value in self.__dict__.iteritems()]
13736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13737 
 
13738 
  def __eq__(self, other):
13739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13740 
 
13741 
  def __ne__(self, other):
13742 
    return not (self == other)
13743 
 
2981 rajveer 13744 
class getBrowseHistoryItems_args:
1673 ankur.sing 13745 
  """
13746 
  Attributes:
2981 rajveer 13747 
   - userId
1673 ankur.sing 13748 
  """
1596 ankur.sing 13749 
 
1673 ankur.sing 13750 
  thrift_spec = (
13751 
    None, # 0
2981 rajveer 13752 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13753 
  )
13754 
 
2981 rajveer 13755 
  def __init__(self, userId=None,):
13756 
    self.userId = userId
1673 ankur.sing 13757 
 
13758 
  def read(self, iprot):
13759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13761 
      return
13762 
    iprot.readStructBegin()
13763 
    while True:
13764 
      (fname, ftype, fid) = iprot.readFieldBegin()
13765 
      if ftype == TType.STOP:
13766 
        break
13767 
      if fid == 1:
1891 ankur.sing 13768 
        if ftype == TType.I64:
2981 rajveer 13769 
          self.userId = iprot.readI64();
1891 ankur.sing 13770 
        else:
13771 
          iprot.skip(ftype)
1673 ankur.sing 13772 
      else:
13773 
        iprot.skip(ftype)
13774 
      iprot.readFieldEnd()
13775 
    iprot.readStructEnd()
13776 
 
13777 
  def write(self, oprot):
13778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13780 
      return
2981 rajveer 13781 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13782 
    if self.userId is not None:
2981 rajveer 13783 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13784 
      oprot.writeI64(self.userId)
1673 ankur.sing 13785 
      oprot.writeFieldEnd()
13786 
    oprot.writeFieldStop()
13787 
    oprot.writeStructEnd()
13788 
 
3431 rajveer 13789 
  def validate(self):
13790 
    return
13791 
 
13792 
 
1673 ankur.sing 13793 
  def __repr__(self):
13794 
    L = ['%s=%r' % (key, value)
13795 
      for key, value in self.__dict__.iteritems()]
13796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13797 
 
13798 
  def __eq__(self, other):
13799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13800 
 
13801 
  def __ne__(self, other):
13802 
    return not (self == other)
13803 
 
2981 rajveer 13804 
class getBrowseHistoryItems_result:
1673 ankur.sing 13805 
  """
13806 
  Attributes:
13807 
   - success
2981 rajveer 13808 
   - scx
1673 ankur.sing 13809 
  """
13810 
 
13811 
  thrift_spec = (
2981 rajveer 13812 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13813 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13814 
  )
13815 
 
2981 rajveer 13816 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13817 
    self.success = success
2981 rajveer 13818 
    self.scx = scx
1673 ankur.sing 13819 
 
13820 
  def read(self, iprot):
13821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13823 
      return
13824 
    iprot.readStructBegin()
13825 
    while True:
13826 
      (fname, ftype, fid) = iprot.readFieldBegin()
13827 
      if ftype == TType.STOP:
13828 
        break
13829 
      if fid == 0:
13830 
        if ftype == TType.LIST:
13831 
          self.success = []
11980 amit.gupta 13832 
          (_etype207, _size204) = iprot.readListBegin()
13833 
          for _i208 in xrange(_size204):
13834 
            _elem209 = iprot.readI64();
13835 
            self.success.append(_elem209)
1673 ankur.sing 13836 
          iprot.readListEnd()
13837 
        else:
13838 
          iprot.skip(ftype)
2981 rajveer 13839 
      elif fid == 1:
13840 
        if ftype == TType.STRUCT:
13841 
          self.scx = WidgetException()
13842 
          self.scx.read(iprot)
13843 
        else:
13844 
          iprot.skip(ftype)
1673 ankur.sing 13845 
      else:
13846 
        iprot.skip(ftype)
13847 
      iprot.readFieldEnd()
13848 
    iprot.readStructEnd()
13849 
 
13850 
  def write(self, oprot):
13851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13853 
      return
2981 rajveer 13854 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13855 
    if self.success is not None:
1673 ankur.sing 13856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13857 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13858 
      for iter210 in self.success:
13859 
        oprot.writeI64(iter210)
1673 ankur.sing 13860 
      oprot.writeListEnd()
13861 
      oprot.writeFieldEnd()
3431 rajveer 13862 
    if self.scx is not None:
2981 rajveer 13863 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13864 
      self.scx.write(oprot)
2642 varun.gupt 13865 
      oprot.writeFieldEnd()
13866 
    oprot.writeFieldStop()
13867 
    oprot.writeStructEnd()
13868 
 
3431 rajveer 13869 
  def validate(self):
13870 
    return
13871 
 
13872 
 
2642 varun.gupt 13873 
  def __repr__(self):
13874 
    L = ['%s=%r' % (key, value)
13875 
      for key, value in self.__dict__.iteritems()]
13876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13877 
 
13878 
  def __eq__(self, other):
13879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13880 
 
13881 
  def __ne__(self, other):
13882 
    return not (self == other)
13883 
 
2981 rajveer 13884 
class updateBrowseHistory_args:
2642 varun.gupt 13885 
  """
13886 
  Attributes:
2981 rajveer 13887 
   - userId
13888 
   - itemId
2642 varun.gupt 13889 
  """
13890 
 
13891 
  thrift_spec = (
13892 
    None, # 0
2981 rajveer 13893 
    (1, TType.I64, 'userId', None, None, ), # 1
13894 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13895 
  )
13896 
 
2981 rajveer 13897 
  def __init__(self, userId=None, itemId=None,):
13898 
    self.userId = userId
13899 
    self.itemId = itemId
2642 varun.gupt 13900 
 
13901 
  def read(self, iprot):
13902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13904 
      return
13905 
    iprot.readStructBegin()
13906 
    while True:
13907 
      (fname, ftype, fid) = iprot.readFieldBegin()
13908 
      if ftype == TType.STOP:
13909 
        break
13910 
      if fid == 1:
13911 
        if ftype == TType.I64:
2981 rajveer 13912 
          self.userId = iprot.readI64();
2642 varun.gupt 13913 
        else:
13914 
          iprot.skip(ftype)
13915 
      elif fid == 2:
13916 
        if ftype == TType.I64:
2981 rajveer 13917 
          self.itemId = iprot.readI64();
2642 varun.gupt 13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
2981 rajveer 13929 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13930 
    if self.userId is not None:
2981 rajveer 13931 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13932 
      oprot.writeI64(self.userId)
2642 varun.gupt 13933 
      oprot.writeFieldEnd()
3431 rajveer 13934 
    if self.itemId is not None:
2981 rajveer 13935 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13936 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13937 
      oprot.writeFieldEnd()
13938 
    oprot.writeFieldStop()
13939 
    oprot.writeStructEnd()
13940 
 
3431 rajveer 13941 
  def validate(self):
13942 
    return
13943 
 
13944 
 
2642 varun.gupt 13945 
  def __repr__(self):
13946 
    L = ['%s=%r' % (key, value)
13947 
      for key, value in self.__dict__.iteritems()]
13948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13949 
 
13950 
  def __eq__(self, other):
13951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13952 
 
13953 
  def __ne__(self, other):
13954 
    return not (self == other)
13955 
 
2981 rajveer 13956 
class updateBrowseHistory_result:
2642 varun.gupt 13957 
 
13958 
  thrift_spec = (
13959 
  )
13960 
 
13961 
  def read(self, iprot):
13962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13964 
      return
13965 
    iprot.readStructBegin()
13966 
    while True:
13967 
      (fname, ftype, fid) = iprot.readFieldBegin()
13968 
      if ftype == TType.STOP:
13969 
        break
13970 
      else:
13971 
        iprot.skip(ftype)
13972 
      iprot.readFieldEnd()
13973 
    iprot.readStructEnd()
13974 
 
13975 
  def write(self, oprot):
13976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13978 
      return
2981 rajveer 13979 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13980 
    oprot.writeFieldStop()
13981 
    oprot.writeStructEnd()
13982 
 
3431 rajveer 13983 
  def validate(self):
13984 
    return
13985 
 
13986 
 
2642 varun.gupt 13987 
  def __repr__(self):
13988 
    L = ['%s=%r' % (key, value)
13989 
      for key, value in self.__dict__.iteritems()]
13990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13991 
 
13992 
  def __eq__(self, other):
13993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13994 
 
13995 
  def __ne__(self, other):
13996 
    return not (self == other)
13997 
 
3385 varun.gupt 13998 
class getCartsWithCouponCount_args:
13999 
  """
14000 
  Attributes:
14001 
   - couponCode
14002 
  """
2642 varun.gupt 14003 
 
3385 varun.gupt 14004 
  thrift_spec = (
14005 
    None, # 0
14006 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14007 
  )
14008 
 
14009 
  def __init__(self, couponCode=None,):
14010 
    self.couponCode = couponCode
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.STRING:
14023 
          self.couponCode = iprot.readString();
14024 
        else:
14025 
          iprot.skip(ftype)
14026 
      else:
14027 
        iprot.skip(ftype)
14028 
      iprot.readFieldEnd()
14029 
    iprot.readStructEnd()
14030 
 
14031 
  def write(self, oprot):
14032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14034 
      return
14035 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14036 
    if self.couponCode is not None:
3385 varun.gupt 14037 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14038 
      oprot.writeString(self.couponCode)
14039 
      oprot.writeFieldEnd()
14040 
    oprot.writeFieldStop()
14041 
    oprot.writeStructEnd()
14042 
 
3431 rajveer 14043 
  def validate(self):
14044 
    return
14045 
 
14046 
 
3385 varun.gupt 14047 
  def __repr__(self):
14048 
    L = ['%s=%r' % (key, value)
14049 
      for key, value in self.__dict__.iteritems()]
14050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14051 
 
14052 
  def __eq__(self, other):
14053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14054 
 
14055 
  def __ne__(self, other):
14056 
    return not (self == other)
14057 
 
14058 
class getCartsWithCouponCount_result:
14059 
  """
14060 
  Attributes:
14061 
   - success
14062 
  """
14063 
 
14064 
  thrift_spec = (
14065 
    (0, TType.I64, 'success', None, None, ), # 0
14066 
  )
14067 
 
14068 
  def __init__(self, success=None,):
14069 
    self.success = success
14070 
 
14071 
  def read(self, iprot):
14072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14074 
      return
14075 
    iprot.readStructBegin()
14076 
    while True:
14077 
      (fname, ftype, fid) = iprot.readFieldBegin()
14078 
      if ftype == TType.STOP:
14079 
        break
14080 
      if fid == 0:
14081 
        if ftype == TType.I64:
14082 
          self.success = iprot.readI64();
14083 
        else:
14084 
          iprot.skip(ftype)
14085 
      else:
14086 
        iprot.skip(ftype)
14087 
      iprot.readFieldEnd()
14088 
    iprot.readStructEnd()
14089 
 
14090 
  def write(self, oprot):
14091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14093 
      return
14094 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14095 
    if self.success is not None:
3385 varun.gupt 14096 
      oprot.writeFieldBegin('success', TType.I64, 0)
14097 
      oprot.writeI64(self.success)
14098 
      oprot.writeFieldEnd()
14099 
    oprot.writeFieldStop()
14100 
    oprot.writeStructEnd()
14101 
 
3431 rajveer 14102 
  def validate(self):
14103 
    return
14104 
 
14105 
 
3385 varun.gupt 14106 
  def __repr__(self):
14107 
    L = ['%s=%r' % (key, value)
14108 
      for key, value in self.__dict__.iteritems()]
14109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14110 
 
14111 
  def __eq__(self, other):
14112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14113 
 
14114 
  def __ne__(self, other):
14115 
    return not (self == other)
3499 mandeep.dh 14116 
 
14117 
class increaseTrustLevel_args:
14118 
  """
14119 
  Attributes:
14120 
   - userId
14121 
   - trustLevelDelta
14122 
  """
14123 
 
14124 
  thrift_spec = (
14125 
    None, # 0
14126 
    (1, TType.I64, 'userId', None, None, ), # 1
14127 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14128 
  )
14129 
 
14130 
  def __init__(self, userId=None, trustLevelDelta=None,):
14131 
    self.userId = userId
14132 
    self.trustLevelDelta = trustLevelDelta
14133 
 
14134 
  def read(self, iprot):
14135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14137 
      return
14138 
    iprot.readStructBegin()
14139 
    while True:
14140 
      (fname, ftype, fid) = iprot.readFieldBegin()
14141 
      if ftype == TType.STOP:
14142 
        break
14143 
      if fid == 1:
14144 
        if ftype == TType.I64:
14145 
          self.userId = iprot.readI64();
14146 
        else:
14147 
          iprot.skip(ftype)
14148 
      elif fid == 2:
14149 
        if ftype == TType.DOUBLE:
14150 
          self.trustLevelDelta = iprot.readDouble();
14151 
        else:
14152 
          iprot.skip(ftype)
14153 
      else:
14154 
        iprot.skip(ftype)
14155 
      iprot.readFieldEnd()
14156 
    iprot.readStructEnd()
14157 
 
14158 
  def write(self, oprot):
14159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14161 
      return
14162 
    oprot.writeStructBegin('increaseTrustLevel_args')
14163 
    if self.userId is not None:
14164 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14165 
      oprot.writeI64(self.userId)
14166 
      oprot.writeFieldEnd()
14167 
    if self.trustLevelDelta is not None:
14168 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14169 
      oprot.writeDouble(self.trustLevelDelta)
14170 
      oprot.writeFieldEnd()
14171 
    oprot.writeFieldStop()
14172 
    oprot.writeStructEnd()
14173 
 
14174 
  def validate(self):
14175 
    return
14176 
 
14177 
 
14178 
  def __repr__(self):
14179 
    L = ['%s=%r' % (key, value)
14180 
      for key, value in self.__dict__.iteritems()]
14181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14182 
 
14183 
  def __eq__(self, other):
14184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14185 
 
14186 
  def __ne__(self, other):
14187 
    return not (self == other)
4668 varun.gupt 14188 
 
5407 amar.kumar 14189 
class getTrustLevel_args:
14190 
  """
14191 
  Attributes:
14192 
   - userId
14193 
  """
14194 
 
14195 
  thrift_spec = (
14196 
    None, # 0
14197 
    (1, TType.I64, 'userId', None, None, ), # 1
14198 
  )
14199 
 
14200 
  def __init__(self, userId=None,):
14201 
    self.userId = userId
14202 
 
14203 
  def read(self, iprot):
14204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14206 
      return
14207 
    iprot.readStructBegin()
14208 
    while True:
14209 
      (fname, ftype, fid) = iprot.readFieldBegin()
14210 
      if ftype == TType.STOP:
14211 
        break
14212 
      if fid == 1:
14213 
        if ftype == TType.I64:
14214 
          self.userId = iprot.readI64();
14215 
        else:
14216 
          iprot.skip(ftype)
14217 
      else:
14218 
        iprot.skip(ftype)
14219 
      iprot.readFieldEnd()
14220 
    iprot.readStructEnd()
14221 
 
14222 
  def write(self, oprot):
14223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14225 
      return
14226 
    oprot.writeStructBegin('getTrustLevel_args')
14227 
    if self.userId is not None:
14228 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14229 
      oprot.writeI64(self.userId)
14230 
      oprot.writeFieldEnd()
14231 
    oprot.writeFieldStop()
14232 
    oprot.writeStructEnd()
14233 
 
14234 
  def validate(self):
14235 
    return
14236 
 
14237 
 
14238 
  def __repr__(self):
14239 
    L = ['%s=%r' % (key, value)
14240 
      for key, value in self.__dict__.iteritems()]
14241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14242 
 
14243 
  def __eq__(self, other):
14244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14245 
 
14246 
  def __ne__(self, other):
14247 
    return not (self == other)
14248 
 
14249 
class getTrustLevel_result:
14250 
  """
14251 
  Attributes:
14252 
   - success
14253 
  """
14254 
 
14255 
  thrift_spec = (
14256 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14257 
  )
14258 
 
14259 
  def __init__(self, success=None,):
14260 
    self.success = success
14261 
 
14262 
  def read(self, iprot):
14263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14265 
      return
14266 
    iprot.readStructBegin()
14267 
    while True:
14268 
      (fname, ftype, fid) = iprot.readFieldBegin()
14269 
      if ftype == TType.STOP:
14270 
        break
14271 
      if fid == 0:
14272 
        if ftype == TType.DOUBLE:
14273 
          self.success = iprot.readDouble();
14274 
        else:
14275 
          iprot.skip(ftype)
14276 
      else:
14277 
        iprot.skip(ftype)
14278 
      iprot.readFieldEnd()
14279 
    iprot.readStructEnd()
14280 
 
14281 
  def write(self, oprot):
14282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14284 
      return
14285 
    oprot.writeStructBegin('getTrustLevel_result')
14286 
    if self.success is not None:
14287 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14288 
      oprot.writeDouble(self.success)
14289 
      oprot.writeFieldEnd()
14290 
    oprot.writeFieldStop()
14291 
    oprot.writeStructEnd()
14292 
 
14293 
  def validate(self):
14294 
    return
14295 
 
14296 
 
14297 
  def __repr__(self):
14298 
    L = ['%s=%r' % (key, value)
14299 
      for key, value in self.__dict__.iteritems()]
14300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14301 
 
14302 
  def __eq__(self, other):
14303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14304 
 
14305 
  def __ne__(self, other):
14306 
    return not (self == other)
14307 
 
4668 varun.gupt 14308 
class showCODOption_args:
14309 
  """
14310 
  Attributes:
14311 
   - cartId
14312 
   - sourceId
14313 
   - pincode
14314 
  """
14315 
 
14316 
  thrift_spec = (
14317 
    None, # 0
14318 
    (1, TType.I64, 'cartId', None, None, ), # 1
14319 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14320 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14321 
  )
14322 
 
14323 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14324 
    self.cartId = cartId
14325 
    self.sourceId = sourceId
14326 
    self.pincode = pincode
14327 
 
14328 
  def read(self, iprot):
14329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14331 
      return
14332 
    iprot.readStructBegin()
14333 
    while True:
14334 
      (fname, ftype, fid) = iprot.readFieldBegin()
14335 
      if ftype == TType.STOP:
14336 
        break
14337 
      if fid == 1:
14338 
        if ftype == TType.I64:
14339 
          self.cartId = iprot.readI64();
14340 
        else:
14341 
          iprot.skip(ftype)
14342 
      elif fid == 2:
14343 
        if ftype == TType.I64:
14344 
          self.sourceId = iprot.readI64();
14345 
        else:
14346 
          iprot.skip(ftype)
14347 
      elif fid == 3:
14348 
        if ftype == TType.STRING:
14349 
          self.pincode = iprot.readString();
14350 
        else:
14351 
          iprot.skip(ftype)
14352 
      else:
14353 
        iprot.skip(ftype)
14354 
      iprot.readFieldEnd()
14355 
    iprot.readStructEnd()
14356 
 
14357 
  def write(self, oprot):
14358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14360 
      return
14361 
    oprot.writeStructBegin('showCODOption_args')
14362 
    if self.cartId is not None:
14363 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14364 
      oprot.writeI64(self.cartId)
14365 
      oprot.writeFieldEnd()
14366 
    if self.sourceId is not None:
14367 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14368 
      oprot.writeI64(self.sourceId)
14369 
      oprot.writeFieldEnd()
14370 
    if self.pincode is not None:
14371 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14372 
      oprot.writeString(self.pincode)
14373 
      oprot.writeFieldEnd()
14374 
    oprot.writeFieldStop()
14375 
    oprot.writeStructEnd()
14376 
 
14377 
  def validate(self):
14378 
    return
14379 
 
14380 
 
14381 
  def __repr__(self):
14382 
    L = ['%s=%r' % (key, value)
14383 
      for key, value in self.__dict__.iteritems()]
14384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14385 
 
14386 
  def __eq__(self, other):
14387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14388 
 
14389 
  def __ne__(self, other):
14390 
    return not (self == other)
14391 
 
14392 
class showCODOption_result:
14393 
  """
14394 
  Attributes:
14395 
   - success
14396 
  """
14397 
 
14398 
  thrift_spec = (
14399 
    (0, TType.BOOL, 'success', None, None, ), # 0
14400 
  )
14401 
 
14402 
  def __init__(self, success=None,):
14403 
    self.success = success
14404 
 
14405 
  def read(self, iprot):
14406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14408 
      return
14409 
    iprot.readStructBegin()
14410 
    while True:
14411 
      (fname, ftype, fid) = iprot.readFieldBegin()
14412 
      if ftype == TType.STOP:
14413 
        break
14414 
      if fid == 0:
14415 
        if ftype == TType.BOOL:
14416 
          self.success = iprot.readBool();
14417 
        else:
14418 
          iprot.skip(ftype)
14419 
      else:
14420 
        iprot.skip(ftype)
14421 
      iprot.readFieldEnd()
14422 
    iprot.readStructEnd()
14423 
 
14424 
  def write(self, oprot):
14425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14427 
      return
14428 
    oprot.writeStructBegin('showCODOption_result')
14429 
    if self.success is not None:
14430 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14431 
      oprot.writeBool(self.success)
14432 
      oprot.writeFieldEnd()
14433 
    oprot.writeFieldStop()
14434 
    oprot.writeStructEnd()
14435 
 
14436 
  def validate(self):
14437 
    return
14438 
 
14439 
 
14440 
  def __repr__(self):
14441 
    L = ['%s=%r' % (key, value)
14442 
      for key, value in self.__dict__.iteritems()]
14443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14444 
 
14445 
  def __eq__(self, other):
14446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14447 
 
14448 
  def __ne__(self, other):
14449 
    return not (self == other)
5623 anupam.sin 14450 
 
14451 
class getUserEmails_args:
14452 
  """
14453 
  Attributes:
14454 
   - startDate
14455 
   - endDate
14456 
  """
14457 
 
14458 
  thrift_spec = (
14459 
    None, # 0
14460 
    (1, TType.I64, 'startDate', None, None, ), # 1
14461 
    (2, TType.I64, 'endDate', None, None, ), # 2
14462 
  )
14463 
 
14464 
  def __init__(self, startDate=None, endDate=None,):
14465 
    self.startDate = startDate
14466 
    self.endDate = endDate
14467 
 
14468 
  def read(self, iprot):
14469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14471 
      return
14472 
    iprot.readStructBegin()
14473 
    while True:
14474 
      (fname, ftype, fid) = iprot.readFieldBegin()
14475 
      if ftype == TType.STOP:
14476 
        break
14477 
      if fid == 1:
14478 
        if ftype == TType.I64:
14479 
          self.startDate = iprot.readI64();
14480 
        else:
14481 
          iprot.skip(ftype)
14482 
      elif fid == 2:
14483 
        if ftype == TType.I64:
14484 
          self.endDate = iprot.readI64();
14485 
        else:
14486 
          iprot.skip(ftype)
14487 
      else:
14488 
        iprot.skip(ftype)
14489 
      iprot.readFieldEnd()
14490 
    iprot.readStructEnd()
14491 
 
14492 
  def write(self, oprot):
14493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14495 
      return
14496 
    oprot.writeStructBegin('getUserEmails_args')
14497 
    if self.startDate is not None:
14498 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14499 
      oprot.writeI64(self.startDate)
14500 
      oprot.writeFieldEnd()
14501 
    if self.endDate is not None:
14502 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14503 
      oprot.writeI64(self.endDate)
14504 
      oprot.writeFieldEnd()
14505 
    oprot.writeFieldStop()
14506 
    oprot.writeStructEnd()
14507 
 
14508 
  def validate(self):
14509 
    return
14510 
 
14511 
 
14512 
  def __repr__(self):
14513 
    L = ['%s=%r' % (key, value)
14514 
      for key, value in self.__dict__.iteritems()]
14515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14516 
 
14517 
  def __eq__(self, other):
14518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14519 
 
14520 
  def __ne__(self, other):
14521 
    return not (self == other)
14522 
 
14523 
class getUserEmails_result:
14524 
  """
14525 
  Attributes:
14526 
   - success
14527 
  """
14528 
 
14529 
  thrift_spec = (
14530 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14531 
  )
14532 
 
14533 
  def __init__(self, success=None,):
14534 
    self.success = success
14535 
 
14536 
  def read(self, iprot):
14537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14539 
      return
14540 
    iprot.readStructBegin()
14541 
    while True:
14542 
      (fname, ftype, fid) = iprot.readFieldBegin()
14543 
      if ftype == TType.STOP:
14544 
        break
14545 
      if fid == 0:
14546 
        if ftype == TType.LIST:
14547 
          self.success = []
11980 amit.gupta 14548 
          (_etype214, _size211) = iprot.readListBegin()
14549 
          for _i215 in xrange(_size211):
14550 
            _elem216 = iprot.readString();
14551 
            self.success.append(_elem216)
5623 anupam.sin 14552 
          iprot.readListEnd()
14553 
        else:
14554 
          iprot.skip(ftype)
14555 
      else:
14556 
        iprot.skip(ftype)
14557 
      iprot.readFieldEnd()
14558 
    iprot.readStructEnd()
14559 
 
14560 
  def write(self, oprot):
14561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14563 
      return
14564 
    oprot.writeStructBegin('getUserEmails_result')
14565 
    if self.success is not None:
14566 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14567 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14568 
      for iter217 in self.success:
14569 
        oprot.writeString(iter217)
5623 anupam.sin 14570 
      oprot.writeListEnd()
14571 
      oprot.writeFieldEnd()
14572 
    oprot.writeFieldStop()
14573 
    oprot.writeStructEnd()
14574 
 
14575 
  def validate(self):
14576 
    return
14577 
 
14578 
 
14579 
  def __repr__(self):
14580 
    L = ['%s=%r' % (key, value)
14581 
      for key, value in self.__dict__.iteritems()]
14582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14583 
 
14584 
  def __eq__(self, other):
14585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14586 
 
14587 
  def __ne__(self, other):
14588 
    return not (self == other)
6821 amar.kumar 14589 
 
6903 anupam.sin 14590 
class insureItem_args:
14591 
  """
14592 
  Attributes:
14593 
   - itemId
14594 
   - cartId
14595 
   - toInsure
9299 kshitij.so 14596 
   - insurerType
6903 anupam.sin 14597 
  """
14598 
 
14599 
  thrift_spec = (
14600 
    None, # 0
14601 
    (1, TType.I64, 'itemId', None, None, ), # 1
14602 
    (2, TType.I64, 'cartId', None, None, ), # 2
14603 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14604 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14605 
  )
14606 
 
9299 kshitij.so 14607 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14608 
    self.itemId = itemId
14609 
    self.cartId = cartId
14610 
    self.toInsure = toInsure
9299 kshitij.so 14611 
    self.insurerType = insurerType
6903 anupam.sin 14612 
 
14613 
  def read(self, iprot):
14614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14616 
      return
14617 
    iprot.readStructBegin()
14618 
    while True:
14619 
      (fname, ftype, fid) = iprot.readFieldBegin()
14620 
      if ftype == TType.STOP:
14621 
        break
14622 
      if fid == 1:
14623 
        if ftype == TType.I64:
14624 
          self.itemId = iprot.readI64();
14625 
        else:
14626 
          iprot.skip(ftype)
14627 
      elif fid == 2:
14628 
        if ftype == TType.I64:
14629 
          self.cartId = iprot.readI64();
14630 
        else:
14631 
          iprot.skip(ftype)
14632 
      elif fid == 3:
14633 
        if ftype == TType.BOOL:
14634 
          self.toInsure = iprot.readBool();
14635 
        else:
14636 
          iprot.skip(ftype)
9299 kshitij.so 14637 
      elif fid == 4:
14638 
        if ftype == TType.I32:
14639 
          self.insurerType = iprot.readI32();
14640 
        else:
14641 
          iprot.skip(ftype)
6903 anupam.sin 14642 
      else:
14643 
        iprot.skip(ftype)
14644 
      iprot.readFieldEnd()
14645 
    iprot.readStructEnd()
14646 
 
14647 
  def write(self, oprot):
14648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14650 
      return
14651 
    oprot.writeStructBegin('insureItem_args')
14652 
    if self.itemId is not None:
14653 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14654 
      oprot.writeI64(self.itemId)
14655 
      oprot.writeFieldEnd()
14656 
    if self.cartId is not None:
14657 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14658 
      oprot.writeI64(self.cartId)
14659 
      oprot.writeFieldEnd()
14660 
    if self.toInsure is not None:
14661 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14662 
      oprot.writeBool(self.toInsure)
14663 
      oprot.writeFieldEnd()
9299 kshitij.so 14664 
    if self.insurerType is not None:
14665 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14666 
      oprot.writeI32(self.insurerType)
14667 
      oprot.writeFieldEnd()
6903 anupam.sin 14668 
    oprot.writeFieldStop()
14669 
    oprot.writeStructEnd()
14670 
 
14671 
  def validate(self):
14672 
    return
14673 
 
14674 
 
14675 
  def __repr__(self):
14676 
    L = ['%s=%r' % (key, value)
14677 
      for key, value in self.__dict__.iteritems()]
14678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14679 
 
14680 
  def __eq__(self, other):
14681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14682 
 
14683 
  def __ne__(self, other):
14684 
    return not (self == other)
14685 
 
14686 
class insureItem_result:
14687 
  """
14688 
  Attributes:
14689 
   - success
14690 
  """
14691 
 
14692 
  thrift_spec = (
14693 
    (0, TType.BOOL, 'success', None, None, ), # 0
14694 
  )
14695 
 
14696 
  def __init__(self, success=None,):
14697 
    self.success = success
14698 
 
14699 
  def read(self, iprot):
14700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14702 
      return
14703 
    iprot.readStructBegin()
14704 
    while True:
14705 
      (fname, ftype, fid) = iprot.readFieldBegin()
14706 
      if ftype == TType.STOP:
14707 
        break
14708 
      if fid == 0:
14709 
        if ftype == TType.BOOL:
14710 
          self.success = iprot.readBool();
14711 
        else:
14712 
          iprot.skip(ftype)
14713 
      else:
14714 
        iprot.skip(ftype)
14715 
      iprot.readFieldEnd()
14716 
    iprot.readStructEnd()
14717 
 
14718 
  def write(self, oprot):
14719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14721 
      return
14722 
    oprot.writeStructBegin('insureItem_result')
14723 
    if self.success is not None:
14724 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14725 
      oprot.writeBool(self.success)
14726 
      oprot.writeFieldEnd()
14727 
    oprot.writeFieldStop()
14728 
    oprot.writeStructEnd()
14729 
 
14730 
  def validate(self):
14731 
    return
14732 
 
14733 
 
14734 
  def __repr__(self):
14735 
    L = ['%s=%r' % (key, value)
14736 
      for key, value in self.__dict__.iteritems()]
14737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14738 
 
14739 
  def __eq__(self, other):
14740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14741 
 
14742 
  def __ne__(self, other):
14743 
    return not (self == other)
14744 
 
14745 
class cancelInsurance_args:
14746 
  """
14747 
  Attributes:
14748 
   - cartId
14749 
  """
14750 
 
14751 
  thrift_spec = (
14752 
    None, # 0
14753 
    (1, TType.I64, 'cartId', None, None, ), # 1
14754 
  )
14755 
 
14756 
  def __init__(self, cartId=None,):
14757 
    self.cartId = cartId
14758 
 
14759 
  def read(self, iprot):
14760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14762 
      return
14763 
    iprot.readStructBegin()
14764 
    while True:
14765 
      (fname, ftype, fid) = iprot.readFieldBegin()
14766 
      if ftype == TType.STOP:
14767 
        break
14768 
      if fid == 1:
14769 
        if ftype == TType.I64:
14770 
          self.cartId = iprot.readI64();
14771 
        else:
14772 
          iprot.skip(ftype)
14773 
      else:
14774 
        iprot.skip(ftype)
14775 
      iprot.readFieldEnd()
14776 
    iprot.readStructEnd()
14777 
 
14778 
  def write(self, oprot):
14779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14781 
      return
14782 
    oprot.writeStructBegin('cancelInsurance_args')
14783 
    if self.cartId is not None:
14784 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14785 
      oprot.writeI64(self.cartId)
14786 
      oprot.writeFieldEnd()
14787 
    oprot.writeFieldStop()
14788 
    oprot.writeStructEnd()
14789 
 
14790 
  def validate(self):
14791 
    return
14792 
 
14793 
 
14794 
  def __repr__(self):
14795 
    L = ['%s=%r' % (key, value)
14796 
      for key, value in self.__dict__.iteritems()]
14797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14798 
 
14799 
  def __eq__(self, other):
14800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14801 
 
14802 
  def __ne__(self, other):
14803 
    return not (self == other)
14804 
 
14805 
class cancelInsurance_result:
14806 
  """
14807 
  Attributes:
14808 
   - success
14809 
  """
14810 
 
14811 
  thrift_spec = (
14812 
    (0, TType.BOOL, 'success', None, None, ), # 0
14813 
  )
14814 
 
14815 
  def __init__(self, success=None,):
14816 
    self.success = success
14817 
 
14818 
  def read(self, iprot):
14819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14821 
      return
14822 
    iprot.readStructBegin()
14823 
    while True:
14824 
      (fname, ftype, fid) = iprot.readFieldBegin()
14825 
      if ftype == TType.STOP:
14826 
        break
14827 
      if fid == 0:
14828 
        if ftype == TType.BOOL:
14829 
          self.success = iprot.readBool();
14830 
        else:
14831 
          iprot.skip(ftype)
14832 
      else:
14833 
        iprot.skip(ftype)
14834 
      iprot.readFieldEnd()
14835 
    iprot.readStructEnd()
14836 
 
14837 
  def write(self, oprot):
14838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14840 
      return
14841 
    oprot.writeStructBegin('cancelInsurance_result')
14842 
    if self.success is not None:
14843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14844 
      oprot.writeBool(self.success)
14845 
      oprot.writeFieldEnd()
14846 
    oprot.writeFieldStop()
14847 
    oprot.writeStructEnd()
14848 
 
14849 
  def validate(self):
14850 
    return
14851 
 
14852 
 
14853 
  def __repr__(self):
14854 
    L = ['%s=%r' % (key, value)
14855 
      for key, value in self.__dict__.iteritems()]
14856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14857 
 
14858 
  def __eq__(self, other):
14859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14860 
 
14861 
  def __ne__(self, other):
14862 
    return not (self == other)
14863 
 
14864 
class storeInsuranceSpecificDetails_args:
14865 
  """
14866 
  Attributes:
14867 
   - addressId
14868 
   - dob
14869 
   - guardianName
14870 
  """
14871 
 
14872 
  thrift_spec = (
14873 
    None, # 0
14874 
    (1, TType.I64, 'addressId', None, None, ), # 1
14875 
    (2, TType.STRING, 'dob', None, None, ), # 2
14876 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14877 
  )
14878 
 
14879 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14880 
    self.addressId = addressId
14881 
    self.dob = dob
14882 
    self.guardianName = guardianName
14883 
 
14884 
  def read(self, iprot):
14885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14887 
      return
14888 
    iprot.readStructBegin()
14889 
    while True:
14890 
      (fname, ftype, fid) = iprot.readFieldBegin()
14891 
      if ftype == TType.STOP:
14892 
        break
14893 
      if fid == 1:
14894 
        if ftype == TType.I64:
14895 
          self.addressId = iprot.readI64();
14896 
        else:
14897 
          iprot.skip(ftype)
14898 
      elif fid == 2:
14899 
        if ftype == TType.STRING:
14900 
          self.dob = iprot.readString();
14901 
        else:
14902 
          iprot.skip(ftype)
14903 
      elif fid == 3:
14904 
        if ftype == TType.STRING:
14905 
          self.guardianName = iprot.readString();
14906 
        else:
14907 
          iprot.skip(ftype)
14908 
      else:
14909 
        iprot.skip(ftype)
14910 
      iprot.readFieldEnd()
14911 
    iprot.readStructEnd()
14912 
 
14913 
  def write(self, oprot):
14914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14916 
      return
14917 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14918 
    if self.addressId is not None:
14919 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14920 
      oprot.writeI64(self.addressId)
14921 
      oprot.writeFieldEnd()
14922 
    if self.dob is not None:
14923 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14924 
      oprot.writeString(self.dob)
14925 
      oprot.writeFieldEnd()
14926 
    if self.guardianName is not None:
14927 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14928 
      oprot.writeString(self.guardianName)
14929 
      oprot.writeFieldEnd()
14930 
    oprot.writeFieldStop()
14931 
    oprot.writeStructEnd()
14932 
 
14933 
  def validate(self):
14934 
    return
14935 
 
14936 
 
14937 
  def __repr__(self):
14938 
    L = ['%s=%r' % (key, value)
14939 
      for key, value in self.__dict__.iteritems()]
14940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14941 
 
14942 
  def __eq__(self, other):
14943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14944 
 
14945 
  def __ne__(self, other):
14946 
    return not (self == other)
14947 
 
14948 
class storeInsuranceSpecificDetails_result:
14949 
  """
14950 
  Attributes:
14951 
   - success
14952 
  """
14953 
 
14954 
  thrift_spec = (
14955 
    (0, TType.BOOL, 'success', None, None, ), # 0
14956 
  )
14957 
 
14958 
  def __init__(self, success=None,):
14959 
    self.success = success
14960 
 
14961 
  def read(self, iprot):
14962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14964 
      return
14965 
    iprot.readStructBegin()
14966 
    while True:
14967 
      (fname, ftype, fid) = iprot.readFieldBegin()
14968 
      if ftype == TType.STOP:
14969 
        break
14970 
      if fid == 0:
14971 
        if ftype == TType.BOOL:
14972 
          self.success = iprot.readBool();
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      else:
14976 
        iprot.skip(ftype)
14977 
      iprot.readFieldEnd()
14978 
    iprot.readStructEnd()
14979 
 
14980 
  def write(self, oprot):
14981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14983 
      return
14984 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14985 
    if self.success is not None:
14986 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14987 
      oprot.writeBool(self.success)
14988 
      oprot.writeFieldEnd()
14989 
    oprot.writeFieldStop()
14990 
    oprot.writeStructEnd()
14991 
 
14992 
  def validate(self):
14993 
    return
14994 
 
14995 
 
14996 
  def __repr__(self):
14997 
    L = ['%s=%r' % (key, value)
14998 
      for key, value in self.__dict__.iteritems()]
14999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15000 
 
15001 
  def __eq__(self, other):
15002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15003 
 
15004 
  def __ne__(self, other):
15005 
    return not (self == other)
15006 
 
15007 
class isInsuranceDetailPresent_args:
15008 
  """
15009 
  Attributes:
15010 
   - addressId
15011 
  """
15012 
 
15013 
  thrift_spec = (
15014 
    None, # 0
15015 
    (1, TType.I64, 'addressId', None, None, ), # 1
15016 
  )
15017 
 
15018 
  def __init__(self, addressId=None,):
15019 
    self.addressId = addressId
15020 
 
15021 
  def read(self, iprot):
15022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15024 
      return
15025 
    iprot.readStructBegin()
15026 
    while True:
15027 
      (fname, ftype, fid) = iprot.readFieldBegin()
15028 
      if ftype == TType.STOP:
15029 
        break
15030 
      if fid == 1:
15031 
        if ftype == TType.I64:
15032 
          self.addressId = iprot.readI64();
15033 
        else:
15034 
          iprot.skip(ftype)
15035 
      else:
15036 
        iprot.skip(ftype)
15037 
      iprot.readFieldEnd()
15038 
    iprot.readStructEnd()
15039 
 
15040 
  def write(self, oprot):
15041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15043 
      return
15044 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15045 
    if self.addressId is not None:
15046 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15047 
      oprot.writeI64(self.addressId)
15048 
      oprot.writeFieldEnd()
15049 
    oprot.writeFieldStop()
15050 
    oprot.writeStructEnd()
15051 
 
15052 
  def validate(self):
15053 
    return
15054 
 
15055 
 
15056 
  def __repr__(self):
15057 
    L = ['%s=%r' % (key, value)
15058 
      for key, value in self.__dict__.iteritems()]
15059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15060 
 
15061 
  def __eq__(self, other):
15062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15063 
 
15064 
  def __ne__(self, other):
15065 
    return not (self == other)
15066 
 
15067 
class isInsuranceDetailPresent_result:
15068 
  """
15069 
  Attributes:
15070 
   - success
15071 
  """
15072 
 
15073 
  thrift_spec = (
15074 
    (0, TType.BOOL, 'success', None, None, ), # 0
15075 
  )
15076 
 
15077 
  def __init__(self, success=None,):
15078 
    self.success = success
15079 
 
15080 
  def read(self, iprot):
15081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15083 
      return
15084 
    iprot.readStructBegin()
15085 
    while True:
15086 
      (fname, ftype, fid) = iprot.readFieldBegin()
15087 
      if ftype == TType.STOP:
15088 
        break
15089 
      if fid == 0:
15090 
        if ftype == TType.BOOL:
15091 
          self.success = iprot.readBool();
15092 
        else:
15093 
          iprot.skip(ftype)
15094 
      else:
15095 
        iprot.skip(ftype)
15096 
      iprot.readFieldEnd()
15097 
    iprot.readStructEnd()
15098 
 
15099 
  def write(self, oprot):
15100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15102 
      return
15103 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15104 
    if self.success is not None:
15105 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15106 
      oprot.writeBool(self.success)
15107 
      oprot.writeFieldEnd()
15108 
    oprot.writeFieldStop()
15109 
    oprot.writeStructEnd()
15110 
 
15111 
  def validate(self):
15112 
    return
15113 
 
15114 
 
15115 
  def __repr__(self):
15116 
    L = ['%s=%r' % (key, value)
15117 
      for key, value in self.__dict__.iteritems()]
15118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15119 
 
15120 
  def __eq__(self, other):
15121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15122 
 
15123 
  def __ne__(self, other):
15124 
    return not (self == other)
15125 
 
9791 rajveer 15126 
class getProductsAddedToCart_args:
6821 amar.kumar 15127 
  """
15128 
  Attributes:
15129 
   - startDate
15130 
   - endDate
15131 
  """
15132 
 
15133 
  thrift_spec = (
15134 
    None, # 0
9791 rajveer 15135 
    (1, TType.I64, 'startDate', None, None, ), # 1
15136 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15137 
  )
15138 
 
9791 rajveer 15139 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15140 
    self.startDate = startDate
15141 
    self.endDate = endDate
15142 
 
15143 
  def read(self, iprot):
15144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15146 
      return
15147 
    iprot.readStructBegin()
15148 
    while True:
15149 
      (fname, ftype, fid) = iprot.readFieldBegin()
15150 
      if ftype == TType.STOP:
15151 
        break
15152 
      if fid == 1:
15153 
        if ftype == TType.I64:
9791 rajveer 15154 
          self.startDate = iprot.readI64();
6821 amar.kumar 15155 
        else:
15156 
          iprot.skip(ftype)
15157 
      elif fid == 2:
15158 
        if ftype == TType.I64:
15159 
          self.endDate = iprot.readI64();
15160 
        else:
15161 
          iprot.skip(ftype)
15162 
      else:
15163 
        iprot.skip(ftype)
15164 
      iprot.readFieldEnd()
15165 
    iprot.readStructEnd()
15166 
 
15167 
  def write(self, oprot):
15168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15170 
      return
9791 rajveer 15171 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15172 
    if self.startDate is not None:
9791 rajveer 15173 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15174 
      oprot.writeI64(self.startDate)
15175 
      oprot.writeFieldEnd()
15176 
    if self.endDate is not None:
9791 rajveer 15177 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15178 
      oprot.writeI64(self.endDate)
15179 
      oprot.writeFieldEnd()
15180 
    oprot.writeFieldStop()
15181 
    oprot.writeStructEnd()
15182 
 
15183 
  def validate(self):
15184 
    return
15185 
 
15186 
 
15187 
  def __repr__(self):
15188 
    L = ['%s=%r' % (key, value)
15189 
      for key, value in self.__dict__.iteritems()]
15190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15191 
 
15192 
  def __eq__(self, other):
15193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15194 
 
15195 
  def __ne__(self, other):
15196 
    return not (self == other)
15197 
 
9791 rajveer 15198 
class getProductsAddedToCart_result:
6821 amar.kumar 15199 
  """
15200 
  Attributes:
15201 
   - success
15202 
  """
15203 
 
15204 
  thrift_spec = (
9791 rajveer 15205 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15206 
  )
15207 
 
15208 
  def __init__(self, success=None,):
15209 
    self.success = success
15210 
 
15211 
  def read(self, iprot):
15212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15214 
      return
15215 
    iprot.readStructBegin()
15216 
    while True:
15217 
      (fname, ftype, fid) = iprot.readFieldBegin()
15218 
      if ftype == TType.STOP:
15219 
        break
15220 
      if fid == 0:
9791 rajveer 15221 
        if ftype == TType.LIST:
15222 
          self.success = []
11980 amit.gupta 15223 
          (_etype221, _size218) = iprot.readListBegin()
15224 
          for _i222 in xrange(_size218):
15225 
            _elem223 = iprot.readI64();
15226 
            self.success.append(_elem223)
9791 rajveer 15227 
          iprot.readListEnd()
6821 amar.kumar 15228 
        else:
15229 
          iprot.skip(ftype)
15230 
      else:
15231 
        iprot.skip(ftype)
15232 
      iprot.readFieldEnd()
15233 
    iprot.readStructEnd()
15234 
 
15235 
  def write(self, oprot):
15236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15238 
      return
9791 rajveer 15239 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15240 
    if self.success is not None:
9791 rajveer 15241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15242 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15243 
      for iter224 in self.success:
15244 
        oprot.writeI64(iter224)
9791 rajveer 15245 
      oprot.writeListEnd()
6821 amar.kumar 15246 
      oprot.writeFieldEnd()
15247 
    oprot.writeFieldStop()
15248 
    oprot.writeStructEnd()
15249 
 
15250 
  def validate(self):
15251 
    return
15252 
 
15253 
 
15254 
  def __repr__(self):
15255 
    L = ['%s=%r' % (key, value)
15256 
      for key, value in self.__dict__.iteritems()]
15257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15258 
 
15259 
  def __eq__(self, other):
15260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15261 
 
15262 
  def __ne__(self, other):
15263 
    return not (self == other)
11592 amit.gupta 15264 
 
15265 
class validateCartPlus_args:
15266 
  """
15267 
  Attributes:
15268 
   - cartId
15269 
   - sourceId
11980 amit.gupta 15270 
   - dealerCoupon
11592 amit.gupta 15271 
  """
15272 
 
15273 
  thrift_spec = (
15274 
    None, # 0
15275 
    (1, TType.I64, 'cartId', None, None, ), # 1
15276 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15277 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15278 
  )
15279 
 
11980 amit.gupta 15280 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15281 
    self.cartId = cartId
15282 
    self.sourceId = sourceId
11980 amit.gupta 15283 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15284 
 
15285 
  def read(self, iprot):
15286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15288 
      return
15289 
    iprot.readStructBegin()
15290 
    while True:
15291 
      (fname, ftype, fid) = iprot.readFieldBegin()
15292 
      if ftype == TType.STOP:
15293 
        break
15294 
      if fid == 1:
15295 
        if ftype == TType.I64:
15296 
          self.cartId = iprot.readI64();
15297 
        else:
15298 
          iprot.skip(ftype)
15299 
      elif fid == 2:
15300 
        if ftype == TType.I64:
15301 
          self.sourceId = iprot.readI64();
15302 
        else:
15303 
          iprot.skip(ftype)
11980 amit.gupta 15304 
      elif fid == 3:
15305 
        if ftype == TType.STRING:
15306 
          self.dealerCoupon = iprot.readString();
15307 
        else:
15308 
          iprot.skip(ftype)
11592 amit.gupta 15309 
      else:
15310 
        iprot.skip(ftype)
15311 
      iprot.readFieldEnd()
15312 
    iprot.readStructEnd()
15313 
 
15314 
  def write(self, oprot):
15315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15317 
      return
15318 
    oprot.writeStructBegin('validateCartPlus_args')
15319 
    if self.cartId is not None:
15320 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15321 
      oprot.writeI64(self.cartId)
15322 
      oprot.writeFieldEnd()
15323 
    if self.sourceId is not None:
15324 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15325 
      oprot.writeI64(self.sourceId)
15326 
      oprot.writeFieldEnd()
11980 amit.gupta 15327 
    if self.dealerCoupon is not None:
15328 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15329 
      oprot.writeString(self.dealerCoupon)
15330 
      oprot.writeFieldEnd()
11592 amit.gupta 15331 
    oprot.writeFieldStop()
15332 
    oprot.writeStructEnd()
15333 
 
15334 
  def validate(self):
15335 
    return
15336 
 
15337 
 
15338 
  def __repr__(self):
15339 
    L = ['%s=%r' % (key, value)
15340 
      for key, value in self.__dict__.iteritems()]
15341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15342 
 
15343 
  def __eq__(self, other):
15344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15345 
 
15346 
  def __ne__(self, other):
15347 
    return not (self == other)
15348 
 
15349 
class validateCartPlus_result:
15350 
  """
15351 
  Attributes:
15352 
   - success
15353 
   - scex
15354 
  """
15355 
 
15356 
  thrift_spec = (
15357 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15358 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15359 
  )
15360 
 
15361 
  def __init__(self, success=None, scex=None,):
15362 
    self.success = success
15363 
    self.scex = scex
15364 
 
15365 
  def read(self, iprot):
15366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15368 
      return
15369 
    iprot.readStructBegin()
15370 
    while True:
15371 
      (fname, ftype, fid) = iprot.readFieldBegin()
15372 
      if ftype == TType.STOP:
15373 
        break
15374 
      if fid == 0:
15375 
        if ftype == TType.STRUCT:
15376 
          self.success = CartPlus()
15377 
          self.success.read(iprot)
15378 
        else:
15379 
          iprot.skip(ftype)
15380 
      elif fid == 1:
15381 
        if ftype == TType.STRUCT:
15382 
          self.scex = ShoppingCartException()
15383 
          self.scex.read(iprot)
15384 
        else:
15385 
          iprot.skip(ftype)
15386 
      else:
15387 
        iprot.skip(ftype)
15388 
      iprot.readFieldEnd()
15389 
    iprot.readStructEnd()
15390 
 
15391 
  def write(self, oprot):
15392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15394 
      return
15395 
    oprot.writeStructBegin('validateCartPlus_result')
15396 
    if self.success is not None:
15397 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15398 
      self.success.write(oprot)
15399 
      oprot.writeFieldEnd()
15400 
    if self.scex is not None:
15401 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15402 
      self.scex.write(oprot)
15403 
      oprot.writeFieldEnd()
15404 
    oprot.writeFieldStop()
15405 
    oprot.writeStructEnd()
15406 
 
15407 
  def validate(self):
15408 
    return
15409 
 
15410 
 
15411 
  def __repr__(self):
15412 
    L = ['%s=%r' % (key, value)
15413 
      for key, value in self.__dict__.iteritems()]
15414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15415 
 
15416 
  def __eq__(self, other):
15417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15418 
 
15419 
  def __ne__(self, other):
15420 
    return not (self == other)
11679 vikram.rag 15421 
 
15422 
class isPrivateDealUser_args:
15423 
  """
15424 
  Attributes:
15425 
   - userId
15426 
  """
15427 
 
15428 
  thrift_spec = (
15429 
    None, # 0
15430 
    (1, TType.I64, 'userId', None, None, ), # 1
15431 
  )
15432 
 
15433 
  def __init__(self, userId=None,):
15434 
    self.userId = userId
15435 
 
15436 
  def read(self, iprot):
15437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15439 
      return
15440 
    iprot.readStructBegin()
15441 
    while True:
15442 
      (fname, ftype, fid) = iprot.readFieldBegin()
15443 
      if ftype == TType.STOP:
15444 
        break
15445 
      if fid == 1:
15446 
        if ftype == TType.I64:
15447 
          self.userId = iprot.readI64();
15448 
        else:
15449 
          iprot.skip(ftype)
15450 
      else:
15451 
        iprot.skip(ftype)
15452 
      iprot.readFieldEnd()
15453 
    iprot.readStructEnd()
15454 
 
15455 
  def write(self, oprot):
15456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15458 
      return
15459 
    oprot.writeStructBegin('isPrivateDealUser_args')
15460 
    if self.userId is not None:
15461 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15462 
      oprot.writeI64(self.userId)
15463 
      oprot.writeFieldEnd()
15464 
    oprot.writeFieldStop()
15465 
    oprot.writeStructEnd()
15466 
 
15467 
  def validate(self):
15468 
    return
15469 
 
15470 
 
15471 
  def __repr__(self):
15472 
    L = ['%s=%r' % (key, value)
15473 
      for key, value in self.__dict__.iteritems()]
15474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15475 
 
15476 
  def __eq__(self, other):
15477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15478 
 
15479 
  def __ne__(self, other):
15480 
    return not (self == other)
15481 
 
15482 
class isPrivateDealUser_result:
15483 
  """
15484 
  Attributes:
15485 
   - success
15486 
  """
15487 
 
15488 
  thrift_spec = (
15489 
    (0, TType.BOOL, 'success', None, None, ), # 0
15490 
  )
15491 
 
15492 
  def __init__(self, success=None,):
15493 
    self.success = success
15494 
 
15495 
  def read(self, iprot):
15496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15498 
      return
15499 
    iprot.readStructBegin()
15500 
    while True:
15501 
      (fname, ftype, fid) = iprot.readFieldBegin()
15502 
      if ftype == TType.STOP:
15503 
        break
15504 
      if fid == 0:
15505 
        if ftype == TType.BOOL:
15506 
          self.success = iprot.readBool();
15507 
        else:
15508 
          iprot.skip(ftype)
15509 
      else:
15510 
        iprot.skip(ftype)
15511 
      iprot.readFieldEnd()
15512 
    iprot.readStructEnd()
15513 
 
15514 
  def write(self, oprot):
15515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15517 
      return
15518 
    oprot.writeStructBegin('isPrivateDealUser_result')
15519 
    if self.success is not None:
15520 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15521 
      oprot.writeBool(self.success)
15522 
      oprot.writeFieldEnd()
15523 
    oprot.writeFieldStop()
15524 
    oprot.writeStructEnd()
15525 
 
15526 
  def validate(self):
15527 
    return
15528 
 
15529 
 
15530 
  def __repr__(self):
15531 
    L = ['%s=%r' % (key, value)
15532 
      for key, value in self.__dict__.iteritems()]
15533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15534 
 
15535 
  def __eq__(self, other):
15536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15537 
 
15538 
  def __ne__(self, other):
15539 
    return not (self == other)
11890 kshitij.so 15540 
 
15541 
class addPrivateDealUser_args:
15542 
  """
15543 
  Attributes:
15544 
   - userId
15545 
  """
15546 
 
15547 
  thrift_spec = (
15548 
    None, # 0
15549 
    (1, TType.I64, 'userId', None, None, ), # 1
15550 
  )
15551 
 
15552 
  def __init__(self, userId=None,):
15553 
    self.userId = userId
15554 
 
15555 
  def read(self, iprot):
15556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15558 
      return
15559 
    iprot.readStructBegin()
15560 
    while True:
15561 
      (fname, ftype, fid) = iprot.readFieldBegin()
15562 
      if ftype == TType.STOP:
15563 
        break
15564 
      if fid == 1:
15565 
        if ftype == TType.I64:
15566 
          self.userId = iprot.readI64();
15567 
        else:
15568 
          iprot.skip(ftype)
15569 
      else:
15570 
        iprot.skip(ftype)
15571 
      iprot.readFieldEnd()
15572 
    iprot.readStructEnd()
15573 
 
15574 
  def write(self, oprot):
15575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15577 
      return
15578 
    oprot.writeStructBegin('addPrivateDealUser_args')
15579 
    if self.userId is not None:
15580 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15581 
      oprot.writeI64(self.userId)
15582 
      oprot.writeFieldEnd()
15583 
    oprot.writeFieldStop()
15584 
    oprot.writeStructEnd()
15585 
 
15586 
  def validate(self):
15587 
    return
15588 
 
15589 
 
15590 
  def __repr__(self):
15591 
    L = ['%s=%r' % (key, value)
15592 
      for key, value in self.__dict__.iteritems()]
15593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15594 
 
15595 
  def __eq__(self, other):
15596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15597 
 
15598 
  def __ne__(self, other):
15599 
    return not (self == other)
15600 
 
15601 
class addPrivateDealUser_result:
15602 
  """
15603 
  Attributes:
15604 
   - success
15605 
  """
15606 
 
15607 
  thrift_spec = (
15608 
    (0, TType.BOOL, 'success', None, None, ), # 0
15609 
  )
15610 
 
15611 
  def __init__(self, success=None,):
15612 
    self.success = success
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 == 0:
15624 
        if ftype == TType.BOOL:
15625 
          self.success = iprot.readBool();
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      else:
15629 
        iprot.skip(ftype)
15630 
      iprot.readFieldEnd()
15631 
    iprot.readStructEnd()
15632 
 
15633 
  def write(self, oprot):
15634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15636 
      return
15637 
    oprot.writeStructBegin('addPrivateDealUser_result')
15638 
    if self.success is not None:
15639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15640 
      oprot.writeBool(self.success)
15641 
      oprot.writeFieldEnd()
15642 
    oprot.writeFieldStop()
15643 
    oprot.writeStructEnd()
15644 
 
15645 
  def validate(self):
15646 
    return
15647 
 
15648 
 
15649 
  def __repr__(self):
15650 
    L = ['%s=%r' % (key, value)
15651 
      for key, value in self.__dict__.iteritems()]
15652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15653 
 
15654 
  def __eq__(self, other):
15655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15656 
 
15657 
  def __ne__(self, other):
15658 
    return not (self == other)
15659 
 
15660 
class changePrivateDealUserStatus_args:
15661 
  """
15662 
  Attributes:
15663 
   - userId
15664 
   - isActive
15665 
  """
15666 
 
15667 
  thrift_spec = (
15668 
    None, # 0
15669 
    (1, TType.I64, 'userId', None, None, ), # 1
15670 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15671 
  )
15672 
 
15673 
  def __init__(self, userId=None, isActive=None,):
15674 
    self.userId = userId
15675 
    self.isActive = isActive
15676 
 
15677 
  def read(self, iprot):
15678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15680 
      return
15681 
    iprot.readStructBegin()
15682 
    while True:
15683 
      (fname, ftype, fid) = iprot.readFieldBegin()
15684 
      if ftype == TType.STOP:
15685 
        break
15686 
      if fid == 1:
15687 
        if ftype == TType.I64:
15688 
          self.userId = iprot.readI64();
15689 
        else:
15690 
          iprot.skip(ftype)
15691 
      elif fid == 2:
15692 
        if ftype == TType.BOOL:
15693 
          self.isActive = iprot.readBool();
15694 
        else:
15695 
          iprot.skip(ftype)
15696 
      else:
15697 
        iprot.skip(ftype)
15698 
      iprot.readFieldEnd()
15699 
    iprot.readStructEnd()
15700 
 
15701 
  def write(self, oprot):
15702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15704 
      return
15705 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15706 
    if self.userId is not None:
15707 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15708 
      oprot.writeI64(self.userId)
15709 
      oprot.writeFieldEnd()
15710 
    if self.isActive is not None:
15711 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15712 
      oprot.writeBool(self.isActive)
15713 
      oprot.writeFieldEnd()
15714 
    oprot.writeFieldStop()
15715 
    oprot.writeStructEnd()
15716 
 
15717 
  def validate(self):
15718 
    return
15719 
 
15720 
 
15721 
  def __repr__(self):
15722 
    L = ['%s=%r' % (key, value)
15723 
      for key, value in self.__dict__.iteritems()]
15724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15725 
 
15726 
  def __eq__(self, other):
15727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15728 
 
15729 
  def __ne__(self, other):
15730 
    return not (self == other)
15731 
 
15732 
class changePrivateDealUserStatus_result:
15733 
  """
15734 
  Attributes:
15735 
   - success
15736 
  """
15737 
 
15738 
  thrift_spec = (
15739 
    (0, TType.BOOL, 'success', None, None, ), # 0
15740 
  )
15741 
 
15742 
  def __init__(self, success=None,):
15743 
    self.success = success
15744 
 
15745 
  def read(self, iprot):
15746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15748 
      return
15749 
    iprot.readStructBegin()
15750 
    while True:
15751 
      (fname, ftype, fid) = iprot.readFieldBegin()
15752 
      if ftype == TType.STOP:
15753 
        break
15754 
      if fid == 0:
15755 
        if ftype == TType.BOOL:
15756 
          self.success = iprot.readBool();
15757 
        else:
15758 
          iprot.skip(ftype)
15759 
      else:
15760 
        iprot.skip(ftype)
15761 
      iprot.readFieldEnd()
15762 
    iprot.readStructEnd()
15763 
 
15764 
  def write(self, oprot):
15765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15767 
      return
15768 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15769 
    if self.success is not None:
15770 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15771 
      oprot.writeBool(self.success)
15772 
      oprot.writeFieldEnd()
15773 
    oprot.writeFieldStop()
15774 
    oprot.writeStructEnd()
15775 
 
15776 
  def validate(self):
15777 
    return
15778 
 
15779 
 
15780 
  def __repr__(self):
15781 
    L = ['%s=%r' % (key, value)
15782 
      for key, value in self.__dict__.iteritems()]
15783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15784 
 
15785 
  def __eq__(self, other):
15786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15787 
 
15788 
  def __ne__(self, other):
15789 
    return not (self == other)
15790 
 
15791 
class getPrivateDealUser_args:
15792 
  """
15793 
  Attributes:
15794 
   - userId
15795 
  """
15796 
 
15797 
  thrift_spec = (
15798 
    None, # 0
15799 
    (1, TType.I64, 'userId', None, None, ), # 1
15800 
  )
15801 
 
15802 
  def __init__(self, userId=None,):
15803 
    self.userId = userId
15804 
 
15805 
  def read(self, iprot):
15806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15808 
      return
15809 
    iprot.readStructBegin()
15810 
    while True:
15811 
      (fname, ftype, fid) = iprot.readFieldBegin()
15812 
      if ftype == TType.STOP:
15813 
        break
15814 
      if fid == 1:
15815 
        if ftype == TType.I64:
15816 
          self.userId = iprot.readI64();
15817 
        else:
15818 
          iprot.skip(ftype)
15819 
      else:
15820 
        iprot.skip(ftype)
15821 
      iprot.readFieldEnd()
15822 
    iprot.readStructEnd()
15823 
 
15824 
  def write(self, oprot):
15825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15827 
      return
15828 
    oprot.writeStructBegin('getPrivateDealUser_args')
15829 
    if self.userId is not None:
15830 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15831 
      oprot.writeI64(self.userId)
15832 
      oprot.writeFieldEnd()
15833 
    oprot.writeFieldStop()
15834 
    oprot.writeStructEnd()
15835 
 
15836 
  def validate(self):
15837 
    return
15838 
 
15839 
 
15840 
  def __repr__(self):
15841 
    L = ['%s=%r' % (key, value)
15842 
      for key, value in self.__dict__.iteritems()]
15843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15844 
 
15845 
  def __eq__(self, other):
15846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15847 
 
15848 
  def __ne__(self, other):
15849 
    return not (self == other)
15850 
 
15851 
class getPrivateDealUser_result:
15852 
  """
15853 
  Attributes:
15854 
   - success
15855 
  """
15856 
 
15857 
  thrift_spec = (
15858 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15859 
  )
15860 
 
15861 
  def __init__(self, success=None,):
15862 
    self.success = success
15863 
 
15864 
  def read(self, iprot):
15865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15867 
      return
15868 
    iprot.readStructBegin()
15869 
    while True:
15870 
      (fname, ftype, fid) = iprot.readFieldBegin()
15871 
      if ftype == TType.STOP:
15872 
        break
15873 
      if fid == 0:
15874 
        if ftype == TType.STRUCT:
15875 
          self.success = PrivateDealUser()
15876 
          self.success.read(iprot)
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
15888 
    oprot.writeStructBegin('getPrivateDealUser_result')
15889 
    if self.success is not None:
15890 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15891 
      self.success.write(oprot)
15892 
      oprot.writeFieldEnd()
15893 
    oprot.writeFieldStop()
15894 
    oprot.writeStructEnd()
15895 
 
15896 
  def validate(self):
15897 
    return
15898 
 
15899 
 
15900 
  def __repr__(self):
15901 
    L = ['%s=%r' % (key, value)
15902 
      for key, value in self.__dict__.iteritems()]
15903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15904 
 
15905 
  def __eq__(self, other):
15906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15907 
 
15908 
  def __ne__(self, other):
15909 
    return not (self == other)
12696 amit.gupta 15910 
 
15911 
class registerCounter_args:
15912 
  """
15913 
  Attributes:
15914 
   - counter
15915 
   - userId
15916 
  """
15917 
 
15918 
  thrift_spec = (
15919 
    None, # 0
15920 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15921 
    (2, TType.I64, 'userId', None, None, ), # 2
15922 
  )
15923 
 
15924 
  def __init__(self, counter=None, userId=None,):
15925 
    self.counter = counter
15926 
    self.userId = userId
15927 
 
15928 
  def read(self, iprot):
15929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15931 
      return
15932 
    iprot.readStructBegin()
15933 
    while True:
15934 
      (fname, ftype, fid) = iprot.readFieldBegin()
15935 
      if ftype == TType.STOP:
15936 
        break
15937 
      if fid == 1:
15938 
        if ftype == TType.STRUCT:
15939 
          self.counter = Counter()
15940 
          self.counter.read(iprot)
15941 
        else:
15942 
          iprot.skip(ftype)
15943 
      elif fid == 2:
15944 
        if ftype == TType.I64:
15945 
          self.userId = iprot.readI64();
15946 
        else:
15947 
          iprot.skip(ftype)
15948 
      else:
15949 
        iprot.skip(ftype)
15950 
      iprot.readFieldEnd()
15951 
    iprot.readStructEnd()
15952 
 
15953 
  def write(self, oprot):
15954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15956 
      return
15957 
    oprot.writeStructBegin('registerCounter_args')
15958 
    if self.counter is not None:
15959 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15960 
      self.counter.write(oprot)
15961 
      oprot.writeFieldEnd()
15962 
    if self.userId is not None:
15963 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15964 
      oprot.writeI64(self.userId)
15965 
      oprot.writeFieldEnd()
15966 
    oprot.writeFieldStop()
15967 
    oprot.writeStructEnd()
15968 
 
15969 
  def validate(self):
15970 
    return
15971 
 
15972 
 
15973 
  def __repr__(self):
15974 
    L = ['%s=%r' % (key, value)
15975 
      for key, value in self.__dict__.iteritems()]
15976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15977 
 
15978 
  def __eq__(self, other):
15979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15980 
 
15981 
  def __ne__(self, other):
15982 
    return not (self == other)
15983 
 
15984 
class registerCounter_result:
15985 
  """
15986 
  Attributes:
15987 
   - success
15988 
  """
15989 
 
15990 
  thrift_spec = (
15991 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15992 
  )
15993 
 
15994 
  def __init__(self, success=None,):
15995 
    self.success = success
15996 
 
15997 
  def read(self, iprot):
15998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16000 
      return
16001 
    iprot.readStructBegin()
16002 
    while True:
16003 
      (fname, ftype, fid) = iprot.readFieldBegin()
16004 
      if ftype == TType.STOP:
16005 
        break
16006 
      if fid == 0:
16007 
        if ftype == TType.MAP:
16008 
          self.success = {}
16009 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16010 
          for _i229 in xrange(_size225):
16011 
            _key230 = iprot.readString();
16012 
            _val231 = iprot.readString();
16013 
            self.success[_key230] = _val231
16014 
          iprot.readMapEnd()
16015 
        else:
16016 
          iprot.skip(ftype)
16017 
      else:
16018 
        iprot.skip(ftype)
16019 
      iprot.readFieldEnd()
16020 
    iprot.readStructEnd()
16021 
 
16022 
  def write(self, oprot):
16023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16025 
      return
16026 
    oprot.writeStructBegin('registerCounter_result')
16027 
    if self.success is not None:
16028 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16029 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16030 
      for kiter232,viter233 in self.success.items():
16031 
        oprot.writeString(kiter232)
16032 
        oprot.writeString(viter233)
16033 
      oprot.writeMapEnd()
16034 
      oprot.writeFieldEnd()
16035 
    oprot.writeFieldStop()
16036 
    oprot.writeStructEnd()
16037 
 
16038 
  def validate(self):
16039 
    return
16040 
 
16041 
 
16042 
  def __repr__(self):
16043 
    L = ['%s=%r' % (key, value)
16044 
      for key, value in self.__dict__.iteritems()]
16045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16046 
 
16047 
  def __eq__(self, other):
16048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16049 
 
16050 
  def __ne__(self, other):
16051 
    return not (self == other)
12722 amit.gupta 16052 
 
16053 
class searchCounter_args:
16054 
  """
16055 
  Attributes:
16056 
   - type1
16057 
   - searchString
16058 
  """
16059 
 
16060 
  thrift_spec = (
16061 
    None, # 0
16062 
    (1, TType.STRING, 'type1', None, None, ), # 1
16063 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16064 
  )
16065 
 
16066 
  def __init__(self, type1=None, searchString=None,):
16067 
    self.type1 = type1
16068 
    self.searchString = searchString
16069 
 
16070 
  def read(self, iprot):
16071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16073 
      return
16074 
    iprot.readStructBegin()
16075 
    while True:
16076 
      (fname, ftype, fid) = iprot.readFieldBegin()
16077 
      if ftype == TType.STOP:
16078 
        break
16079 
      if fid == 1:
16080 
        if ftype == TType.STRING:
16081 
          self.type1 = iprot.readString();
16082 
        else:
16083 
          iprot.skip(ftype)
16084 
      elif fid == 2:
16085 
        if ftype == TType.STRING:
16086 
          self.searchString = iprot.readString();
16087 
        else:
16088 
          iprot.skip(ftype)
16089 
      else:
16090 
        iprot.skip(ftype)
16091 
      iprot.readFieldEnd()
16092 
    iprot.readStructEnd()
16093 
 
16094 
  def write(self, oprot):
16095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16097 
      return
16098 
    oprot.writeStructBegin('searchCounter_args')
16099 
    if self.type1 is not None:
16100 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16101 
      oprot.writeString(self.type1)
16102 
      oprot.writeFieldEnd()
16103 
    if self.searchString is not None:
16104 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16105 
      oprot.writeString(self.searchString)
16106 
      oprot.writeFieldEnd()
16107 
    oprot.writeFieldStop()
16108 
    oprot.writeStructEnd()
16109 
 
16110 
  def validate(self):
16111 
    return
16112 
 
16113 
 
16114 
  def __repr__(self):
16115 
    L = ['%s=%r' % (key, value)
16116 
      for key, value in self.__dict__.iteritems()]
16117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16118 
 
16119 
  def __eq__(self, other):
16120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16121 
 
16122 
  def __ne__(self, other):
16123 
    return not (self == other)
16124 
 
16125 
class searchCounter_result:
16126 
  """
16127 
  Attributes:
16128 
   - success
16129 
  """
16130 
 
16131 
  thrift_spec = (
16132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16133 
  )
16134 
 
16135 
  def __init__(self, success=None,):
16136 
    self.success = success
16137 
 
16138 
  def read(self, iprot):
16139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16141 
      return
16142 
    iprot.readStructBegin()
16143 
    while True:
16144 
      (fname, ftype, fid) = iprot.readFieldBegin()
16145 
      if ftype == TType.STOP:
16146 
        break
16147 
      if fid == 0:
16148 
        if ftype == TType.LIST:
16149 
          self.success = []
16150 
          (_etype237, _size234) = iprot.readListBegin()
16151 
          for _i238 in xrange(_size234):
16152 
            _elem239 = Counter()
16153 
            _elem239.read(iprot)
16154 
            self.success.append(_elem239)
16155 
          iprot.readListEnd()
16156 
        else:
16157 
          iprot.skip(ftype)
16158 
      else:
16159 
        iprot.skip(ftype)
16160 
      iprot.readFieldEnd()
16161 
    iprot.readStructEnd()
16162 
 
16163 
  def write(self, oprot):
16164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16166 
      return
16167 
    oprot.writeStructBegin('searchCounter_result')
16168 
    if self.success is not None:
16169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16171 
      for iter240 in self.success:
16172 
        iter240.write(oprot)
16173 
      oprot.writeListEnd()
16174 
      oprot.writeFieldEnd()
16175 
    oprot.writeFieldStop()
16176 
    oprot.writeStructEnd()
16177 
 
16178 
  def validate(self):
16179 
    return
16180 
 
16181 
 
16182 
  def __repr__(self):
16183 
    L = ['%s=%r' % (key, value)
16184 
      for key, value in self.__dict__.iteritems()]
16185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16186 
 
16187 
  def __eq__(self, other):
16188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16189 
 
16190 
  def __ne__(self, other):
16191 
    return not (self == other)
16192 
 
16193 
class getAllUsersByCounter_args:
16194 
  """
16195 
  Attributes:
16196 
   - counterId
16197 
  """
16198 
 
16199 
  thrift_spec = (
16200 
    None, # 0
16201 
    (1, TType.I64, 'counterId', None, None, ), # 1
16202 
  )
16203 
 
16204 
  def __init__(self, counterId=None,):
16205 
    self.counterId = counterId
16206 
 
16207 
  def read(self, iprot):
16208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16210 
      return
16211 
    iprot.readStructBegin()
16212 
    while True:
16213 
      (fname, ftype, fid) = iprot.readFieldBegin()
16214 
      if ftype == TType.STOP:
16215 
        break
16216 
      if fid == 1:
16217 
        if ftype == TType.I64:
16218 
          self.counterId = iprot.readI64();
16219 
        else:
16220 
          iprot.skip(ftype)
16221 
      else:
16222 
        iprot.skip(ftype)
16223 
      iprot.readFieldEnd()
16224 
    iprot.readStructEnd()
16225 
 
16226 
  def write(self, oprot):
16227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16229 
      return
16230 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16231 
    if self.counterId is not None:
16232 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16233 
      oprot.writeI64(self.counterId)
16234 
      oprot.writeFieldEnd()
16235 
    oprot.writeFieldStop()
16236 
    oprot.writeStructEnd()
16237 
 
16238 
  def validate(self):
16239 
    return
16240 
 
16241 
 
16242 
  def __repr__(self):
16243 
    L = ['%s=%r' % (key, value)
16244 
      for key, value in self.__dict__.iteritems()]
16245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16246 
 
16247 
  def __eq__(self, other):
16248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16249 
 
16250 
  def __ne__(self, other):
16251 
    return not (self == other)
16252 
 
16253 
class getAllUsersByCounter_result:
16254 
  """
16255 
  Attributes:
16256 
   - success
16257 
  """
16258 
 
16259 
  thrift_spec = (
16260 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16261 
  )
16262 
 
16263 
  def __init__(self, success=None,):
16264 
    self.success = success
16265 
 
16266 
  def read(self, iprot):
16267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16269 
      return
16270 
    iprot.readStructBegin()
16271 
    while True:
16272 
      (fname, ftype, fid) = iprot.readFieldBegin()
16273 
      if ftype == TType.STOP:
16274 
        break
16275 
      if fid == 0:
16276 
        if ftype == TType.LIST:
16277 
          self.success = []
16278 
          (_etype244, _size241) = iprot.readListBegin()
16279 
          for _i245 in xrange(_size241):
16280 
            _elem246 = User()
16281 
            _elem246.read(iprot)
16282 
            self.success.append(_elem246)
16283 
          iprot.readListEnd()
16284 
        else:
16285 
          iprot.skip(ftype)
16286 
      else:
16287 
        iprot.skip(ftype)
16288 
      iprot.readFieldEnd()
16289 
    iprot.readStructEnd()
16290 
 
16291 
  def write(self, oprot):
16292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16294 
      return
16295 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16296 
    if self.success is not None:
16297 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16298 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16299 
      for iter247 in self.success:
16300 
        iter247.write(oprot)
16301 
      oprot.writeListEnd()
16302 
      oprot.writeFieldEnd()
16303 
    oprot.writeFieldStop()
16304 
    oprot.writeStructEnd()
16305 
 
16306 
  def validate(self):
16307 
    return
16308 
 
16309 
 
16310 
  def __repr__(self):
16311 
    L = ['%s=%r' % (key, value)
16312 
      for key, value in self.__dict__.iteritems()]
16313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16314 
 
16315 
  def __eq__(self, other):
16316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16317 
 
16318 
  def __ne__(self, other):
16319 
    return not (self == other)
15251 manish.sha 16320 
 
16321 
class getActiveAccessTokenForUser_args:
16322 
  """
16323 
  Attributes:
16324 
   - userId
16325 
   - source
16326 
  """
16327 
 
16328 
  thrift_spec = (
16329 
    None, # 0
16330 
    (1, TType.I64, 'userId', None, None, ), # 1
16331 
    (2, TType.STRING, 'source', None, None, ), # 2
16332 
  )
16333 
 
16334 
  def __init__(self, userId=None, source=None,):
16335 
    self.userId = userId
16336 
    self.source = source
16337 
 
16338 
  def read(self, iprot):
16339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16341 
      return
16342 
    iprot.readStructBegin()
16343 
    while True:
16344 
      (fname, ftype, fid) = iprot.readFieldBegin()
16345 
      if ftype == TType.STOP:
16346 
        break
16347 
      if fid == 1:
16348 
        if ftype == TType.I64:
16349 
          self.userId = iprot.readI64();
16350 
        else:
16351 
          iprot.skip(ftype)
16352 
      elif fid == 2:
16353 
        if ftype == TType.STRING:
16354 
          self.source = iprot.readString();
16355 
        else:
16356 
          iprot.skip(ftype)
16357 
      else:
16358 
        iprot.skip(ftype)
16359 
      iprot.readFieldEnd()
16360 
    iprot.readStructEnd()
16361 
 
16362 
  def write(self, oprot):
16363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16365 
      return
16366 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16367 
    if self.userId is not None:
16368 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16369 
      oprot.writeI64(self.userId)
16370 
      oprot.writeFieldEnd()
16371 
    if self.source is not None:
16372 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16373 
      oprot.writeString(self.source)
16374 
      oprot.writeFieldEnd()
16375 
    oprot.writeFieldStop()
16376 
    oprot.writeStructEnd()
16377 
 
16378 
  def validate(self):
16379 
    return
16380 
 
16381 
 
16382 
  def __repr__(self):
16383 
    L = ['%s=%r' % (key, value)
16384 
      for key, value in self.__dict__.iteritems()]
16385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16386 
 
16387 
  def __eq__(self, other):
16388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16389 
 
16390 
  def __ne__(self, other):
16391 
    return not (self == other)
16392 
 
16393 
class getActiveAccessTokenForUser_result:
16394 
  """
16395 
  Attributes:
16396 
   - success
16397 
  """
16398 
 
16399 
  thrift_spec = (
16400 
    (0, TType.STRING, 'success', None, None, ), # 0
16401 
  )
16402 
 
16403 
  def __init__(self, success=None,):
16404 
    self.success = success
16405 
 
16406 
  def read(self, iprot):
16407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16409 
      return
16410 
    iprot.readStructBegin()
16411 
    while True:
16412 
      (fname, ftype, fid) = iprot.readFieldBegin()
16413 
      if ftype == TType.STOP:
16414 
        break
16415 
      if fid == 0:
16416 
        if ftype == TType.STRING:
16417 
          self.success = iprot.readString();
16418 
        else:
16419 
          iprot.skip(ftype)
16420 
      else:
16421 
        iprot.skip(ftype)
16422 
      iprot.readFieldEnd()
16423 
    iprot.readStructEnd()
16424 
 
16425 
  def write(self, oprot):
16426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16428 
      return
16429 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16430 
    if self.success is not None:
16431 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16432 
      oprot.writeString(self.success)
16433 
      oprot.writeFieldEnd()
16434 
    oprot.writeFieldStop()
16435 
    oprot.writeStructEnd()
16436 
 
16437 
  def validate(self):
16438 
    return
16439 
 
16440 
 
16441 
  def __repr__(self):
16442 
    L = ['%s=%r' % (key, value)
16443 
      for key, value in self.__dict__.iteritems()]
16444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16445 
 
16446 
  def __eq__(self, other):
16447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16448 
 
16449 
  def __ne__(self, other):
16450 
    return not (self == other)
16451 
 
16452 
class validateAccessToken_args:
16453 
  """
16454 
  Attributes:
16455 
   - accessToken
16456 
  """
16457 
 
16458 
  thrift_spec = (
16459 
    None, # 0
16460 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16461 
  )
16462 
 
16463 
  def __init__(self, accessToken=None,):
16464 
    self.accessToken = accessToken
16465 
 
16466 
  def read(self, iprot):
16467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16469 
      return
16470 
    iprot.readStructBegin()
16471 
    while True:
16472 
      (fname, ftype, fid) = iprot.readFieldBegin()
16473 
      if ftype == TType.STOP:
16474 
        break
16475 
      if fid == 1:
16476 
        if ftype == TType.STRING:
16477 
          self.accessToken = iprot.readString();
16478 
        else:
16479 
          iprot.skip(ftype)
16480 
      else:
16481 
        iprot.skip(ftype)
16482 
      iprot.readFieldEnd()
16483 
    iprot.readStructEnd()
16484 
 
16485 
  def write(self, oprot):
16486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16488 
      return
16489 
    oprot.writeStructBegin('validateAccessToken_args')
16490 
    if self.accessToken is not None:
16491 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16492 
      oprot.writeString(self.accessToken)
16493 
      oprot.writeFieldEnd()
16494 
    oprot.writeFieldStop()
16495 
    oprot.writeStructEnd()
16496 
 
16497 
  def validate(self):
16498 
    return
16499 
 
16500 
 
16501 
  def __repr__(self):
16502 
    L = ['%s=%r' % (key, value)
16503 
      for key, value in self.__dict__.iteritems()]
16504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16505 
 
16506 
  def __eq__(self, other):
16507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16508 
 
16509 
  def __ne__(self, other):
16510 
    return not (self == other)
16511 
 
16512 
class validateAccessToken_result:
16513 
  """
16514 
  Attributes:
16515 
   - success
16516 
  """
16517 
 
16518 
  thrift_spec = (
16519 
    (0, TType.BOOL, 'success', None, None, ), # 0
16520 
  )
16521 
 
16522 
  def __init__(self, success=None,):
16523 
    self.success = success
16524 
 
16525 
  def read(self, iprot):
16526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16528 
      return
16529 
    iprot.readStructBegin()
16530 
    while True:
16531 
      (fname, ftype, fid) = iprot.readFieldBegin()
16532 
      if ftype == TType.STOP:
16533 
        break
16534 
      if fid == 0:
16535 
        if ftype == TType.BOOL:
16536 
          self.success = iprot.readBool();
16537 
        else:
16538 
          iprot.skip(ftype)
16539 
      else:
16540 
        iprot.skip(ftype)
16541 
      iprot.readFieldEnd()
16542 
    iprot.readStructEnd()
16543 
 
16544 
  def write(self, oprot):
16545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16547 
      return
16548 
    oprot.writeStructBegin('validateAccessToken_result')
16549 
    if self.success is not None:
16550 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16551 
      oprot.writeBool(self.success)
16552 
      oprot.writeFieldEnd()
16553 
    oprot.writeFieldStop()
16554 
    oprot.writeStructEnd()
16555 
 
16556 
  def validate(self):
16557 
    return
16558 
 
16559 
 
16560 
  def __repr__(self):
16561 
    L = ['%s=%r' % (key, value)
16562 
      for key, value in self.__dict__.iteritems()]
16563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16564 
 
16565 
  def __eq__(self, other):
16566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16567 
 
16568 
  def __ne__(self, other):
16569 
    return not (self == other)
17782 amit.gupta 16570 
 
16571 
class addItemsToCart_args:
16572 
  """
16573 
  Attributes:
16574 
   - cartId
16575 
   - itemQty
16576 
   - couponCode
16577 
  """
16578 
 
16579 
  thrift_spec = (
16580 
    None, # 0
16581 
    (1, TType.I64, 'cartId', None, None, ), # 1
16582 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16583 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16584 
  )
16585 
 
16586 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16587 
    self.cartId = cartId
16588 
    self.itemQty = itemQty
16589 
    self.couponCode = couponCode
16590 
 
16591 
  def read(self, iprot):
16592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16594 
      return
16595 
    iprot.readStructBegin()
16596 
    while True:
16597 
      (fname, ftype, fid) = iprot.readFieldBegin()
16598 
      if ftype == TType.STOP:
16599 
        break
16600 
      if fid == 1:
16601 
        if ftype == TType.I64:
16602 
          self.cartId = iprot.readI64();
16603 
        else:
16604 
          iprot.skip(ftype)
16605 
      elif fid == 2:
16606 
        if ftype == TType.LIST:
16607 
          self.itemQty = []
16608 
          (_etype251, _size248) = iprot.readListBegin()
16609 
          for _i252 in xrange(_size248):
16610 
            _elem253 = ItemQuantity()
16611 
            _elem253.read(iprot)
16612 
            self.itemQty.append(_elem253)
16613 
          iprot.readListEnd()
16614 
        else:
16615 
          iprot.skip(ftype)
16616 
      elif fid == 3:
16617 
        if ftype == TType.STRING:
16618 
          self.couponCode = iprot.readString();
16619 
        else:
16620 
          iprot.skip(ftype)
16621 
      else:
16622 
        iprot.skip(ftype)
16623 
      iprot.readFieldEnd()
16624 
    iprot.readStructEnd()
16625 
 
16626 
  def write(self, oprot):
16627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16629 
      return
16630 
    oprot.writeStructBegin('addItemsToCart_args')
16631 
    if self.cartId is not None:
16632 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16633 
      oprot.writeI64(self.cartId)
16634 
      oprot.writeFieldEnd()
16635 
    if self.itemQty is not None:
16636 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16637 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16638 
      for iter254 in self.itemQty:
16639 
        iter254.write(oprot)
16640 
      oprot.writeListEnd()
16641 
      oprot.writeFieldEnd()
16642 
    if self.couponCode is not None:
16643 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16644 
      oprot.writeString(self.couponCode)
16645 
      oprot.writeFieldEnd()
16646 
    oprot.writeFieldStop()
16647 
    oprot.writeStructEnd()
16648 
 
16649 
  def validate(self):
16650 
    return
16651 
 
16652 
 
16653 
  def __repr__(self):
16654 
    L = ['%s=%r' % (key, value)
16655 
      for key, value in self.__dict__.iteritems()]
16656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16657 
 
16658 
  def __eq__(self, other):
16659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16660 
 
16661 
  def __ne__(self, other):
16662 
    return not (self == other)
16663 
 
16664 
class addItemsToCart_result:
16665 
  """
16666 
  Attributes:
16667 
   - success
16668 
  """
16669 
 
16670 
  thrift_spec = (
16671 
    (0, TType.BOOL, 'success', None, None, ), # 0
16672 
  )
16673 
 
16674 
  def __init__(self, success=None,):
16675 
    self.success = success
16676 
 
16677 
  def read(self, iprot):
16678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16680 
      return
16681 
    iprot.readStructBegin()
16682 
    while True:
16683 
      (fname, ftype, fid) = iprot.readFieldBegin()
16684 
      if ftype == TType.STOP:
16685 
        break
16686 
      if fid == 0:
16687 
        if ftype == TType.BOOL:
16688 
          self.success = iprot.readBool();
16689 
        else:
16690 
          iprot.skip(ftype)
16691 
      else:
16692 
        iprot.skip(ftype)
16693 
      iprot.readFieldEnd()
16694 
    iprot.readStructEnd()
16695 
 
16696 
  def write(self, oprot):
16697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16699 
      return
16700 
    oprot.writeStructBegin('addItemsToCart_result')
16701 
    if self.success is not None:
16702 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16703 
      oprot.writeBool(self.success)
16704 
      oprot.writeFieldEnd()
16705 
    oprot.writeFieldStop()
16706 
    oprot.writeStructEnd()
16707 
 
16708 
  def validate(self):
16709 
    return
16710 
 
16711 
 
16712 
  def __repr__(self):
16713 
    L = ['%s=%r' % (key, value)
16714 
      for key, value in self.__dict__.iteritems()]
16715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16716 
 
16717 
  def __eq__(self, other):
16718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16719 
 
16720 
  def __ne__(self, other):
16721 
    return not (self == other)
16722 
 
16723 
class validateCartNew_args:
16724 
  """
16725 
  Attributes:
16726 
   - cartId
16727 
   - pinCode
16728 
   - sourceId
16729 
  """
16730 
 
16731 
  thrift_spec = (
16732 
    None, # 0
16733 
    (1, TType.I64, 'cartId', None, None, ), # 1
16734 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16735 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16736 
  )
16737 
 
16738 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16739 
    self.cartId = cartId
16740 
    self.pinCode = pinCode
16741 
    self.sourceId = sourceId
16742 
 
16743 
  def read(self, iprot):
16744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16746 
      return
16747 
    iprot.readStructBegin()
16748 
    while True:
16749 
      (fname, ftype, fid) = iprot.readFieldBegin()
16750 
      if ftype == TType.STOP:
16751 
        break
16752 
      if fid == 1:
16753 
        if ftype == TType.I64:
16754 
          self.cartId = iprot.readI64();
16755 
        else:
16756 
          iprot.skip(ftype)
16757 
      elif fid == 2:
16758 
        if ftype == TType.STRING:
16759 
          self.pinCode = iprot.readString();
16760 
        else:
16761 
          iprot.skip(ftype)
16762 
      elif fid == 3:
16763 
        if ftype == TType.I64:
16764 
          self.sourceId = iprot.readI64();
16765 
        else:
16766 
          iprot.skip(ftype)
16767 
      else:
16768 
        iprot.skip(ftype)
16769 
      iprot.readFieldEnd()
16770 
    iprot.readStructEnd()
16771 
 
16772 
  def write(self, oprot):
16773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16775 
      return
16776 
    oprot.writeStructBegin('validateCartNew_args')
16777 
    if self.cartId is not None:
16778 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16779 
      oprot.writeI64(self.cartId)
16780 
      oprot.writeFieldEnd()
16781 
    if self.pinCode is not None:
16782 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
16783 
      oprot.writeString(self.pinCode)
16784 
      oprot.writeFieldEnd()
16785 
    if self.sourceId is not None:
16786 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
16787 
      oprot.writeI64(self.sourceId)
16788 
      oprot.writeFieldEnd()
16789 
    oprot.writeFieldStop()
16790 
    oprot.writeStructEnd()
16791 
 
16792 
  def validate(self):
16793 
    return
16794 
 
16795 
 
16796 
  def __repr__(self):
16797 
    L = ['%s=%r' % (key, value)
16798 
      for key, value in self.__dict__.iteritems()]
16799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16800 
 
16801 
  def __eq__(self, other):
16802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16803 
 
16804 
  def __ne__(self, other):
16805 
    return not (self == other)
16806 
 
16807 
class validateCartNew_result:
16808 
  """
16809 
  Attributes:
16810 
   - success
16811 
  """
16812 
 
16813 
  thrift_spec = (
16814 
    (0, TType.STRING, 'success', None, None, ), # 0
16815 
  )
16816 
 
16817 
  def __init__(self, success=None,):
16818 
    self.success = success
16819 
 
16820 
  def read(self, iprot):
16821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16823 
      return
16824 
    iprot.readStructBegin()
16825 
    while True:
16826 
      (fname, ftype, fid) = iprot.readFieldBegin()
16827 
      if ftype == TType.STOP:
16828 
        break
16829 
      if fid == 0:
16830 
        if ftype == TType.STRING:
16831 
          self.success = iprot.readString();
16832 
        else:
16833 
          iprot.skip(ftype)
16834 
      else:
16835 
        iprot.skip(ftype)
16836 
      iprot.readFieldEnd()
16837 
    iprot.readStructEnd()
16838 
 
16839 
  def write(self, oprot):
16840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16842 
      return
16843 
    oprot.writeStructBegin('validateCartNew_result')
16844 
    if self.success is not None:
16845 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16846 
      oprot.writeString(self.success)
16847 
      oprot.writeFieldEnd()
16848 
    oprot.writeFieldStop()
16849 
    oprot.writeStructEnd()
16850 
 
16851 
  def validate(self):
16852 
    return
16853 
 
16854 
 
16855 
  def __repr__(self):
16856 
    L = ['%s=%r' % (key, value)
16857 
      for key, value in self.__dict__.iteritems()]
16858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16859 
 
16860 
  def __eq__(self, other):
16861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16862 
 
16863 
  def __ne__(self, other):
16864 
    return not (self == other)
18530 manish.sha 16865 
 
18644 manish.sha 16866 
class isAddressEditableForCounter_args:
18530 manish.sha 16867 
  """
16868 
  Attributes:
16869 
   - userId
16870 
  """
16871 
 
16872 
  thrift_spec = (
16873 
    None, # 0
16874 
    (1, TType.I64, 'userId', None, None, ), # 1
16875 
  )
16876 
 
16877 
  def __init__(self, userId=None,):
16878 
    self.userId = userId
16879 
 
16880 
  def read(self, iprot):
16881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16883 
      return
16884 
    iprot.readStructBegin()
16885 
    while True:
16886 
      (fname, ftype, fid) = iprot.readFieldBegin()
16887 
      if ftype == TType.STOP:
16888 
        break
16889 
      if fid == 1:
16890 
        if ftype == TType.I64:
16891 
          self.userId = iprot.readI64();
16892 
        else:
16893 
          iprot.skip(ftype)
16894 
      else:
16895 
        iprot.skip(ftype)
16896 
      iprot.readFieldEnd()
16897 
    iprot.readStructEnd()
16898 
 
16899 
  def write(self, oprot):
16900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16902 
      return
18644 manish.sha 16903 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 16904 
    if self.userId is not None:
16905 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16906 
      oprot.writeI64(self.userId)
16907 
      oprot.writeFieldEnd()
16908 
    oprot.writeFieldStop()
16909 
    oprot.writeStructEnd()
16910 
 
16911 
  def validate(self):
16912 
    return
16913 
 
16914 
 
16915 
  def __repr__(self):
16916 
    L = ['%s=%r' % (key, value)
16917 
      for key, value in self.__dict__.iteritems()]
16918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16919 
 
16920 
  def __eq__(self, other):
16921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16922 
 
16923 
  def __ne__(self, other):
16924 
    return not (self == other)
16925 
 
18644 manish.sha 16926 
class isAddressEditableForCounter_result:
18530 manish.sha 16927 
  """
16928 
  Attributes:
16929 
   - success
16930 
  """
16931 
 
16932 
  thrift_spec = (
16933 
    (0, TType.BOOL, 'success', None, None, ), # 0
16934 
  )
16935 
 
16936 
  def __init__(self, success=None,):
16937 
    self.success = success
16938 
 
16939 
  def read(self, iprot):
16940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16942 
      return
16943 
    iprot.readStructBegin()
16944 
    while True:
16945 
      (fname, ftype, fid) = iprot.readFieldBegin()
16946 
      if ftype == TType.STOP:
16947 
        break
16948 
      if fid == 0:
16949 
        if ftype == TType.BOOL:
16950 
          self.success = iprot.readBool();
16951 
        else:
16952 
          iprot.skip(ftype)
16953 
      else:
16954 
        iprot.skip(ftype)
16955 
      iprot.readFieldEnd()
16956 
    iprot.readStructEnd()
16957 
 
16958 
  def write(self, oprot):
16959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16961 
      return
18644 manish.sha 16962 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 16963 
    if self.success is not None:
16964 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16965 
      oprot.writeBool(self.success)
16966 
      oprot.writeFieldEnd()
16967 
    oprot.writeFieldStop()
16968 
    oprot.writeStructEnd()
16969 
 
16970 
  def validate(self):
16971 
    return
16972 
 
16973 
 
16974 
  def __repr__(self):
16975 
    L = ['%s=%r' % (key, value)
16976 
      for key, value in self.__dict__.iteritems()]
16977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16978 
 
16979 
  def __eq__(self, other):
16980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16981 
 
16982 
  def __ne__(self, other):
16983 
    return not (self == other)
16984 
 
16985 
class getBillingAddressForUser_args:
16986 
  """
16987 
  Attributes:
16988 
   - userId
16989 
  """
16990 
 
16991 
  thrift_spec = (
16992 
    None, # 0
16993 
    (1, TType.I64, 'userId', None, None, ), # 1
16994 
  )
16995 
 
16996 
  def __init__(self, userId=None,):
16997 
    self.userId = userId
16998 
 
16999 
  def read(self, iprot):
17000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17002 
      return
17003 
    iprot.readStructBegin()
17004 
    while True:
17005 
      (fname, ftype, fid) = iprot.readFieldBegin()
17006 
      if ftype == TType.STOP:
17007 
        break
17008 
      if fid == 1:
17009 
        if ftype == TType.I64:
17010 
          self.userId = iprot.readI64();
17011 
        else:
17012 
          iprot.skip(ftype)
17013 
      else:
17014 
        iprot.skip(ftype)
17015 
      iprot.readFieldEnd()
17016 
    iprot.readStructEnd()
17017 
 
17018 
  def write(self, oprot):
17019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17021 
      return
17022 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17023 
    if self.userId is not None:
17024 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17025 
      oprot.writeI64(self.userId)
17026 
      oprot.writeFieldEnd()
17027 
    oprot.writeFieldStop()
17028 
    oprot.writeStructEnd()
17029 
 
17030 
  def validate(self):
17031 
    return
17032 
 
17033 
 
17034 
  def __repr__(self):
17035 
    L = ['%s=%r' % (key, value)
17036 
      for key, value in self.__dict__.iteritems()]
17037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17038 
 
17039 
  def __eq__(self, other):
17040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17041 
 
17042 
  def __ne__(self, other):
17043 
    return not (self == other)
17044 
 
17045 
class getBillingAddressForUser_result:
17046 
  """
17047 
  Attributes:
17048 
   - success
17049 
  """
17050 
 
17051 
  thrift_spec = (
17052 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17053 
  )
17054 
 
17055 
  def __init__(self, success=None,):
17056 
    self.success = success
17057 
 
17058 
  def read(self, iprot):
17059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17061 
      return
17062 
    iprot.readStructBegin()
17063 
    while True:
17064 
      (fname, ftype, fid) = iprot.readFieldBegin()
17065 
      if ftype == TType.STOP:
17066 
        break
17067 
      if fid == 0:
17068 
        if ftype == TType.STRUCT:
17069 
          self.success = Address()
17070 
          self.success.read(iprot)
17071 
        else:
17072 
          iprot.skip(ftype)
17073 
      else:
17074 
        iprot.skip(ftype)
17075 
      iprot.readFieldEnd()
17076 
    iprot.readStructEnd()
17077 
 
17078 
  def write(self, oprot):
17079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17081 
      return
17082 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17083 
    if self.success is not None:
17084 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17085 
      self.success.write(oprot)
17086 
      oprot.writeFieldEnd()
17087 
    oprot.writeFieldStop()
17088 
    oprot.writeStructEnd()
17089 
 
17090 
  def validate(self):
17091 
    return
17092 
 
17093 
 
17094 
  def __repr__(self):
17095 
    L = ['%s=%r' % (key, value)
17096 
      for key, value in self.__dict__.iteritems()]
17097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17098 
 
17099 
  def __eq__(self, other):
17100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17101 
 
17102 
  def __ne__(self, other):
17103 
    return not (self == other)
18590 manish.sha 17104 
 
17105 
class isCreditorAssigned_args:
17106 
  """
17107 
  Attributes:
17108 
   - userId
17109 
  """
17110 
 
17111 
  thrift_spec = (
17112 
    None, # 0
17113 
    (1, TType.I64, 'userId', None, None, ), # 1
17114 
  )
17115 
 
17116 
  def __init__(self, userId=None,):
17117 
    self.userId = userId
17118 
 
17119 
  def read(self, iprot):
17120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17122 
      return
17123 
    iprot.readStructBegin()
17124 
    while True:
17125 
      (fname, ftype, fid) = iprot.readFieldBegin()
17126 
      if ftype == TType.STOP:
17127 
        break
17128 
      if fid == 1:
17129 
        if ftype == TType.I64:
17130 
          self.userId = iprot.readI64();
17131 
        else:
17132 
          iprot.skip(ftype)
17133 
      else:
17134 
        iprot.skip(ftype)
17135 
      iprot.readFieldEnd()
17136 
    iprot.readStructEnd()
17137 
 
17138 
  def write(self, oprot):
17139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17141 
      return
17142 
    oprot.writeStructBegin('isCreditorAssigned_args')
17143 
    if self.userId is not None:
17144 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17145 
      oprot.writeI64(self.userId)
17146 
      oprot.writeFieldEnd()
17147 
    oprot.writeFieldStop()
17148 
    oprot.writeStructEnd()
17149 
 
17150 
  def validate(self):
17151 
    return
17152 
 
17153 
 
17154 
  def __repr__(self):
17155 
    L = ['%s=%r' % (key, value)
17156 
      for key, value in self.__dict__.iteritems()]
17157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17158 
 
17159 
  def __eq__(self, other):
17160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17161 
 
17162 
  def __ne__(self, other):
17163 
    return not (self == other)
17164 
 
17165 
class isCreditorAssigned_result:
17166 
  """
17167 
  Attributes:
17168 
   - success
17169 
  """
17170 
 
17171 
  thrift_spec = (
17172 
    (0, TType.BOOL, 'success', None, None, ), # 0
17173 
  )
17174 
 
17175 
  def __init__(self, success=None,):
17176 
    self.success = success
17177 
 
17178 
  def read(self, iprot):
17179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17181 
      return
17182 
    iprot.readStructBegin()
17183 
    while True:
17184 
      (fname, ftype, fid) = iprot.readFieldBegin()
17185 
      if ftype == TType.STOP:
17186 
        break
17187 
      if fid == 0:
17188 
        if ftype == TType.BOOL:
17189 
          self.success = iprot.readBool();
17190 
        else:
17191 
          iprot.skip(ftype)
17192 
      else:
17193 
        iprot.skip(ftype)
17194 
      iprot.readFieldEnd()
17195 
    iprot.readStructEnd()
17196 
 
17197 
  def write(self, oprot):
17198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17200 
      return
17201 
    oprot.writeStructBegin('isCreditorAssigned_result')
17202 
    if self.success is not None:
17203 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17204 
      oprot.writeBool(self.success)
17205 
      oprot.writeFieldEnd()
17206 
    oprot.writeFieldStop()
17207 
    oprot.writeStructEnd()
17208 
 
17209 
  def validate(self):
17210 
    return
17211 
 
17212 
 
17213 
  def __repr__(self):
17214 
    L = ['%s=%r' % (key, value)
17215 
      for key, value in self.__dict__.iteritems()]
17216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17217 
 
17218 
  def __eq__(self, other):
17219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17220 
 
17221 
  def __ne__(self, other):
17222 
    return not (self == other)
18735 manish.sha 17223 
 
17224 
class isTaxInvoiceEnabledUser_args:
17225 
  """
17226 
  Attributes:
17227 
   - userId
17228 
  """
17229 
 
17230 
  thrift_spec = (
17231 
    None, # 0
17232 
    (1, TType.I64, 'userId', None, None, ), # 1
17233 
  )
17234 
 
17235 
  def __init__(self, userId=None,):
17236 
    self.userId = userId
17237 
 
17238 
  def read(self, iprot):
17239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17241 
      return
17242 
    iprot.readStructBegin()
17243 
    while True:
17244 
      (fname, ftype, fid) = iprot.readFieldBegin()
17245 
      if ftype == TType.STOP:
17246 
        break
17247 
      if fid == 1:
17248 
        if ftype == TType.I64:
17249 
          self.userId = iprot.readI64();
17250 
        else:
17251 
          iprot.skip(ftype)
17252 
      else:
17253 
        iprot.skip(ftype)
17254 
      iprot.readFieldEnd()
17255 
    iprot.readStructEnd()
17256 
 
17257 
  def write(self, oprot):
17258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17260 
      return
17261 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17262 
    if self.userId is not None:
17263 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17264 
      oprot.writeI64(self.userId)
17265 
      oprot.writeFieldEnd()
17266 
    oprot.writeFieldStop()
17267 
    oprot.writeStructEnd()
17268 
 
17269 
  def validate(self):
17270 
    return
17271 
 
17272 
 
17273 
  def __repr__(self):
17274 
    L = ['%s=%r' % (key, value)
17275 
      for key, value in self.__dict__.iteritems()]
17276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17277 
 
17278 
  def __eq__(self, other):
17279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17280 
 
17281 
  def __ne__(self, other):
17282 
    return not (self == other)
17283 
 
17284 
class isTaxInvoiceEnabledUser_result:
17285 
  """
17286 
  Attributes:
17287 
   - success
17288 
  """
17289 
 
17290 
  thrift_spec = (
17291 
    (0, TType.BOOL, 'success', None, None, ), # 0
17292 
  )
17293 
 
17294 
  def __init__(self, success=None,):
17295 
    self.success = success
17296 
 
17297 
  def read(self, iprot):
17298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17300 
      return
17301 
    iprot.readStructBegin()
17302 
    while True:
17303 
      (fname, ftype, fid) = iprot.readFieldBegin()
17304 
      if ftype == TType.STOP:
17305 
        break
17306 
      if fid == 0:
17307 
        if ftype == TType.BOOL:
17308 
          self.success = iprot.readBool();
17309 
        else:
17310 
          iprot.skip(ftype)
17311 
      else:
17312 
        iprot.skip(ftype)
17313 
      iprot.readFieldEnd()
17314 
    iprot.readStructEnd()
17315 
 
17316 
  def write(self, oprot):
17317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17319 
      return
17320 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17321 
    if self.success is not None:
17322 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17323 
      oprot.writeBool(self.success)
17324 
      oprot.writeFieldEnd()
17325 
    oprot.writeFieldStop()
17326 
    oprot.writeStructEnd()
17327 
 
17328 
  def validate(self):
17329 
    return
17330 
 
17331 
 
17332 
  def __repr__(self):
17333 
    L = ['%s=%r' % (key, value)
17334 
      for key, value in self.__dict__.iteritems()]
17335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17336 
 
17337 
  def __eq__(self, other):
17338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17339 
 
17340 
  def __ne__(self, other):
17341 
    return not (self == other)
18764 kshitij.so 17342 
 
17343 
class getCartByValue_args:
17344 
  """
17345 
  Attributes:
17346 
   - cartIds
17347 
  """
17348 
 
17349 
  thrift_spec = (
17350 
    None, # 0
17351 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17352 
  )
17353 
 
17354 
  def __init__(self, cartIds=None,):
17355 
    self.cartIds = cartIds
17356 
 
17357 
  def read(self, iprot):
17358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17360 
      return
17361 
    iprot.readStructBegin()
17362 
    while True:
17363 
      (fname, ftype, fid) = iprot.readFieldBegin()
17364 
      if ftype == TType.STOP:
17365 
        break
17366 
      if fid == 1:
17367 
        if ftype == TType.LIST:
17368 
          self.cartIds = []
17369 
          (_etype258, _size255) = iprot.readListBegin()
17370 
          for _i259 in xrange(_size255):
17371 
            _elem260 = iprot.readI64();
17372 
            self.cartIds.append(_elem260)
17373 
          iprot.readListEnd()
17374 
        else:
17375 
          iprot.skip(ftype)
17376 
      else:
17377 
        iprot.skip(ftype)
17378 
      iprot.readFieldEnd()
17379 
    iprot.readStructEnd()
17380 
 
17381 
  def write(self, oprot):
17382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17384 
      return
17385 
    oprot.writeStructBegin('getCartByValue_args')
17386 
    if self.cartIds is not None:
17387 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
17388 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
17389 
      for iter261 in self.cartIds:
17390 
        oprot.writeI64(iter261)
17391 
      oprot.writeListEnd()
17392 
      oprot.writeFieldEnd()
17393 
    oprot.writeFieldStop()
17394 
    oprot.writeStructEnd()
17395 
 
17396 
  def validate(self):
17397 
    return
17398 
 
17399 
 
17400 
  def __repr__(self):
17401 
    L = ['%s=%r' % (key, value)
17402 
      for key, value in self.__dict__.iteritems()]
17403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17404 
 
17405 
  def __eq__(self, other):
17406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17407 
 
17408 
  def __ne__(self, other):
17409 
    return not (self == other)
17410 
 
17411 
class getCartByValue_result:
17412 
  """
17413 
  Attributes:
17414 
   - success
17415 
  """
17416 
 
17417 
  thrift_spec = (
17418 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
17419 
  )
17420 
 
17421 
  def __init__(self, success=None,):
17422 
    self.success = success
17423 
 
17424 
  def read(self, iprot):
17425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17427 
      return
17428 
    iprot.readStructBegin()
17429 
    while True:
17430 
      (fname, ftype, fid) = iprot.readFieldBegin()
17431 
      if ftype == TType.STOP:
17432 
        break
17433 
      if fid == 0:
17434 
        if ftype == TType.MAP:
17435 
          self.success = {}
17436 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
17437 
          for _i266 in xrange(_size262):
17438 
            _key267 = iprot.readI64();
17439 
            _val268 = []
17440 
            (_etype272, _size269) = iprot.readListBegin()
17441 
            for _i273 in xrange(_size269):
17442 
              _elem274 = Line()
17443 
              _elem274.read(iprot)
17444 
              _val268.append(_elem274)
17445 
            iprot.readListEnd()
17446 
            self.success[_key267] = _val268
17447 
          iprot.readMapEnd()
17448 
        else:
17449 
          iprot.skip(ftype)
17450 
      else:
17451 
        iprot.skip(ftype)
17452 
      iprot.readFieldEnd()
17453 
    iprot.readStructEnd()
17454 
 
17455 
  def write(self, oprot):
17456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17458 
      return
17459 
    oprot.writeStructBegin('getCartByValue_result')
17460 
    if self.success is not None:
17461 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17462 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
17463 
      for kiter275,viter276 in self.success.items():
17464 
        oprot.writeI64(kiter275)
17465 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
17466 
        for iter277 in viter276:
17467 
          iter277.write(oprot)
17468 
        oprot.writeListEnd()
17469 
      oprot.writeMapEnd()
17470 
      oprot.writeFieldEnd()
17471 
    oprot.writeFieldStop()
17472 
    oprot.writeStructEnd()
17473 
 
17474 
  def validate(self):
17475 
    return
17476 
 
17477 
 
17478 
  def __repr__(self):
17479 
    L = ['%s=%r' % (key, value)
17480 
      for key, value in self.__dict__.iteritems()]
17481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17482 
 
17483 
  def __eq__(self, other):
17484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17485 
 
17486 
  def __ne__(self, other):
17487 
    return not (self == other)