Subversion Repositories SmartDukaan

Rev

Rev 11890 | Rev 12696 | 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 
 
697 
 
3376 rajveer 698 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 699 
  """
700 
  service
701 
  """
702 
  def __init__(self, iprot, oprot=None):
3376 rajveer 703 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 704 
 
559 chandransh 705 
  def createAnonymousUser(self, jsessionId):
94 ashish 706 
    """
707 
    Parameters:
559 chandransh 708 
     - jsessionId
94 ashish 709 
    """
559 chandransh 710 
    self.send_createAnonymousUser(jsessionId)
711 
    return self.recv_createAnonymousUser()
94 ashish 712 
 
559 chandransh 713 
  def send_createAnonymousUser(self, jsessionId):
714 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
715 
    args = createAnonymousUser_args()
716 
    args.jsessionId = jsessionId
94 ashish 717 
    args.write(self._oprot)
718 
    self._oprot.writeMessageEnd()
719 
    self._oprot.trans.flush()
720 
 
559 chandransh 721 
  def recv_createAnonymousUser(self, ):
94 ashish 722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
723 
    if mtype == TMessageType.EXCEPTION:
724 
      x = TApplicationException()
725 
      x.read(self._iprot)
726 
      self._iprot.readMessageEnd()
727 
      raise x
559 chandransh 728 
    result = createAnonymousUser_result()
94 ashish 729 
    result.read(self._iprot)
730 
    self._iprot.readMessageEnd()
3431 rajveer 731 
    if result.success is not None:
94 ashish 732 
      return result.success
3431 rajveer 733 
    if result.ucex is not None:
559 chandransh 734 
      raise result.ucex
735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 736 
 
559 chandransh 737 
  def getUserById(self, userId):
94 ashish 738 
    """
739 
    Parameters:
740 
     - userId
741 
    """
559 chandransh 742 
    self.send_getUserById(userId)
743 
    return self.recv_getUserById()
94 ashish 744 
 
559 chandransh 745 
  def send_getUserById(self, userId):
746 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
747 
    args = getUserById_args()
94 ashish 748 
    args.userId = userId
749 
    args.write(self._oprot)
750 
    self._oprot.writeMessageEnd()
751 
    self._oprot.trans.flush()
752 
 
559 chandransh 753 
  def recv_getUserById(self, ):
94 ashish 754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
755 
    if mtype == TMessageType.EXCEPTION:
756 
      x = TApplicationException()
757 
      x.read(self._iprot)
758 
      self._iprot.readMessageEnd()
759 
      raise x
559 chandransh 760 
    result = getUserById_result()
94 ashish 761 
    result.read(self._iprot)
762 
    self._iprot.readMessageEnd()
3431 rajveer 763 
    if result.success is not None:
94 ashish 764 
      return result.success
3431 rajveer 765 
    if result.ucex is not None:
559 chandransh 766 
      raise result.ucex
767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 768 
 
5326 rajveer 769 
  def getUserByCartId(self, cartId):
770 
    """
771 
    Parameters:
772 
     - cartId
773 
    """
774 
    self.send_getUserByCartId(cartId)
775 
    return self.recv_getUserByCartId()
776 
 
777 
  def send_getUserByCartId(self, cartId):
778 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
779 
    args = getUserByCartId_args()
780 
    args.cartId = cartId
781 
    args.write(self._oprot)
782 
    self._oprot.writeMessageEnd()
783 
    self._oprot.trans.flush()
784 
 
785 
  def recv_getUserByCartId(self, ):
786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
787 
    if mtype == TMessageType.EXCEPTION:
788 
      x = TApplicationException()
789 
      x.read(self._iprot)
790 
      self._iprot.readMessageEnd()
791 
      raise x
792 
    result = getUserByCartId_result()
793 
    result.read(self._iprot)
794 
    self._iprot.readMessageEnd()
795 
    if result.success is not None:
796 
      return result.success
797 
    if result.ucex is not None:
798 
      raise result.ucex
799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
800 
 
1491 vikas 801 
  def getUserByEmail(self, email):
802 
    """
803 
    Parameters:
804 
     - email
805 
    """
806 
    self.send_getUserByEmail(email)
807 
    return self.recv_getUserByEmail()
808 
 
809 
  def send_getUserByEmail(self, email):
810 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
811 
    args = getUserByEmail_args()
812 
    args.email = email
813 
    args.write(self._oprot)
814 
    self._oprot.writeMessageEnd()
815 
    self._oprot.trans.flush()
816 
 
817 
  def recv_getUserByEmail(self, ):
818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
819 
    if mtype == TMessageType.EXCEPTION:
820 
      x = TApplicationException()
821 
      x.read(self._iprot)
822 
      self._iprot.readMessageEnd()
823 
      raise x
824 
    result = getUserByEmail_result()
825 
    result.read(self._iprot)
826 
    self._iprot.readMessageEnd()
3431 rajveer 827 
    if result.success is not None:
1491 vikas 828 
      return result.success
3431 rajveer 829 
    if result.ucex is not None:
1491 vikas 830 
      raise result.ucex
831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
832 
 
3032 mandeep.dh 833 
  def getUserByMobileNumber(self, mobileNumber):
834 
    """
835 
    Parameters:
836 
     - mobileNumber
837 
    """
838 
    self.send_getUserByMobileNumber(mobileNumber)
839 
    return self.recv_getUserByMobileNumber()
840 
 
841 
  def send_getUserByMobileNumber(self, mobileNumber):
842 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
843 
    args = getUserByMobileNumber_args()
844 
    args.mobileNumber = mobileNumber
845 
    args.write(self._oprot)
846 
    self._oprot.writeMessageEnd()
847 
    self._oprot.trans.flush()
848 
 
849 
  def recv_getUserByMobileNumber(self, ):
850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
851 
    if mtype == TMessageType.EXCEPTION:
852 
      x = TApplicationException()
853 
      x.read(self._iprot)
854 
      self._iprot.readMessageEnd()
855 
      raise x
856 
    result = getUserByMobileNumber_result()
857 
    result.read(self._iprot)
858 
    self._iprot.readMessageEnd()
3431 rajveer 859 
    if result.success is not None:
3032 mandeep.dh 860 
      return result.success
3431 rajveer 861 
    if result.ucex is not None:
3032 mandeep.dh 862 
      raise result.ucex
863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
864 
 
559 chandransh 865 
  def createUser(self, user):
94 ashish 866 
    """
867 
    Parameters:
559 chandransh 868 
     - user
94 ashish 869 
    """
559 chandransh 870 
    self.send_createUser(user)
871 
    return self.recv_createUser()
94 ashish 872 
 
559 chandransh 873 
  def send_createUser(self, user):
874 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
875 
    args = createUser_args()
876 
    args.user = user
94 ashish 877 
    args.write(self._oprot)
878 
    self._oprot.writeMessageEnd()
879 
    self._oprot.trans.flush()
880 
 
559 chandransh 881 
  def recv_createUser(self, ):
94 ashish 882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
883 
    if mtype == TMessageType.EXCEPTION:
884 
      x = TApplicationException()
885 
      x.read(self._iprot)
886 
      self._iprot.readMessageEnd()
887 
      raise x
559 chandransh 888 
    result = createUser_result()
94 ashish 889 
    result.read(self._iprot)
890 
    self._iprot.readMessageEnd()
3431 rajveer 891 
    if result.success is not None:
94 ashish 892 
      return result.success
3431 rajveer 893 
    if result.ucex is not None:
559 chandransh 894 
      raise result.ucex
895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 896 
 
559 chandransh 897 
  def updateUser(self, user):
94 ashish 898 
    """
899 
    Parameters:
559 chandransh 900 
     - user
94 ashish 901 
    """
559 chandransh 902 
    self.send_updateUser(user)
903 
    return self.recv_updateUser()
94 ashish 904 
 
559 chandransh 905 
  def send_updateUser(self, user):
906 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
907 
    args = updateUser_args()
908 
    args.user = user
94 ashish 909 
    args.write(self._oprot)
910 
    self._oprot.writeMessageEnd()
911 
    self._oprot.trans.flush()
912 
 
559 chandransh 913 
  def recv_updateUser(self, ):
94 ashish 914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
915 
    if mtype == TMessageType.EXCEPTION:
916 
      x = TApplicationException()
917 
      x.read(self._iprot)
918 
      self._iprot.readMessageEnd()
919 
      raise x
559 chandransh 920 
    result = updateUser_result()
94 ashish 921 
    result.read(self._iprot)
922 
    self._iprot.readMessageEnd()
3431 rajveer 923 
    if result.success is not None:
94 ashish 924 
      return result.success
3431 rajveer 925 
    if result.ucex is not None:
559 chandransh 926 
      raise result.ucex
927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 928 
 
559 chandransh 929 
  def authenticateUser(self, email, password):
94 ashish 930 
    """
931 
    Parameters:
932 
     - email
933 
     - password
934 
    """
559 chandransh 935 
    self.send_authenticateUser(email, password)
122 ashish 936 
    return self.recv_authenticateUser()
937 
 
559 chandransh 938 
  def send_authenticateUser(self, email, password):
122 ashish 939 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
940 
    args = authenticateUser_args()
559 chandransh 941 
    args.email = email
122 ashish 942 
    args.password = password
943 
    args.write(self._oprot)
944 
    self._oprot.writeMessageEnd()
945 
    self._oprot.trans.flush()
946 
 
947 
  def recv_authenticateUser(self, ):
948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
949 
    if mtype == TMessageType.EXCEPTION:
950 
      x = TApplicationException()
951 
      x.read(self._iprot)
952 
      self._iprot.readMessageEnd()
953 
      raise x
954 
    result = authenticateUser_result()
955 
    result.read(self._iprot)
956 
    self._iprot.readMessageEnd()
3431 rajveer 957 
    if result.success is not None:
122 ashish 958 
      return result.success
3431 rajveer 959 
    if result.auex is not None:
559 chandransh 960 
      raise result.auex
122 ashish 961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
962 
 
94 ashish 963 
  def userExists(self, email):
964 
    """
965 
    Parameters:
966 
     - email
967 
    """
968 
    self.send_userExists(email)
969 
    return self.recv_userExists()
970 
 
971 
  def send_userExists(self, email):
972 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
973 
    args = userExists_args()
974 
    args.email = email
975 
    args.write(self._oprot)
976 
    self._oprot.writeMessageEnd()
977 
    self._oprot.trans.flush()
978 
 
979 
  def recv_userExists(self, ):
980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
981 
    if mtype == TMessageType.EXCEPTION:
982 
      x = TApplicationException()
983 
      x.read(self._iprot)
984 
      self._iprot.readMessageEnd()
985 
      raise x
986 
    result = userExists_result()
987 
    result.read(self._iprot)
988 
    self._iprot.readMessageEnd()
3431 rajveer 989 
    if result.success is not None:
94 ashish 990 
      return result.success
3431 rajveer 991 
    if result.ucx is not None:
94 ashish 992 
      raise result.ucx
993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
994 
 
567 rajveer 995 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 996 
    """
997 
    Parameters:
998 
     - userId
999 
     - address
513 rajveer 1000 
     - setDefault
94 ashish 1001 
    """
567 rajveer 1002 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1003 
    return self.recv_addAddressForUser()
1004 
 
567 rajveer 1005 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1006 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1007 
    args = addAddressForUser_args()
559 chandransh 1008 
    args.userId = userId
94 ashish 1009 
    args.address = address
513 rajveer 1010 
    args.setDefault = setDefault
94 ashish 1011 
    args.write(self._oprot)
1012 
    self._oprot.writeMessageEnd()
1013 
    self._oprot.trans.flush()
1014 
 
1015 
  def recv_addAddressForUser(self, ):
1016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1017 
    if mtype == TMessageType.EXCEPTION:
1018 
      x = TApplicationException()
1019 
      x.read(self._iprot)
1020 
      self._iprot.readMessageEnd()
1021 
      raise x
1022 
    result = addAddressForUser_result()
1023 
    result.read(self._iprot)
1024 
    self._iprot.readMessageEnd()
3431 rajveer 1025 
    if result.success is not None:
94 ashish 1026 
      return result.success
3431 rajveer 1027 
    if result.ucx is not None:
94 ashish 1028 
      raise result.ucx
1029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1030 
 
1031 
  def removeAddressForUser(self, userid, addressId):
1032 
    """
1033 
    Parameters:
1034 
     - userid
1035 
     - addressId
1036 
    """
1037 
    self.send_removeAddressForUser(userid, addressId)
1038 
    return self.recv_removeAddressForUser()
1039 
 
1040 
  def send_removeAddressForUser(self, userid, addressId):
1041 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1042 
    args = removeAddressForUser_args()
1043 
    args.userid = userid
1044 
    args.addressId = addressId
1045 
    args.write(self._oprot)
1046 
    self._oprot.writeMessageEnd()
1047 
    self._oprot.trans.flush()
1048 
 
1049 
  def recv_removeAddressForUser(self, ):
1050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1051 
    if mtype == TMessageType.EXCEPTION:
1052 
      x = TApplicationException()
1053 
      x.read(self._iprot)
1054 
      self._iprot.readMessageEnd()
1055 
      raise x
1056 
    result = removeAddressForUser_result()
1057 
    result.read(self._iprot)
1058 
    self._iprot.readMessageEnd()
3431 rajveer 1059 
    if result.success is not None:
94 ashish 1060 
      return result.success
3431 rajveer 1061 
    if result.ucx is not None:
94 ashish 1062 
      raise result.ucx
1063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1064 
 
1065 
  def setUserAsLoggedIn(self, userId, timestamp):
1066 
    """
1067 
    Parameters:
1068 
     - userId
1069 
     - timestamp
1070 
    """
1071 
    self.send_setUserAsLoggedIn(userId, timestamp)
1072 
    return self.recv_setUserAsLoggedIn()
1073 
 
1074 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1075 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1076 
    args = setUserAsLoggedIn_args()
1077 
    args.userId = userId
1078 
    args.timestamp = timestamp
1079 
    args.write(self._oprot)
1080 
    self._oprot.writeMessageEnd()
1081 
    self._oprot.trans.flush()
1082 
 
1083 
  def recv_setUserAsLoggedIn(self, ):
1084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1085 
    if mtype == TMessageType.EXCEPTION:
1086 
      x = TApplicationException()
1087 
      x.read(self._iprot)
1088 
      self._iprot.readMessageEnd()
1089 
      raise x
1090 
    result = setUserAsLoggedIn_result()
1091 
    result.read(self._iprot)
1092 
    self._iprot.readMessageEnd()
3431 rajveer 1093 
    if result.success is not None:
94 ashish 1094 
      return result.success
3431 rajveer 1095 
    if result.ucx is not None:
94 ashish 1096 
      raise result.ucx
1097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1098 
 
1099 
  def setUserAsLoggedOut(self, userid, timestamp):
1100 
    """
1101 
    Parameters:
1102 
     - userid
1103 
     - timestamp
1104 
    """
1105 
    self.send_setUserAsLoggedOut(userid, timestamp)
1106 
    return self.recv_setUserAsLoggedOut()
1107 
 
1108 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1109 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1110 
    args = setUserAsLoggedOut_args()
1111 
    args.userid = userid
1112 
    args.timestamp = timestamp
1113 
    args.write(self._oprot)
1114 
    self._oprot.writeMessageEnd()
1115 
    self._oprot.trans.flush()
1116 
 
1117 
  def recv_setUserAsLoggedOut(self, ):
1118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1119 
    if mtype == TMessageType.EXCEPTION:
1120 
      x = TApplicationException()
1121 
      x.read(self._iprot)
1122 
      self._iprot.readMessageEnd()
1123 
      raise x
1124 
    result = setUserAsLoggedOut_result()
1125 
    result.read(self._iprot)
1126 
    self._iprot.readMessageEnd()
3431 rajveer 1127 
    if result.success is not None:
94 ashish 1128 
      return result.success
3431 rajveer 1129 
    if result.ucx is not None:
94 ashish 1130 
      raise result.ucx
1131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1132 
 
504 rajveer 1133 
  def setDefaultAddress(self, userid, addressId):
1134 
    """
1135 
    Parameters:
1136 
     - userid
1137 
     - addressId
1138 
    """
1139 
    self.send_setDefaultAddress(userid, addressId)
1140 
    return self.recv_setDefaultAddress()
1141 
 
1142 
  def send_setDefaultAddress(self, userid, addressId):
1143 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1144 
    args = setDefaultAddress_args()
1145 
    args.userid = userid
1146 
    args.addressId = addressId
1147 
    args.write(self._oprot)
1148 
    self._oprot.writeMessageEnd()
1149 
    self._oprot.trans.flush()
1150 
 
1151 
  def recv_setDefaultAddress(self, ):
1152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1153 
    if mtype == TMessageType.EXCEPTION:
1154 
      x = TApplicationException()
1155 
      x.read(self._iprot)
1156 
      self._iprot.readMessageEnd()
1157 
      raise x
1158 
    result = setDefaultAddress_result()
1159 
    result.read(self._iprot)
1160 
    self._iprot.readMessageEnd()
3431 rajveer 1161 
    if result.success is not None:
504 rajveer 1162 
      return result.success
3431 rajveer 1163 
    if result.ucx is not None:
504 rajveer 1164 
      raise result.ucx
1165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1166 
 
594 rajveer 1167 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1168 
    """
1169 
    Parameters:
1170 
     - userid
594 rajveer 1171 
     - oldPassword
1172 
     - newPassword
94 ashish 1173 
    """
594 rajveer 1174 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1175 
    return self.recv_updatePassword()
1176 
 
594 rajveer 1177 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1178 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1179 
    args = updatePassword_args()
1180 
    args.userid = userid
594 rajveer 1181 
    args.oldPassword = oldPassword
1182 
    args.newPassword = newPassword
94 ashish 1183 
    args.write(self._oprot)
1184 
    self._oprot.writeMessageEnd()
1185 
    self._oprot.trans.flush()
1186 
 
1187 
  def recv_updatePassword(self, ):
1188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1189 
    if mtype == TMessageType.EXCEPTION:
1190 
      x = TApplicationException()
1191 
      x.read(self._iprot)
1192 
      self._iprot.readMessageEnd()
1193 
      raise x
1194 
    result = updatePassword_result()
1195 
    result.read(self._iprot)
1196 
    self._iprot.readMessageEnd()
3431 rajveer 1197 
    if result.success is not None:
94 ashish 1198 
      return result.success
3431 rajveer 1199 
    if result.ucx is not None:
94 ashish 1200 
      raise result.ucx
1201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1202 
 
884 rajveer 1203 
  def forgotPassword(self, email, newPassword):
581 rajveer 1204 
    """
1205 
    Parameters:
1206 
     - email
884 rajveer 1207 
     - newPassword
581 rajveer 1208 
    """
884 rajveer 1209 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1210 
    return self.recv_forgotPassword()
1211 
 
884 rajveer 1212 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1213 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1214 
    args = forgotPassword_args()
1215 
    args.email = email
884 rajveer 1216 
    args.newPassword = newPassword
581 rajveer 1217 
    args.write(self._oprot)
1218 
    self._oprot.writeMessageEnd()
1219 
    self._oprot.trans.flush()
1220 
 
1221 
  def recv_forgotPassword(self, ):
1222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1223 
    if mtype == TMessageType.EXCEPTION:
1224 
      x = TApplicationException()
1225 
      x.read(self._iprot)
1226 
      self._iprot.readMessageEnd()
1227 
      raise x
1228 
    result = forgotPassword_result()
1229 
    result.read(self._iprot)
1230 
    self._iprot.readMessageEnd()
3431 rajveer 1231 
    if result.success is not None:
581 rajveer 1232 
      return result.success
3431 rajveer 1233 
    if result.ucx is not None:
581 rajveer 1234 
      raise result.ucx
1235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1236 
 
594 rajveer 1237 
  def getAllAddressesForUser(self, userId):
1238 
    """
1239 
    Parameters:
1240 
     - userId
1241 
    """
1242 
    self.send_getAllAddressesForUser(userId)
1243 
    return self.recv_getAllAddressesForUser()
1244 
 
1245 
  def send_getAllAddressesForUser(self, userId):
1246 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1247 
    args = getAllAddressesForUser_args()
1248 
    args.userId = userId
1249 
    args.write(self._oprot)
1250 
    self._oprot.writeMessageEnd()
1251 
    self._oprot.trans.flush()
1252 
 
1253 
  def recv_getAllAddressesForUser(self, ):
1254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1255 
    if mtype == TMessageType.EXCEPTION:
1256 
      x = TApplicationException()
1257 
      x.read(self._iprot)
1258 
      self._iprot.readMessageEnd()
1259 
      raise x
1260 
    result = getAllAddressesForUser_result()
1261 
    result.read(self._iprot)
1262 
    self._iprot.readMessageEnd()
3431 rajveer 1263 
    if result.success is not None:
594 rajveer 1264 
      return result.success
3431 rajveer 1265 
    if result.ucx is not None:
594 rajveer 1266 
      raise result.ucx
1267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1268 
 
1894 vikas 1269 
  def getAddressById(self, addressId):
1270 
    """
1271 
    Parameters:
1272 
     - addressId
1273 
    """
1274 
    self.send_getAddressById(addressId)
1275 
    return self.recv_getAddressById()
1276 
 
1277 
  def send_getAddressById(self, addressId):
1278 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1279 
    args = getAddressById_args()
1280 
    args.addressId = addressId
1281 
    args.write(self._oprot)
1282 
    self._oprot.writeMessageEnd()
1283 
    self._oprot.trans.flush()
1284 
 
1285 
  def recv_getAddressById(self, ):
1286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1287 
    if mtype == TMessageType.EXCEPTION:
1288 
      x = TApplicationException()
1289 
      x.read(self._iprot)
1290 
      self._iprot.readMessageEnd()
1291 
      raise x
1292 
    result = getAddressById_result()
1293 
    result.read(self._iprot)
1294 
    self._iprot.readMessageEnd()
3431 rajveer 1295 
    if result.success is not None:
1894 vikas 1296 
      return result.success
3431 rajveer 1297 
    if result.ucx is not None:
1894 vikas 1298 
      raise result.ucx
1299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1300 
 
594 rajveer 1301 
  def getDefaultAddressId(self, userId):
1302 
    """
1303 
    Parameters:
1304 
     - userId
1305 
    """
1306 
    self.send_getDefaultAddressId(userId)
1307 
    return self.recv_getDefaultAddressId()
1308 
 
1309 
  def send_getDefaultAddressId(self, userId):
1310 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1311 
    args = getDefaultAddressId_args()
1312 
    args.userId = userId
1313 
    args.write(self._oprot)
1314 
    self._oprot.writeMessageEnd()
1315 
    self._oprot.trans.flush()
1316 
 
1317 
  def recv_getDefaultAddressId(self, ):
1318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1319 
    if mtype == TMessageType.EXCEPTION:
1320 
      x = TApplicationException()
1321 
      x.read(self._iprot)
1322 
      self._iprot.readMessageEnd()
1323 
      raise x
1324 
    result = getDefaultAddressId_result()
1325 
    result.read(self._iprot)
1326 
    self._iprot.readMessageEnd()
3431 rajveer 1327 
    if result.success is not None:
594 rajveer 1328 
      return result.success
3431 rajveer 1329 
    if result.ucx is not None:
594 rajveer 1330 
      raise result.ucx
1331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1332 
 
785 rajveer 1333 
  def getDefaultPincode(self, userId):
1334 
    """
1335 
    Parameters:
1336 
     - userId
1337 
    """
1338 
    self.send_getDefaultPincode(userId)
1339 
    return self.recv_getDefaultPincode()
1340 
 
1341 
  def send_getDefaultPincode(self, userId):
1342 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1343 
    args = getDefaultPincode_args()
1344 
    args.userId = userId
1345 
    args.write(self._oprot)
1346 
    self._oprot.writeMessageEnd()
1347 
    self._oprot.trans.flush()
1348 
 
1349 
  def recv_getDefaultPincode(self, ):
1350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1351 
    if mtype == TMessageType.EXCEPTION:
1352 
      x = TApplicationException()
1353 
      x.read(self._iprot)
1354 
      self._iprot.readMessageEnd()
1355 
      raise x
1356 
    result = getDefaultPincode_result()
1357 
    result.read(self._iprot)
1358 
    self._iprot.readMessageEnd()
3431 rajveer 1359 
    if result.success is not None:
785 rajveer 1360 
      return result.success
3431 rajveer 1361 
    if result.ucx is not None:
785 rajveer 1362 
      raise result.ucx
1363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1364 
 
1274 varun.gupt 1365 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1366 
    """
1367 
    Parameters:
1368 
     - userId
1369 
     - replyTo
1370 
     - communicationType
1371 
     - orderId
1372 
     - airwaybillNo
1373 
     - productName
1374 
     - subject
1375 
     - message
1376 
    """
1377 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1378 
    return self.recv_saveUserCommunication()
1379 
 
1380 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1381 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1382 
    args = saveUserCommunication_args()
1383 
    args.userId = userId
1384 
    args.replyTo = replyTo
1385 
    args.communicationType = communicationType
1386 
    args.orderId = orderId
1387 
    args.airwaybillNo = airwaybillNo
1388 
    args.productName = productName
1389 
    args.subject = subject
1390 
    args.message = message
1391 
    args.write(self._oprot)
1392 
    self._oprot.writeMessageEnd()
1393 
    self._oprot.trans.flush()
1394 
 
1395 
  def recv_saveUserCommunication(self, ):
1396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1397 
    if mtype == TMessageType.EXCEPTION:
1398 
      x = TApplicationException()
1399 
      x.read(self._iprot)
1400 
      self._iprot.readMessageEnd()
1401 
      raise x
1402 
    result = saveUserCommunication_result()
1403 
    result.read(self._iprot)
1404 
    self._iprot.readMessageEnd()
3431 rajveer 1405 
    if result.success is not None:
1274 varun.gupt 1406 
      return result.success
3431 rajveer 1407 
    if result.ucx is not None:
1274 varun.gupt 1408 
      raise result.ucx
1409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1410 
 
1590 varun.gupt 1411 
  def getUserCommunicationById(self, id):
1412 
    """
1413 
    Parameters:
1414 
     - id
1415 
    """
1416 
    self.send_getUserCommunicationById(id)
1417 
    return self.recv_getUserCommunicationById()
1418 
 
1419 
  def send_getUserCommunicationById(self, id):
1420 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1421 
    args = getUserCommunicationById_args()
1422 
    args.id = id
1423 
    args.write(self._oprot)
1424 
    self._oprot.writeMessageEnd()
1425 
    self._oprot.trans.flush()
1426 
 
1427 
  def recv_getUserCommunicationById(self, ):
1428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1429 
    if mtype == TMessageType.EXCEPTION:
1430 
      x = TApplicationException()
1431 
      x.read(self._iprot)
1432 
      self._iprot.readMessageEnd()
1433 
      raise x
1434 
    result = getUserCommunicationById_result()
1435 
    result.read(self._iprot)
1436 
    self._iprot.readMessageEnd()
3431 rajveer 1437 
    if result.success is not None:
1590 varun.gupt 1438 
      return result.success
3431 rajveer 1439 
    if result.ucx is not None:
1590 varun.gupt 1440 
      raise result.ucx
1441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1442 
 
1443 
  def getUserCommunicationByUser(self, userId):
1444 
    """
1445 
    Parameters:
1446 
     - userId
1447 
    """
1448 
    self.send_getUserCommunicationByUser(userId)
1449 
    return self.recv_getUserCommunicationByUser()
1450 
 
1451 
  def send_getUserCommunicationByUser(self, userId):
1452 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1453 
    args = getUserCommunicationByUser_args()
1454 
    args.userId = userId
1455 
    args.write(self._oprot)
1456 
    self._oprot.writeMessageEnd()
1457 
    self._oprot.trans.flush()
1458 
 
1459 
  def recv_getUserCommunicationByUser(self, ):
1460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1461 
    if mtype == TMessageType.EXCEPTION:
1462 
      x = TApplicationException()
1463 
      x.read(self._iprot)
1464 
      self._iprot.readMessageEnd()
1465 
      raise x
1466 
    result = getUserCommunicationByUser_result()
1467 
    result.read(self._iprot)
1468 
    self._iprot.readMessageEnd()
3431 rajveer 1469 
    if result.success is not None:
1590 varun.gupt 1470 
      return result.success
3431 rajveer 1471 
    if result.ucx is not None:
1590 varun.gupt 1472 
      raise result.ucx
1473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1474 
 
1475 
  def getAllUserCommunications(self, ):
1476 
    self.send_getAllUserCommunications()
1477 
    return self.recv_getAllUserCommunications()
1478 
 
1479 
  def send_getAllUserCommunications(self, ):
1480 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1481 
    args = getAllUserCommunications_args()
1482 
    args.write(self._oprot)
1483 
    self._oprot.writeMessageEnd()
1484 
    self._oprot.trans.flush()
1485 
 
1486 
  def recv_getAllUserCommunications(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 = getAllUserCommunications_result()
1494 
    result.read(self._iprot)
1495 
    self._iprot.readMessageEnd()
3431 rajveer 1496 
    if result.success is not None:
1590 varun.gupt 1497 
      return result.success
3431 rajveer 1498 
    if result.ucx is not None:
1590 varun.gupt 1499 
      raise result.ucx
1500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1501 
 
5407 amar.kumar 1502 
  def removeUserCommunication(self, id):
1503 
    """
1504 
    Parameters:
1505 
     - id
1506 
    """
1507 
    self.send_removeUserCommunication(id)
1508 
    self.recv_removeUserCommunication()
1509 
 
1510 
  def send_removeUserCommunication(self, id):
1511 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1512 
    args = removeUserCommunication_args()
1513 
    args.id = id
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_removeUserCommunication(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 = removeUserCommunication_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
1528 
    if result.ucx is not None:
1529 
      raise result.ucx
1530 
    return
1531 
 
1859 vikas 1532 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1533 
    """
1534 
    Parameters:
1535 
     - name
1859 vikas 1536 
     - addedOn
1845 vikas 1537 
    """
1859 vikas 1538 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1539 
    return self.recv_createMasterAffiliate()
1540 
 
1859 vikas 1541 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1542 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1543 
    args = createMasterAffiliate_args()
1544 
    args.name = name
1859 vikas 1545 
    args.addedOn = addedOn
1845 vikas 1546 
    args.write(self._oprot)
1547 
    self._oprot.writeMessageEnd()
1548 
    self._oprot.trans.flush()
1549 
 
1550 
  def recv_createMasterAffiliate(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 = createMasterAffiliate_result()
1558 
    result.read(self._iprot)
1559 
    self._iprot.readMessageEnd()
3431 rajveer 1560 
    if result.success is not None:
1845 vikas 1561 
      return result.success
3431 rajveer 1562 
    if result.utx is not None:
1845 vikas 1563 
      raise result.utx
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1565 
 
1899 vikas 1566 
  def getAllMasterAffiliates(self, ):
1567 
    self.send_getAllMasterAffiliates()
1568 
    return self.recv_getAllMasterAffiliates()
1569 
 
1570 
  def send_getAllMasterAffiliates(self, ):
1571 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1572 
    args = getAllMasterAffiliates_args()
1573 
    args.write(self._oprot)
1574 
    self._oprot.writeMessageEnd()
1575 
    self._oprot.trans.flush()
1576 
 
1577 
  def recv_getAllMasterAffiliates(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 = getAllMasterAffiliates_result()
1585 
    result.read(self._iprot)
1586 
    self._iprot.readMessageEnd()
3431 rajveer 1587 
    if result.success is not None:
1899 vikas 1588 
      return result.success
3431 rajveer 1589 
    if result.utx is not None:
1899 vikas 1590 
      raise result.utx
1591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1592 
 
1845 vikas 1593 
  def getMasterAffiliateById(self, id):
1594 
    """
1595 
    Parameters:
1596 
     - id
1597 
    """
1598 
    self.send_getMasterAffiliateById(id)
1599 
    return self.recv_getMasterAffiliateById()
1600 
 
1601 
  def send_getMasterAffiliateById(self, id):
1602 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1603 
    args = getMasterAffiliateById_args()
1604 
    args.id = id
1605 
    args.write(self._oprot)
1606 
    self._oprot.writeMessageEnd()
1607 
    self._oprot.trans.flush()
1608 
 
1609 
  def recv_getMasterAffiliateById(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 = getMasterAffiliateById_result()
1617 
    result.read(self._iprot)
1618 
    self._iprot.readMessageEnd()
3431 rajveer 1619 
    if result.success is not None:
1845 vikas 1620 
      return result.success
3431 rajveer 1621 
    if result.utx is not None:
1845 vikas 1622 
      raise result.utx
1623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1624 
 
1625 
  def getMasterAffiliateByName(self, name):
1626 
    """
1627 
    Parameters:
1628 
     - name
1629 
    """
1630 
    self.send_getMasterAffiliateByName(name)
1631 
    return self.recv_getMasterAffiliateByName()
1632 
 
1633 
  def send_getMasterAffiliateByName(self, name):
1634 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1635 
    args = getMasterAffiliateByName_args()
1636 
    args.name = name
1637 
    args.write(self._oprot)
1638 
    self._oprot.writeMessageEnd()
1639 
    self._oprot.trans.flush()
1640 
 
1641 
  def recv_getMasterAffiliateByName(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 = getMasterAffiliateByName_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, "getMasterAffiliateByName failed: unknown result");
1656 
 
1859 vikas 1657 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1658 
    """
1659 
    Parameters:
1660 
     - name
1661 
     - url
1662 
     - masterAffiliateId
1859 vikas 1663 
     - addedOn
1845 vikas 1664 
    """
1859 vikas 1665 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1666 
    return self.recv_createAffiliate()
1667 
 
1859 vikas 1668 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1669 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1670 
    args = createAffiliate_args()
1671 
    args.name = name
1672 
    args.url = url
1673 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1674 
    args.addedOn = addedOn
1845 vikas 1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_createAffiliate(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = createAffiliate_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
3431 rajveer 1689 
    if result.success is not None:
1845 vikas 1690 
      return result.success
3431 rajveer 1691 
    if result.utx is not None:
1845 vikas 1692 
      raise result.utx
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1694 
 
1695 
  def getAffiliateById(self, id):
1696 
    """
1697 
    Parameters:
1698 
     - id
1699 
    """
1700 
    self.send_getAffiliateById(id)
1701 
    return self.recv_getAffiliateById()
1702 
 
1703 
  def send_getAffiliateById(self, id):
1704 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1705 
    args = getAffiliateById_args()
1706 
    args.id = id
1707 
    args.write(self._oprot)
1708 
    self._oprot.writeMessageEnd()
1709 
    self._oprot.trans.flush()
1710 
 
1711 
  def recv_getAffiliateById(self, ):
1712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1713 
    if mtype == TMessageType.EXCEPTION:
1714 
      x = TApplicationException()
1715 
      x.read(self._iprot)
1716 
      self._iprot.readMessageEnd()
1717 
      raise x
1718 
    result = getAffiliateById_result()
1719 
    result.read(self._iprot)
1720 
    self._iprot.readMessageEnd()
3431 rajveer 1721 
    if result.success is not None:
1845 vikas 1722 
      return result.success
3431 rajveer 1723 
    if result.utx is not None:
1845 vikas 1724 
      raise result.utx
1725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1726 
 
1727 
  def getAffiliateByName(self, name):
1728 
    """
1729 
    Parameters:
1730 
     - name
1731 
    """
1732 
    self.send_getAffiliateByName(name)
1733 
    return self.recv_getAffiliateByName()
1734 
 
1735 
  def send_getAffiliateByName(self, name):
1736 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1737 
    args = getAffiliateByName_args()
1738 
    args.name = name
1739 
    args.write(self._oprot)
1740 
    self._oprot.writeMessageEnd()
1741 
    self._oprot.trans.flush()
1742 
 
1743 
  def recv_getAffiliateByName(self, ):
1744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1745 
    if mtype == TMessageType.EXCEPTION:
1746 
      x = TApplicationException()
1747 
      x.read(self._iprot)
1748 
      self._iprot.readMessageEnd()
1749 
      raise x
1750 
    result = getAffiliateByName_result()
1751 
    result.read(self._iprot)
1752 
    self._iprot.readMessageEnd()
3431 rajveer 1753 
    if result.success is not None:
1845 vikas 1754 
      return result.success
3431 rajveer 1755 
    if result.utx is not None:
1845 vikas 1756 
      raise result.utx
1757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1758 
 
1996 vikas 1759 
  def getTrackerById(self, id):
1845 vikas 1760 
    """
1761 
    Parameters:
1762 
     - id
1763 
    """
1996 vikas 1764 
    self.send_getTrackerById(id)
1845 vikas 1765 
    return self.recv_getTrackerById()
1766 
 
1996 vikas 1767 
  def send_getTrackerById(self, id):
1845 vikas 1768 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1769 
    args = getTrackerById_args()
1996 vikas 1770 
    args.id = id
1845 vikas 1771 
    args.write(self._oprot)
1772 
    self._oprot.writeMessageEnd()
1773 
    self._oprot.trans.flush()
1774 
 
1775 
  def recv_getTrackerById(self, ):
1776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1777 
    if mtype == TMessageType.EXCEPTION:
1778 
      x = TApplicationException()
1779 
      x.read(self._iprot)
1780 
      self._iprot.readMessageEnd()
1781 
      raise x
1782 
    result = getTrackerById_result()
1783 
    result.read(self._iprot)
1784 
    self._iprot.readMessageEnd()
3431 rajveer 1785 
    if result.success is not None:
1845 vikas 1786 
      return result.success
3431 rajveer 1787 
    if result.utx is not None:
1845 vikas 1788 
      raise result.utx
1789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1790 
 
1996 vikas 1791 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1792 
    """
1793 
    Parameters:
1996 vikas 1794 
     - id
1845 vikas 1795 
    """
1996 vikas 1796 
    self.send_getAffiliatesByMasterAffiliate(id)
1797 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1798 
 
1996 vikas 1799 
  def send_getAffiliatesByMasterAffiliate(self, id):
1800 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1801 
    args = getAffiliatesByMasterAffiliate_args()
1802 
    args.id = id
1845 vikas 1803 
    args.write(self._oprot)
1804 
    self._oprot.writeMessageEnd()
1805 
    self._oprot.trans.flush()
1806 
 
1996 vikas 1807 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1809 
    if mtype == TMessageType.EXCEPTION:
1810 
      x = TApplicationException()
1811 
      x.read(self._iprot)
1812 
      self._iprot.readMessageEnd()
1813 
      raise x
1996 vikas 1814 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1815 
    result.read(self._iprot)
1816 
    self._iprot.readMessageEnd()
3431 rajveer 1817 
    if result.success is not None:
1845 vikas 1818 
      return result.success
3431 rajveer 1819 
    if result.utx is not None:
1845 vikas 1820 
      raise result.utx
1996 vikas 1821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1822 
 
1996 vikas 1823 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1824 
    """
1825 
    Parameters:
1996 vikas 1826 
     - affiliateId
1845 vikas 1827 
     - userId
1828 
     - event
1829 
     - url
1830 
     - data
1859 vikas 1831 
     - addedOn
1845 vikas 1832 
    """
1996 vikas 1833 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1834 
    return self.recv_addTrackLog()
1835 
 
1996 vikas 1836 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1837 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1838 
    args = addTrackLog_args()
1996 vikas 1839 
    args.affiliateId = affiliateId
1845 vikas 1840 
    args.userId = userId
1841 
    args.event = event
1842 
    args.url = url
1843 
    args.data = data
1859 vikas 1844 
    args.addedOn = addedOn
1845 vikas 1845 
    args.write(self._oprot)
1846 
    self._oprot.writeMessageEnd()
1847 
    self._oprot.trans.flush()
1848 
 
1849 
  def recv_addTrackLog(self, ):
1850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1851 
    if mtype == TMessageType.EXCEPTION:
1852 
      x = TApplicationException()
1853 
      x.read(self._iprot)
1854 
      self._iprot.readMessageEnd()
1855 
      raise x
1856 
    result = addTrackLog_result()
1857 
    result.read(self._iprot)
1858 
    self._iprot.readMessageEnd()
3431 rajveer 1859 
    if result.success is not None:
1845 vikas 1860 
      return result.success
3431 rajveer 1861 
    if result.utx is not None:
1845 vikas 1862 
      raise result.utx
1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1864 
 
1865 
  def getTrackLogById(self, id):
1866 
    """
1867 
    Parameters:
1868 
     - id
1869 
    """
1870 
    self.send_getTrackLogById(id)
1871 
    return self.recv_getTrackLogById()
1872 
 
1873 
  def send_getTrackLogById(self, id):
1874 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1875 
    args = getTrackLogById_args()
1876 
    args.id = id
1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
1881 
  def recv_getTrackLogById(self, ):
1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
1888 
    result = getTrackLogById_result()
1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
3431 rajveer 1891 
    if result.success is not None:
1845 vikas 1892 
      return result.success
3431 rajveer 1893 
    if result.utx is not None:
1845 vikas 1894 
      raise result.utx
1895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1896 
 
3293 vikas 1897 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1898 
    """
1899 
    Parameters:
1996 vikas 1900 
     - affiliateId
3293 vikas 1901 
     - startDate
1902 
     - endDate
1845 vikas 1903 
    """
3293 vikas 1904 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1905 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1906 
 
3293 vikas 1907 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1908 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1909 
    args = getTrackLogsByAffiliate_args()
1910 
    args.affiliateId = affiliateId
3293 vikas 1911 
    args.startDate = startDate
1912 
    args.endDate = endDate
1845 vikas 1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1996 vikas 1917 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1996 vikas 1924 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
3431 rajveer 1927 
    if result.success is not None:
1845 vikas 1928 
      return result.success
3431 rajveer 1929 
    if result.utx is not None:
1845 vikas 1930 
      raise result.utx
1996 vikas 1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1932 
 
1933 
  def getTrackLogsByUser(self, userId):
1934 
    """
1935 
    Parameters:
1936 
     - userId
1937 
    """
1938 
    self.send_getTrackLogsByUser(userId)
1939 
    return self.recv_getTrackLogsByUser()
1940 
 
1941 
  def send_getTrackLogsByUser(self, userId):
1942 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1943 
    args = getTrackLogsByUser_args()
1944 
    args.userId = userId
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getTrackLogsByUser(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getTrackLogsByUser_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
1845 vikas 1960 
      return result.success
3431 rajveer 1961 
    if result.utx is not None:
1845 vikas 1962 
      raise result.utx
1963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1964 
 
1996 vikas 1965 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1966 
    """
1967 
    Parameters:
1968 
     - userId
1969 
     - event
1970 
     - url
1971 
    """
1996 vikas 1972 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1973 
    return self.recv_getTrackLogs()
1974 
 
1996 vikas 1975 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1976 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1977 
    args = getTrackLogs_args()
1978 
    args.userId = userId
1979 
    args.event = event
1980 
    args.url = url
1981 
    args.write(self._oprot)
1982 
    self._oprot.writeMessageEnd()
1983 
    self._oprot.trans.flush()
1984 
 
1985 
  def recv_getTrackLogs(self, ):
1986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1987 
    if mtype == TMessageType.EXCEPTION:
1988 
      x = TApplicationException()
1989 
      x.read(self._iprot)
1990 
      self._iprot.readMessageEnd()
1991 
      raise x
1992 
    result = getTrackLogs_result()
1993 
    result.read(self._iprot)
1994 
    self._iprot.readMessageEnd()
3431 rajveer 1995 
    if result.success is not None:
1845 vikas 1996 
      return result.success
3431 rajveer 1997 
    if result.utx is not None:
1845 vikas 1998 
      raise result.utx
1999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2000 
 
559 chandransh 2001 
  def getCurrentCart(self, userId):
94 ashish 2002 
    """
2003 
    Parameters:
559 chandransh 2004 
     - userId
94 ashish 2005 
    """
559 chandransh 2006 
    self.send_getCurrentCart(userId)
2007 
    return self.recv_getCurrentCart()
94 ashish 2008 
 
559 chandransh 2009 
  def send_getCurrentCart(self, userId):
2010 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2011 
    args = getCurrentCart_args()
2012 
    args.userId = userId
94 ashish 2013 
    args.write(self._oprot)
2014 
    self._oprot.writeMessageEnd()
2015 
    self._oprot.trans.flush()
2016 
 
559 chandransh 2017 
  def recv_getCurrentCart(self, ):
94 ashish 2018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2019 
    if mtype == TMessageType.EXCEPTION:
2020 
      x = TApplicationException()
2021 
      x.read(self._iprot)
2022 
      self._iprot.readMessageEnd()
2023 
      raise x
559 chandransh 2024 
    result = getCurrentCart_result()
94 ashish 2025 
    result.read(self._iprot)
2026 
    self._iprot.readMessageEnd()
3431 rajveer 2027 
    if result.success is not None:
94 ashish 2028 
      return result.success
3431 rajveer 2029 
    if result.scx is not None:
559 chandransh 2030 
      raise result.scx
2031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2032 
 
559 chandransh 2033 
  def getCart(self, cartId):
94 ashish 2034 
    """
2035 
    Parameters:
559 chandransh 2036 
     - cartId
94 ashish 2037 
    """
559 chandransh 2038 
    self.send_getCart(cartId)
2039 
    return self.recv_getCart()
94 ashish 2040 
 
559 chandransh 2041 
  def send_getCart(self, cartId):
2042 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2043 
    args = getCart_args()
2044 
    args.cartId = cartId
94 ashish 2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
559 chandransh 2049 
  def recv_getCart(self, ):
94 ashish 2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
559 chandransh 2056 
    result = getCart_result()
94 ashish 2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
3431 rajveer 2059 
    if result.success is not None:
94 ashish 2060 
      return result.success
3431 rajveer 2061 
    if result.scx is not None:
559 chandransh 2062 
      raise result.scx
2063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2064 
 
559 chandransh 2065 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2066 
    """
2067 
    Parameters:
559 chandransh 2068 
     - from_time
2069 
     - to_time
2070 
     - status
94 ashish 2071 
    """
559 chandransh 2072 
    self.send_getCartsByTime(from_time, to_time, status)
2073 
    return self.recv_getCartsByTime()
94 ashish 2074 
 
559 chandransh 2075 
  def send_getCartsByTime(self, from_time, to_time, status):
2076 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2077 
    args = getCartsByTime_args()
2078 
    args.from_time = from_time
2079 
    args.to_time = to_time
2080 
    args.status = status
94 ashish 2081 
    args.write(self._oprot)
2082 
    self._oprot.writeMessageEnd()
2083 
    self._oprot.trans.flush()
2084 
 
559 chandransh 2085 
  def recv_getCartsByTime(self, ):
94 ashish 2086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2087 
    if mtype == TMessageType.EXCEPTION:
2088 
      x = TApplicationException()
2089 
      x.read(self._iprot)
2090 
      self._iprot.readMessageEnd()
2091 
      raise x
559 chandransh 2092 
    result = getCartsByTime_result()
94 ashish 2093 
    result.read(self._iprot)
2094 
    self._iprot.readMessageEnd()
3431 rajveer 2095 
    if result.success is not None:
94 ashish 2096 
      return result.success
3431 rajveer 2097 
    if result.scx is not None:
559 chandransh 2098 
      raise result.scx
2099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2100 
 
3557 rajveer 2101 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2102 
    """
2103 
    Parameters:
2104 
     - cartId
2105 
     - itemId
2106 
     - quantity
3557 rajveer 2107 
     - sourceId
559 chandransh 2108 
    """
3557 rajveer 2109 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2110 
    return self.recv_addItemToCart()
559 chandransh 2111 
 
3557 rajveer 2112 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2113 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2114 
    args = addItemToCart_args()
2115 
    args.cartId = cartId
2116 
    args.itemId = itemId
2117 
    args.quantity = quantity
3557 rajveer 2118 
    args.sourceId = sourceId
559 chandransh 2119 
    args.write(self._oprot)
2120 
    self._oprot.writeMessageEnd()
2121 
    self._oprot.trans.flush()
2122 
 
2123 
  def recv_addItemToCart(self, ):
2124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2125 
    if mtype == TMessageType.EXCEPTION:
2126 
      x = TApplicationException()
2127 
      x.read(self._iprot)
2128 
      self._iprot.readMessageEnd()
2129 
      raise x
2130 
    result = addItemToCart_result()
2131 
    result.read(self._iprot)
2132 
    self._iprot.readMessageEnd()
3431 rajveer 2133 
    if result.success is not None:
2035 rajveer 2134 
      return result.success
3431 rajveer 2135 
    if result.scx is not None:
559 chandransh 2136 
      raise result.scx
2035 rajveer 2137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2138 
 
2139 
  def deleteItemFromCart(self, cartId, itemId):
2140 
    """
2141 
    Parameters:
2142 
     - cartId
2143 
     - itemId
2144 
    """
2145 
    self.send_deleteItemFromCart(cartId, itemId)
2146 
    self.recv_deleteItemFromCart()
2147 
 
2148 
  def send_deleteItemFromCart(self, cartId, itemId):
2149 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2150 
    args = deleteItemFromCart_args()
2151 
    args.cartId = cartId
2152 
    args.itemId = itemId
2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
2157 
  def recv_deleteItemFromCart(self, ):
2158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2159 
    if mtype == TMessageType.EXCEPTION:
2160 
      x = TApplicationException()
2161 
      x.read(self._iprot)
2162 
      self._iprot.readMessageEnd()
2163 
      raise x
2164 
    result = deleteItemFromCart_result()
2165 
    result.read(self._iprot)
2166 
    self._iprot.readMessageEnd()
3431 rajveer 2167 
    if result.scx is not None:
559 chandransh 2168 
      raise result.scx
2169 
    return
2170 
 
2171 
  def addAddressToCart(self, cartId, addressId):
2172 
    """
2173 
    Parameters:
2174 
     - cartId
2175 
     - addressId
2176 
    """
2177 
    self.send_addAddressToCart(cartId, addressId)
2178 
    self.recv_addAddressToCart()
2179 
 
2180 
  def send_addAddressToCart(self, cartId, addressId):
2181 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2182 
    args = addAddressToCart_args()
2183 
    args.cartId = cartId
2184 
    args.addressId = addressId
2185 
    args.write(self._oprot)
2186 
    self._oprot.writeMessageEnd()
2187 
    self._oprot.trans.flush()
2188 
 
2189 
  def recv_addAddressToCart(self, ):
2190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2191 
    if mtype == TMessageType.EXCEPTION:
2192 
      x = TApplicationException()
2193 
      x.read(self._iprot)
2194 
      self._iprot.readMessageEnd()
2195 
      raise x
2196 
    result = addAddressToCart_result()
2197 
    result.read(self._iprot)
2198 
    self._iprot.readMessageEnd()
3431 rajveer 2199 
    if result.scx is not None:
575 chandransh 2200 
      raise result.scx
559 chandransh 2201 
    return
2202 
 
5553 rajveer 2203 
  def addStoreToCart(self, cartId, storeId):
2204 
    """
2205 
    Parameters:
2206 
     - cartId
2207 
     - storeId
2208 
    """
2209 
    self.send_addStoreToCart(cartId, storeId)
2210 
    self.recv_addStoreToCart()
2211 
 
2212 
  def send_addStoreToCart(self, cartId, storeId):
2213 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2214 
    args = addStoreToCart_args()
2215 
    args.cartId = cartId
2216 
    args.storeId = storeId
2217 
    args.write(self._oprot)
2218 
    self._oprot.writeMessageEnd()
2219 
    self._oprot.trans.flush()
2220 
 
2221 
  def recv_addStoreToCart(self, ):
2222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2223 
    if mtype == TMessageType.EXCEPTION:
2224 
      x = TApplicationException()
2225 
      x.read(self._iprot)
2226 
      self._iprot.readMessageEnd()
2227 
      raise x
2228 
    result = addStoreToCart_result()
2229 
    result.read(self._iprot)
2230 
    self._iprot.readMessageEnd()
2231 
    if result.scx is not None:
2232 
      raise result.scx
2233 
    return
2234 
 
6922 anupam.sin 2235 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2236 
    """
2237 
    Parameters:
6922 anupam.sin 2238 
     - cart
1976 varun.gupt 2239 
     - couponCode
2240 
    """
6922 anupam.sin 2241 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2242 
    self.recv_applyCouponToCart()
2243 
 
6922 anupam.sin 2244 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2245 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2246 
    args = applyCouponToCart_args()
6922 anupam.sin 2247 
    args.cart = cart
1976 varun.gupt 2248 
    args.couponCode = couponCode
2249 
    args.write(self._oprot)
2250 
    self._oprot.writeMessageEnd()
2251 
    self._oprot.trans.flush()
2252 
 
2253 
  def recv_applyCouponToCart(self, ):
2254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2255 
    if mtype == TMessageType.EXCEPTION:
2256 
      x = TApplicationException()
2257 
      x.read(self._iprot)
2258 
      self._iprot.readMessageEnd()
2259 
      raise x
2260 
    result = applyCouponToCart_result()
2261 
    result.read(self._iprot)
2262 
    self._iprot.readMessageEnd()
3431 rajveer 2263 
    if result.scx is not None:
1976 varun.gupt 2264 
      raise result.scx
2265 
    return
2266 
 
2267 
  def removeCoupon(self, cartId):
2268 
    """
2269 
    Parameters:
2270 
     - cartId
2271 
    """
2272 
    self.send_removeCoupon(cartId)
2273 
    self.recv_removeCoupon()
2274 
 
2275 
  def send_removeCoupon(self, cartId):
2276 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2277 
    args = removeCoupon_args()
2278 
    args.cartId = cartId
2279 
    args.write(self._oprot)
2280 
    self._oprot.writeMessageEnd()
2281 
    self._oprot.trans.flush()
2282 
 
2283 
  def recv_removeCoupon(self, ):
2284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2285 
    if mtype == TMessageType.EXCEPTION:
2286 
      x = TApplicationException()
2287 
      x.read(self._iprot)
2288 
      self._iprot.readMessageEnd()
2289 
      raise x
2290 
    result = removeCoupon_result()
2291 
    result.read(self._iprot)
2292 
    self._iprot.readMessageEnd()
3431 rajveer 2293 
    if result.scx is not None:
1976 varun.gupt 2294 
      raise result.scx
2295 
    return
2296 
 
3554 varun.gupt 2297 
  def deleteDiscountsFromCart(self, cartId):
2298 
    """
2299 
    Deletes all the discounts associated with the cart
2300 
 
2301 
    Parameters:
2302 
     - cartId
2303 
    """
2304 
    self.send_deleteDiscountsFromCart(cartId)
2305 
    self.recv_deleteDiscountsFromCart()
2306 
 
2307 
  def send_deleteDiscountsFromCart(self, cartId):
2308 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2309 
    args = deleteDiscountsFromCart_args()
2310 
    args.cartId = cartId
2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
2315 
  def recv_deleteDiscountsFromCart(self, ):
2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
2322 
    result = deleteDiscountsFromCart_result()
2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
2325 
    if result.scx is not None:
2326 
      raise result.scx
2327 
    return
2328 
 
2329 
  def saveDiscounts(self, discounts):
2330 
    """
2331 
    Accepts a list of thrift objects of Discount type and saves them
2332 
 
2333 
    Parameters:
2334 
     - discounts
2335 
    """
2336 
    self.send_saveDiscounts(discounts)
2337 
    self.recv_saveDiscounts()
2338 
 
2339 
  def send_saveDiscounts(self, discounts):
2340 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2341 
    args = saveDiscounts_args()
2342 
    args.discounts = discounts
2343 
    args.write(self._oprot)
2344 
    self._oprot.writeMessageEnd()
2345 
    self._oprot.trans.flush()
2346 
 
2347 
  def recv_saveDiscounts(self, ):
2348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2349 
    if mtype == TMessageType.EXCEPTION:
2350 
      x = TApplicationException()
2351 
      x.read(self._iprot)
2352 
      self._iprot.readMessageEnd()
2353 
      raise x
2354 
    result = saveDiscounts_result()
2355 
    result.read(self._iprot)
2356 
    self._iprot.readMessageEnd()
2357 
    if result.scx is not None:
2358 
      raise result.scx
2359 
    return
2360 
 
11526 amit.gupta 2361 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2362 
    """
690 chandransh 2363 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2364 
 
559 chandransh 2365 
    Parameters:
2366 
     - cartId
2815 vikas 2367 
     - sessionSource
2368 
     - sessionStartTime
3858 vikas 2369 
     - firstSource
2370 
     - firstSourceTime
5326 rajveer 2371 
     - userId
6389 rajveer 2372 
     - schemeId
11526 amit.gupta 2373 
     - orderSource
559 chandransh 2374 
    """
11526 amit.gupta 2375 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2376 
    return self.recv_createOrders()
559 chandransh 2377 
 
11526 amit.gupta 2378 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2379 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2380 
    args = createOrders_args()
559 chandransh 2381 
    args.cartId = cartId
2815 vikas 2382 
    args.sessionSource = sessionSource
2383 
    args.sessionStartTime = sessionStartTime
3858 vikas 2384 
    args.firstSource = firstSource
2385 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2386 
    args.userId = userId
6389 rajveer 2387 
    args.schemeId = schemeId
11526 amit.gupta 2388 
    args.orderSource = orderSource
559 chandransh 2389 
    args.write(self._oprot)
2390 
    self._oprot.writeMessageEnd()
2391 
    self._oprot.trans.flush()
2392 
 
690 chandransh 2393 
  def recv_createOrders(self, ):
559 chandransh 2394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2395 
    if mtype == TMessageType.EXCEPTION:
2396 
      x = TApplicationException()
2397 
      x.read(self._iprot)
2398 
      self._iprot.readMessageEnd()
2399 
      raise x
690 chandransh 2400 
    result = createOrders_result()
559 chandransh 2401 
    result.read(self._iprot)
2402 
    self._iprot.readMessageEnd()
3431 rajveer 2403 
    if result.success is not None:
130 ashish 2404 
      return result.success
3431 rajveer 2405 
    if result.scx is not None:
559 chandransh 2406 
      raise result.scx
690 chandransh 2407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2408 
 
3557 rajveer 2409 
  def validateCart(self, cartId, sourceId):
130 ashish 2410 
    """
690 chandransh 2411 
    Validates that:
2412 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2413 
    2. All of the lines in the cart are active items.
690 chandransh 2414 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2415 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2416 
 
130 ashish 2417 
    Parameters:
559 chandransh 2418 
     - cartId
3557 rajveer 2419 
     - sourceId
130 ashish 2420 
    """
3557 rajveer 2421 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2422 
    return self.recv_validateCart()
130 ashish 2423 
 
3557 rajveer 2424 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2425 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2426 
    args = validateCart_args()
2427 
    args.cartId = cartId
3557 rajveer 2428 
    args.sourceId = sourceId
130 ashish 2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
559 chandransh 2433 
  def recv_validateCart(self, ):
130 ashish 2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
559 chandransh 2440 
    result = validateCart_result()
130 ashish 2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
3431 rajveer 2443 
    if result.success is not None:
130 ashish 2444 
      return result.success
3431 rajveer 2445 
    if result.scex is not None:
575 chandransh 2446 
      raise result.scex
559 chandransh 2447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2448 
 
11980 amit.gupta 2449 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2450 
    """
2451 
    Validates that:
2452 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2453 
    2. All of the lines in the cart are active items.
2454 
    3. The estimate for any of the lines in cart doesn't change.
2455 
    If all three are true, returns empty string; else returns appropriate message.
2456 
 
2457 
    Parameters:
2458 
     - cartId
2459 
     - sourceId
2460 
     - dealCoupon
2461 
    """
2462 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2463 
    return self.recv_validateCartWithDealerCoupon()
2464 
 
2465 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2466 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2467 
    args = validateCartWithDealerCoupon_args()
2468 
    args.cartId = cartId
2469 
    args.sourceId = sourceId
2470 
    args.dealCoupon = dealCoupon
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_validateCartWithDealerCoupon(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = validateCartWithDealerCoupon_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    if result.success is not None:
2486 
      return result.success
2487 
    if result.scex is not None:
2488 
      raise result.scex
2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2490 
 
690 chandransh 2491 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2492 
    """
690 chandransh 2493 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2494 
 
575 chandransh 2495 
    Parameters:
690 chandransh 2496 
     - fromCartId
2497 
     - toCartId
2498 
    """
2499 
    self.send_mergeCart(fromCartId, toCartId)
2500 
    self.recv_mergeCart()
2501 
 
2502 
  def send_mergeCart(self, fromCartId, toCartId):
2503 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2504 
    args = mergeCart_args()
2505 
    args.fromCartId = fromCartId
2506 
    args.toCartId = toCartId
2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
2511 
  def recv_mergeCart(self, ):
2512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2513 
    if mtype == TMessageType.EXCEPTION:
2514 
      x = TApplicationException()
2515 
      x.read(self._iprot)
2516 
      self._iprot.readMessageEnd()
2517 
      raise x
2518 
    result = mergeCart_result()
2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
2521 
    return
2522 
 
2523 
  def checkOut(self, cartId):
2524 
    """
2525 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2526 
 
690 chandransh 2527 
    Parameters:
575 chandransh 2528 
     - cartId
2529 
    """
690 chandransh 2530 
    self.send_checkOut(cartId)
2531 
    return self.recv_checkOut()
575 chandransh 2532 
 
690 chandransh 2533 
  def send_checkOut(self, cartId):
2534 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2535 
    args = checkOut_args()
575 chandransh 2536 
    args.cartId = cartId
2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
690 chandransh 2541 
  def recv_checkOut(self, ):
575 chandransh 2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
690 chandransh 2548 
    result = checkOut_result()
575 chandransh 2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
3431 rajveer 2551 
    if result.success is not None:
575 chandransh 2552 
      return result.success
3431 rajveer 2553 
    if result.scex is not None:
575 chandransh 2554 
      raise result.scex
690 chandransh 2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2556 
 
690 chandransh 2557 
  def resetCart(self, cartId, items):
559 chandransh 2558 
    """
690 chandransh 2559 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2560 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2561 
 
559 chandransh 2562 
    Parameters:
690 chandransh 2563 
     - cartId
2564 
     - items
559 chandransh 2565 
    """
690 chandransh 2566 
    self.send_resetCart(cartId, items)
2567 
    return self.recv_resetCart()
130 ashish 2568 
 
690 chandransh 2569 
  def send_resetCart(self, cartId, items):
2570 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2571 
    args = resetCart_args()
2572 
    args.cartId = cartId
2573 
    args.items = items
559 chandransh 2574 
    args.write(self._oprot)
2575 
    self._oprot.writeMessageEnd()
2576 
    self._oprot.trans.flush()
2577 
 
690 chandransh 2578 
  def recv_resetCart(self, ):
559 chandransh 2579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2580 
    if mtype == TMessageType.EXCEPTION:
2581 
      x = TApplicationException()
2582 
      x.read(self._iprot)
2583 
      self._iprot.readMessageEnd()
2584 
      raise x
690 chandransh 2585 
    result = resetCart_result()
559 chandransh 2586 
    result.read(self._iprot)
2587 
    self._iprot.readMessageEnd()
3431 rajveer 2588 
    if result.success is not None:
690 chandransh 2589 
      return result.success
3431 rajveer 2590 
    if result.scex is not None:
690 chandransh 2591 
      raise result.scex
2592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2593 
 
2981 rajveer 2594 
  def getUserCount(self, userType):
559 chandransh 2595 
    """
2981 rajveer 2596 
    Returns number of registered users.
2597 
    If userType = null, then it returns count of all users, including anonymous
2598 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2599 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2600 
 
559 chandransh 2601 
    Parameters:
2981 rajveer 2602 
     - userType
559 chandransh 2603 
    """
2981 rajveer 2604 
    self.send_getUserCount(userType)
2605 
    return self.recv_getUserCount()
559 chandransh 2606 
 
2981 rajveer 2607 
  def send_getUserCount(self, userType):
2608 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2609 
    args = getUserCount_args()
2610 
    args.userType = userType
559 chandransh 2611 
    args.write(self._oprot)
2612 
    self._oprot.writeMessageEnd()
2613 
    self._oprot.trans.flush()
2614 
 
2981 rajveer 2615 
  def recv_getUserCount(self, ):
559 chandransh 2616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2617 
    if mtype == TMessageType.EXCEPTION:
2618 
      x = TApplicationException()
2619 
      x.read(self._iprot)
2620 
      self._iprot.readMessageEnd()
2621 
      raise x
2981 rajveer 2622 
    result = getUserCount_result()
559 chandransh 2623 
    result.read(self._iprot)
2624 
    self._iprot.readMessageEnd()
3431 rajveer 2625 
    if result.success is not None:
559 chandransh 2626 
      return result.success
2981 rajveer 2627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2628 
 
2981 rajveer 2629 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2630 
    """
2981 rajveer 2631 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2632 
    If any of startDate or endDate is -1, then that filter is ignored.
2633 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2634 
 
2635 
 
559 chandransh 2636 
    Parameters:
2981 rajveer 2637 
     - userType
2638 
     - startDate
2639 
     - endDate
559 chandransh 2640 
    """
2981 rajveer 2641 
    self.send_getAllUsers(userType, startDate, endDate)
2642 
    return self.recv_getAllUsers()
559 chandransh 2643 
 
2981 rajveer 2644 
  def send_getAllUsers(self, userType, startDate, endDate):
2645 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2646 
    args = getAllUsers_args()
2647 
    args.userType = userType
2648 
    args.startDate = startDate
2649 
    args.endDate = endDate
559 chandransh 2650 
    args.write(self._oprot)
2651 
    self._oprot.writeMessageEnd()
2652 
    self._oprot.trans.flush()
2653 
 
2981 rajveer 2654 
  def recv_getAllUsers(self, ):
559 chandransh 2655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2656 
    if mtype == TMessageType.EXCEPTION:
2657 
      x = TApplicationException()
2658 
      x.read(self._iprot)
2659 
      self._iprot.readMessageEnd()
2660 
      raise x
2981 rajveer 2661 
    result = getAllUsers_result()
559 chandransh 2662 
    result.read(self._iprot)
2663 
    self._iprot.readMessageEnd()
3431 rajveer 2664 
    if result.success is not None:
559 chandransh 2665 
      return result.success
2981 rajveer 2666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2667 
 
2981 rajveer 2668 
  def getMyResearchItems(self, userId):
559 chandransh 2669 
    """
2981 rajveer 2670 
    Returns list of item ids in myresearch for the user
3431 rajveer 2671 
 
559 chandransh 2672 
    Parameters:
772 rajveer 2673 
     - userId
559 chandransh 2674 
    """
2981 rajveer 2675 
    self.send_getMyResearchItems(userId)
2676 
    return self.recv_getMyResearchItems()
559 chandransh 2677 
 
2981 rajveer 2678 
  def send_getMyResearchItems(self, userId):
2679 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2680 
    args = getMyResearchItems_args()
772 rajveer 2681 
    args.userId = userId
559 chandransh 2682 
    args.write(self._oprot)
2683 
    self._oprot.writeMessageEnd()
2684 
    self._oprot.trans.flush()
2685 
 
2981 rajveer 2686 
  def recv_getMyResearchItems(self, ):
559 chandransh 2687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2688 
    if mtype == TMessageType.EXCEPTION:
2689 
      x = TApplicationException()
2690 
      x.read(self._iprot)
2691 
      self._iprot.readMessageEnd()
2692 
      raise x
2981 rajveer 2693 
    result = getMyResearchItems_result()
559 chandransh 2694 
    result.read(self._iprot)
2695 
    self._iprot.readMessageEnd()
3431 rajveer 2696 
    if result.success is not None:
559 chandransh 2697 
      return result.success
3431 rajveer 2698 
    if result.scx is not None:
559 chandransh 2699 
      raise result.scx
2981 rajveer 2700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2701 
 
2981 rajveer 2702 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2703 
    """
2981 rajveer 2704 
    add item to my research for a user
3431 rajveer 2705 
 
559 chandransh 2706 
    Parameters:
2981 rajveer 2707 
     - userId
2708 
     - itemId
559 chandransh 2709 
    """
2981 rajveer 2710 
    self.send_updateMyResearch(userId, itemId)
2711 
    return self.recv_updateMyResearch()
559 chandransh 2712 
 
2981 rajveer 2713 
  def send_updateMyResearch(self, userId, itemId):
2714 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2715 
    args = updateMyResearch_args()
2716 
    args.userId = userId
2717 
    args.itemId = itemId
559 chandransh 2718 
    args.write(self._oprot)
2719 
    self._oprot.writeMessageEnd()
2720 
    self._oprot.trans.flush()
2721 
 
2981 rajveer 2722 
  def recv_updateMyResearch(self, ):
559 chandransh 2723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2724 
    if mtype == TMessageType.EXCEPTION:
2725 
      x = TApplicationException()
2726 
      x.read(self._iprot)
2727 
      self._iprot.readMessageEnd()
2728 
      raise x
2981 rajveer 2729 
    result = updateMyResearch_result()
559 chandransh 2730 
    result.read(self._iprot)
2731 
    self._iprot.readMessageEnd()
3431 rajveer 2732 
    if result.success is not None:
2981 rajveer 2733 
      return result.success
3431 rajveer 2734 
    if result.scx is not None:
2981 rajveer 2735 
      raise result.scx
2736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2737 
 
2981 rajveer 2738 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2739 
    """
2981 rajveer 2740 
    delete item from my research for a user
3431 rajveer 2741 
 
1596 ankur.sing 2742 
    Parameters:
2981 rajveer 2743 
     - userId
2744 
     - itemId
1596 ankur.sing 2745 
    """
2981 rajveer 2746 
    self.send_deleteItemFromMyResearch(userId, itemId)
2747 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2748 
 
2981 rajveer 2749 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2750 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2751 
    args = deleteItemFromMyResearch_args()
2752 
    args.userId = userId
2753 
    args.itemId = itemId
1596 ankur.sing 2754 
    args.write(self._oprot)
2755 
    self._oprot.writeMessageEnd()
2756 
    self._oprot.trans.flush()
2757 
 
2981 rajveer 2758 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2760 
    if mtype == TMessageType.EXCEPTION:
2761 
      x = TApplicationException()
2762 
      x.read(self._iprot)
2763 
      self._iprot.readMessageEnd()
2764 
      raise x
2981 rajveer 2765 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2766 
    result.read(self._iprot)
2767 
    self._iprot.readMessageEnd()
3431 rajveer 2768 
    if result.scx is not None:
2981 rajveer 2769 
      raise result.scx
2770 
    return
1596 ankur.sing 2771 
 
2981 rajveer 2772 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2773 
    """
2981 rajveer 2774 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2775 
 
1673 ankur.sing 2776 
    Parameters:
2981 rajveer 2777 
     - userId
1673 ankur.sing 2778 
    """
2981 rajveer 2779 
    self.send_getBrowseHistoryItems(userId)
2780 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2781 
 
2981 rajveer 2782 
  def send_getBrowseHistoryItems(self, userId):
2783 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2784 
    args = getBrowseHistoryItems_args()
2785 
    args.userId = userId
1673 ankur.sing 2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
2981 rajveer 2790 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
2981 rajveer 2797 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
3431 rajveer 2800 
    if result.success is not None:
1673 ankur.sing 2801 
      return result.success
3431 rajveer 2802 
    if result.scx is not None:
2981 rajveer 2803 
      raise result.scx
2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2805 
 
2981 rajveer 2806 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2807 
    """
2981 rajveer 2808 
    add item to browse history for a user
3431 rajveer 2809 
 
2642 varun.gupt 2810 
    Parameters:
2981 rajveer 2811 
     - userId
2812 
     - itemId
2642 varun.gupt 2813 
    """
2981 rajveer 2814 
    self.send_updateBrowseHistory(userId, itemId)
2815 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2816 
 
2981 rajveer 2817 
  def send_updateBrowseHistory(self, userId, itemId):
2818 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2819 
    args = updateBrowseHistory_args()
2820 
    args.userId = userId
2821 
    args.itemId = itemId
2642 varun.gupt 2822 
    args.write(self._oprot)
2823 
    self._oprot.writeMessageEnd()
2824 
    self._oprot.trans.flush()
2825 
 
2981 rajveer 2826 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2828 
    if mtype == TMessageType.EXCEPTION:
2829 
      x = TApplicationException()
2830 
      x.read(self._iprot)
2831 
      self._iprot.readMessageEnd()
2832 
      raise x
2981 rajveer 2833 
    result = updateBrowseHistory_result()
2642 varun.gupt 2834 
    result.read(self._iprot)
2835 
    self._iprot.readMessageEnd()
2836 
    return
2837 
 
3385 varun.gupt 2838 
  def getCartsWithCouponCount(self, couponCode):
2839 
    """
2840 
    Returns count of Carts with given coupon applied
3431 rajveer 2841 
 
3385 varun.gupt 2842 
    Parameters:
2843 
     - couponCode
2844 
    """
2845 
    self.send_getCartsWithCouponCount(couponCode)
2846 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2847 
 
3385 varun.gupt 2848 
  def send_getCartsWithCouponCount(self, couponCode):
2849 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2850 
    args = getCartsWithCouponCount_args()
2851 
    args.couponCode = couponCode
2852 
    args.write(self._oprot)
2853 
    self._oprot.writeMessageEnd()
2854 
    self._oprot.trans.flush()
2855 
 
2856 
  def recv_getCartsWithCouponCount(self, ):
2857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2858 
    if mtype == TMessageType.EXCEPTION:
2859 
      x = TApplicationException()
2860 
      x.read(self._iprot)
2861 
      self._iprot.readMessageEnd()
2862 
      raise x
2863 
    result = getCartsWithCouponCount_result()
2864 
    result.read(self._iprot)
2865 
    self._iprot.readMessageEnd()
3431 rajveer 2866 
    if result.success is not None:
3385 varun.gupt 2867 
      return result.success
2868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2869 
 
3499 mandeep.dh 2870 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2871 
    """
2872 
    Updates COD trust level of a user
3385 varun.gupt 2873 
 
3499 mandeep.dh 2874 
    Parameters:
2875 
     - userId
2876 
     - trustLevelDelta
2877 
    """
2878 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2879 
 
2880 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2881 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2882 
    args = increaseTrustLevel_args()
2883 
    args.userId = userId
2884 
    args.trustLevelDelta = trustLevelDelta
2885 
    args.write(self._oprot)
2886 
    self._oprot.writeMessageEnd()
2887 
    self._oprot.trans.flush()
5407 amar.kumar 2888 
  def getTrustLevel(self, userId):
2889 
    """
2890 
    Get trust level of a user
2891 
 
2892 
    Parameters:
2893 
     - userId
2894 
    """
2895 
    self.send_getTrustLevel(userId)
2896 
    return self.recv_getTrustLevel()
2897 
 
2898 
  def send_getTrustLevel(self, userId):
2899 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2900 
    args = getTrustLevel_args()
2901 
    args.userId = userId
2902 
    args.write(self._oprot)
2903 
    self._oprot.writeMessageEnd()
2904 
    self._oprot.trans.flush()
2905 
 
2906 
  def recv_getTrustLevel(self, ):
2907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2908 
    if mtype == TMessageType.EXCEPTION:
2909 
      x = TApplicationException()
2910 
      x.read(self._iprot)
2911 
      self._iprot.readMessageEnd()
2912 
      raise x
2913 
    result = getTrustLevel_result()
2914 
    result.read(self._iprot)
2915 
    self._iprot.readMessageEnd()
2916 
    if result.success is not None:
2917 
      return result.success
2918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2919 
 
4668 varun.gupt 2920 
  def showCODOption(self, cartId, sourceId, pincode):
2921 
    """
2922 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2923 
 
4668 varun.gupt 2924 
    Parameters:
2925 
     - cartId
2926 
     - sourceId
2927 
     - pincode
2928 
    """
2929 
    self.send_showCODOption(cartId, sourceId, pincode)
2930 
    return self.recv_showCODOption()
2931 
 
2932 
  def send_showCODOption(self, cartId, sourceId, pincode):
2933 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2934 
    args = showCODOption_args()
2935 
    args.cartId = cartId
2936 
    args.sourceId = sourceId
2937 
    args.pincode = pincode
2938 
    args.write(self._oprot)
2939 
    self._oprot.writeMessageEnd()
2940 
    self._oprot.trans.flush()
2941 
 
2942 
  def recv_showCODOption(self, ):
2943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2944 
    if mtype == TMessageType.EXCEPTION:
2945 
      x = TApplicationException()
2946 
      x.read(self._iprot)
2947 
      self._iprot.readMessageEnd()
2948 
      raise x
2949 
    result = showCODOption_result()
2950 
    result.read(self._iprot)
2951 
    self._iprot.readMessageEnd()
2952 
    if result.success is not None:
2953 
      return result.success
2954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2955 
 
5623 anupam.sin 2956 
  def getUserEmails(self, startDate, endDate):
2957 
    """
2958 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2959 
 
5623 anupam.sin 2960 
    Parameters:
2961 
     - startDate
2962 
     - endDate
2963 
    """
2964 
    self.send_getUserEmails(startDate, endDate)
2965 
    return self.recv_getUserEmails()
2966 
 
2967 
  def send_getUserEmails(self, startDate, endDate):
2968 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
2969 
    args = getUserEmails_args()
2970 
    args.startDate = startDate
2971 
    args.endDate = endDate
2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
2976 
  def recv_getUserEmails(self, ):
2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
2983 
    result = getUserEmails_result()
2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
2986 
    if result.success is not None:
2987 
      return result.success
2988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
2989 
 
9299 kshitij.so 2990 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 2991 
    """
2992 
    Mark a cart lineitem as insured. Returns true/false.
2993 
 
2994 
    Parameters:
2995 
     - itemId
2996 
     - cartId
2997 
     - toInsure
9299 kshitij.so 2998 
     - insurerType
6903 anupam.sin 2999 
    """
9299 kshitij.so 3000 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3001 
    return self.recv_insureItem()
3002 
 
9299 kshitij.so 3003 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3004 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3005 
    args = insureItem_args()
3006 
    args.itemId = itemId
3007 
    args.cartId = cartId
3008 
    args.toInsure = toInsure
9299 kshitij.so 3009 
    args.insurerType = insurerType
6903 anupam.sin 3010 
    args.write(self._oprot)
3011 
    self._oprot.writeMessageEnd()
3012 
    self._oprot.trans.flush()
3013 
 
3014 
  def recv_insureItem(self, ):
3015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3016 
    if mtype == TMessageType.EXCEPTION:
3017 
      x = TApplicationException()
3018 
      x.read(self._iprot)
3019 
      self._iprot.readMessageEnd()
3020 
      raise x
3021 
    result = insureItem_result()
3022 
    result.read(self._iprot)
3023 
    self._iprot.readMessageEnd()
3024 
    if result.success is not None:
3025 
      return result.success
3026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3027 
 
3028 
  def cancelInsurance(self, cartId):
3029 
    """
3030 
    Cancel insurance for all items in the cart
3031 
 
3032 
    Parameters:
3033 
     - cartId
3034 
    """
3035 
    self.send_cancelInsurance(cartId)
3036 
    return self.recv_cancelInsurance()
3037 
 
3038 
  def send_cancelInsurance(self, cartId):
3039 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3040 
    args = cancelInsurance_args()
3041 
    args.cartId = cartId
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_cancelInsurance(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = cancelInsurance_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3056 
    if result.success is not None:
3057 
      return result.success
3058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3059 
 
3060 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3061 
    """
3062 
    Stores insurance specific details like date of birth and guardianName
3063 
 
3064 
    Parameters:
3065 
     - addressId
3066 
     - dob
3067 
     - guardianName
3068 
    """
3069 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3070 
    return self.recv_storeInsuranceSpecificDetails()
3071 
 
3072 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3073 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3074 
    args = storeInsuranceSpecificDetails_args()
3075 
    args.addressId = addressId
3076 
    args.dob = dob
3077 
    args.guardianName = guardianName
3078 
    args.write(self._oprot)
3079 
    self._oprot.writeMessageEnd()
3080 
    self._oprot.trans.flush()
3081 
 
3082 
  def recv_storeInsuranceSpecificDetails(self, ):
3083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3084 
    if mtype == TMessageType.EXCEPTION:
3085 
      x = TApplicationException()
3086 
      x.read(self._iprot)
3087 
      self._iprot.readMessageEnd()
3088 
      raise x
3089 
    result = storeInsuranceSpecificDetails_result()
3090 
    result.read(self._iprot)
3091 
    self._iprot.readMessageEnd()
3092 
    if result.success is not None:
3093 
      return result.success
3094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3095 
 
3096 
  def isInsuranceDetailPresent(self, addressId):
3097 
    """
3098 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3099 
 
3100 
    Parameters:
3101 
     - addressId
3102 
    """
3103 
    self.send_isInsuranceDetailPresent(addressId)
3104 
    return self.recv_isInsuranceDetailPresent()
3105 
 
3106 
  def send_isInsuranceDetailPresent(self, addressId):
3107 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3108 
    args = isInsuranceDetailPresent_args()
3109 
    args.addressId = addressId
3110 
    args.write(self._oprot)
3111 
    self._oprot.writeMessageEnd()
3112 
    self._oprot.trans.flush()
3113 
 
3114 
  def recv_isInsuranceDetailPresent(self, ):
3115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3116 
    if mtype == TMessageType.EXCEPTION:
3117 
      x = TApplicationException()
3118 
      x.read(self._iprot)
3119 
      self._iprot.readMessageEnd()
3120 
      raise x
3121 
    result = isInsuranceDetailPresent_result()
3122 
    result.read(self._iprot)
3123 
    self._iprot.readMessageEnd()
3124 
    if result.success is not None:
3125 
      return result.success
3126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3127 
 
9791 rajveer 3128 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3129 
    """
9791 rajveer 3130 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3131 
 
6821 amar.kumar 3132 
    Parameters:
3133 
     - startDate
3134 
     - endDate
3135 
    """
9791 rajveer 3136 
    self.send_getProductsAddedToCart(startDate, endDate)
3137 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3138 
 
9791 rajveer 3139 
  def send_getProductsAddedToCart(self, startDate, endDate):
3140 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3141 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3142 
    args.startDate = startDate
3143 
    args.endDate = endDate
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
9791 rajveer 3148 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
9791 rajveer 3155 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.success is not None:
3159 
      return result.success
9791 rajveer 3160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3161 
 
11980 amit.gupta 3162 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3163 
    """
3164 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3165 
 
11592 amit.gupta 3166 
    Parameters:
3167 
     - cartId
3168 
     - sourceId
11980 amit.gupta 3169 
     - dealerCoupon
11592 amit.gupta 3170 
    """
11980 amit.gupta 3171 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3172 
    return self.recv_validateCartPlus()
3173 
 
11980 amit.gupta 3174 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3175 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3176 
    args = validateCartPlus_args()
3177 
    args.cartId = cartId
3178 
    args.sourceId = sourceId
11980 amit.gupta 3179 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_validateCartPlus(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = validateCartPlus_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    if result.success is not None:
3195 
      return result.success
3196 
    if result.scex is not None:
3197 
      raise result.scex
3198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3199 
 
11679 vikram.rag 3200 
  def isPrivateDealUser(self, userId):
3201 
    """
3202 
    Parameters:
3203 
     - userId
3204 
    """
3205 
    self.send_isPrivateDealUser(userId)
3206 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3207 
 
11679 vikram.rag 3208 
  def send_isPrivateDealUser(self, userId):
3209 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3210 
    args = isPrivateDealUser_args()
3211 
    args.userId = userId
3212 
    args.write(self._oprot)
3213 
    self._oprot.writeMessageEnd()
3214 
    self._oprot.trans.flush()
3215 
 
3216 
  def recv_isPrivateDealUser(self, ):
3217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3218 
    if mtype == TMessageType.EXCEPTION:
3219 
      x = TApplicationException()
3220 
      x.read(self._iprot)
3221 
      self._iprot.readMessageEnd()
3222 
      raise x
3223 
    result = isPrivateDealUser_result()
3224 
    result.read(self._iprot)
3225 
    self._iprot.readMessageEnd()
3226 
    if result.success is not None:
3227 
      return result.success
3228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3229 
 
11890 kshitij.so 3230 
  def addPrivateDealUser(self, userId):
3231 
    """
3232 
    Parameters:
3233 
     - userId
3234 
    """
3235 
    self.send_addPrivateDealUser(userId)
3236 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3237 
 
11890 kshitij.so 3238 
  def send_addPrivateDealUser(self, userId):
3239 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3240 
    args = addPrivateDealUser_args()
3241 
    args.userId = userId
3242 
    args.write(self._oprot)
3243 
    self._oprot.writeMessageEnd()
3244 
    self._oprot.trans.flush()
3245 
 
3246 
  def recv_addPrivateDealUser(self, ):
3247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3248 
    if mtype == TMessageType.EXCEPTION:
3249 
      x = TApplicationException()
3250 
      x.read(self._iprot)
3251 
      self._iprot.readMessageEnd()
3252 
      raise x
3253 
    result = addPrivateDealUser_result()
3254 
    result.read(self._iprot)
3255 
    self._iprot.readMessageEnd()
3256 
    if result.success is not None:
3257 
      return result.success
3258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3259 
 
3260 
  def changePrivateDealUserStatus(self, userId, isActive):
3261 
    """
3262 
    Parameters:
3263 
     - userId
3264 
     - isActive
3265 
    """
3266 
    self.send_changePrivateDealUserStatus(userId, isActive)
3267 
    return self.recv_changePrivateDealUserStatus()
3268 
 
3269 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3270 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3271 
    args = changePrivateDealUserStatus_args()
3272 
    args.userId = userId
3273 
    args.isActive = isActive
3274 
    args.write(self._oprot)
3275 
    self._oprot.writeMessageEnd()
3276 
    self._oprot.trans.flush()
3277 
 
3278 
  def recv_changePrivateDealUserStatus(self, ):
3279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3280 
    if mtype == TMessageType.EXCEPTION:
3281 
      x = TApplicationException()
3282 
      x.read(self._iprot)
3283 
      self._iprot.readMessageEnd()
3284 
      raise x
3285 
    result = changePrivateDealUserStatus_result()
3286 
    result.read(self._iprot)
3287 
    self._iprot.readMessageEnd()
3288 
    if result.success is not None:
3289 
      return result.success
3290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3291 
 
3292 
  def getPrivateDealUser(self, userId):
3293 
    """
3294 
    Parameters:
3295 
     - userId
3296 
    """
3297 
    self.send_getPrivateDealUser(userId)
3298 
    return self.recv_getPrivateDealUser()
3299 
 
3300 
  def send_getPrivateDealUser(self, userId):
3301 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3302 
    args = getPrivateDealUser_args()
3303 
    args.userId = userId
3304 
    args.write(self._oprot)
3305 
    self._oprot.writeMessageEnd()
3306 
    self._oprot.trans.flush()
3307 
 
3308 
  def recv_getPrivateDealUser(self, ):
3309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3310 
    if mtype == TMessageType.EXCEPTION:
3311 
      x = TApplicationException()
3312 
      x.read(self._iprot)
3313 
      self._iprot.readMessageEnd()
3314 
      raise x
3315 
    result = getPrivateDealUser_result()
3316 
    result.read(self._iprot)
3317 
    self._iprot.readMessageEnd()
3318 
    if result.success is not None:
3319 
      return result.success
3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3321 
 
3322 
 
3376 rajveer 3323 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3324 
  def __init__(self, handler):
3376 rajveer 3325 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3326 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3327 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3328 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3329 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3330 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3331 
    self._processMap["createUser"] = Processor.process_createUser
3332 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3333 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3334 
    self._processMap["userExists"] = Processor.process_userExists
3335 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3336 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3337 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3338 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3339 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3340 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3341 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3342 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3343 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3344 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3345 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3346 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3347 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3348 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3349 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3350 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3351 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3352 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3353 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3354 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3355 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3356 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3357 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3358 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3359 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3360 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3361 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3362 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3363 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3364 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3365 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3366 
    self._processMap["getCart"] = Processor.process_getCart
3367 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3368 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3369 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3370 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3371 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3372 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3373 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3374 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3375 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3376 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3377 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3378 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3379 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3380 
    self._processMap["checkOut"] = Processor.process_checkOut
3381 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3382 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3383 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3384 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3385 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3386 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3387 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3388 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3389 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3390 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3391 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3392 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3393 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3394 
    self._processMap["insureItem"] = Processor.process_insureItem
3395 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3396 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3397 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3398 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3399 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3400 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3401 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3402 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3403 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
94 ashish 3404 
 
3405 
  def process(self, iprot, oprot):
3406 
    (name, type, seqid) = iprot.readMessageBegin()
3407 
    if name not in self._processMap:
3408 
      iprot.skip(TType.STRUCT)
3409 
      iprot.readMessageEnd()
3410 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3411 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3412 
      x.write(oprot)
3413 
      oprot.writeMessageEnd()
3414 
      oprot.trans.flush()
3415 
      return
3416 
    else:
3417 
      self._processMap[name](self, seqid, iprot, oprot)
3418 
    return True
3419 
 
559 chandransh 3420 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3421 
    args = createAnonymousUser_args()
94 ashish 3422 
    args.read(iprot)
3423 
    iprot.readMessageEnd()
559 chandransh 3424 
    result = createAnonymousUser_result()
94 ashish 3425 
    try:
559 chandransh 3426 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3427 
    except UserContextException, ucex:
3428 
      result.ucex = ucex
3429 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3430 
    result.write(oprot)
3431 
    oprot.writeMessageEnd()
3432 
    oprot.trans.flush()
3433 
 
559 chandransh 3434 
  def process_getUserById(self, seqid, iprot, oprot):
3435 
    args = getUserById_args()
94 ashish 3436 
    args.read(iprot)
3437 
    iprot.readMessageEnd()
559 chandransh 3438 
    result = getUserById_result()
94 ashish 3439 
    try:
559 chandransh 3440 
      result.success = self._handler.getUserById(args.userId)
3441 
    except UserContextException, ucex:
3442 
      result.ucex = ucex
3443 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3444 
    result.write(oprot)
3445 
    oprot.writeMessageEnd()
3446 
    oprot.trans.flush()
3447 
 
5326 rajveer 3448 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3449 
    args = getUserByCartId_args()
3450 
    args.read(iprot)
3451 
    iprot.readMessageEnd()
3452 
    result = getUserByCartId_result()
3453 
    try:
3454 
      result.success = self._handler.getUserByCartId(args.cartId)
3455 
    except UserContextException, ucex:
3456 
      result.ucex = ucex
3457 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3458 
    result.write(oprot)
3459 
    oprot.writeMessageEnd()
3460 
    oprot.trans.flush()
3461 
 
1491 vikas 3462 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3463 
    args = getUserByEmail_args()
3464 
    args.read(iprot)
3465 
    iprot.readMessageEnd()
3466 
    result = getUserByEmail_result()
3467 
    try:
3468 
      result.success = self._handler.getUserByEmail(args.email)
3469 
    except UserContextException, ucex:
3470 
      result.ucex = ucex
3471 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3472 
    result.write(oprot)
3473 
    oprot.writeMessageEnd()
3474 
    oprot.trans.flush()
3475 
 
3032 mandeep.dh 3476 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3477 
    args = getUserByMobileNumber_args()
3478 
    args.read(iprot)
3479 
    iprot.readMessageEnd()
3480 
    result = getUserByMobileNumber_result()
3481 
    try:
3482 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3483 
    except UserContextException, ucex:
3484 
      result.ucex = ucex
3485 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3486 
    result.write(oprot)
3487 
    oprot.writeMessageEnd()
3488 
    oprot.trans.flush()
3489 
 
559 chandransh 3490 
  def process_createUser(self, seqid, iprot, oprot):
3491 
    args = createUser_args()
94 ashish 3492 
    args.read(iprot)
3493 
    iprot.readMessageEnd()
559 chandransh 3494 
    result = createUser_result()
94 ashish 3495 
    try:
559 chandransh 3496 
      result.success = self._handler.createUser(args.user)
3497 
    except UserContextException, ucex:
3498 
      result.ucex = ucex
3499 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3500 
    result.write(oprot)
3501 
    oprot.writeMessageEnd()
3502 
    oprot.trans.flush()
3503 
 
559 chandransh 3504 
  def process_updateUser(self, seqid, iprot, oprot):
3505 
    args = updateUser_args()
94 ashish 3506 
    args.read(iprot)
3507 
    iprot.readMessageEnd()
559 chandransh 3508 
    result = updateUser_result()
94 ashish 3509 
    try:
559 chandransh 3510 
      result.success = self._handler.updateUser(args.user)
3511 
    except UserContextException, ucex:
3512 
      result.ucex = ucex
3513 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3514 
    result.write(oprot)
3515 
    oprot.writeMessageEnd()
3516 
    oprot.trans.flush()
3517 
 
122 ashish 3518 
  def process_authenticateUser(self, seqid, iprot, oprot):
3519 
    args = authenticateUser_args()
3520 
    args.read(iprot)
3521 
    iprot.readMessageEnd()
3522 
    result = authenticateUser_result()
3523 
    try:
559 chandransh 3524 
      result.success = self._handler.authenticateUser(args.email, args.password)
3525 
    except AuthenticationException, auex:
3526 
      result.auex = auex
122 ashish 3527 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3528 
    result.write(oprot)
3529 
    oprot.writeMessageEnd()
3530 
    oprot.trans.flush()
3531 
 
94 ashish 3532 
  def process_userExists(self, seqid, iprot, oprot):
3533 
    args = userExists_args()
3534 
    args.read(iprot)
3535 
    iprot.readMessageEnd()
3536 
    result = userExists_result()
3537 
    try:
3538 
      result.success = self._handler.userExists(args.email)
3539 
    except UserContextException, ucx:
3540 
      result.ucx = ucx
3541 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3542 
    result.write(oprot)
3543 
    oprot.writeMessageEnd()
3544 
    oprot.trans.flush()
3545 
 
3546 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3547 
    args = addAddressForUser_args()
3548 
    args.read(iprot)
3549 
    iprot.readMessageEnd()
3550 
    result = addAddressForUser_result()
3551 
    try:
567 rajveer 3552 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3553 
    except UserContextException, ucx:
3554 
      result.ucx = ucx
3555 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3556 
    result.write(oprot)
3557 
    oprot.writeMessageEnd()
3558 
    oprot.trans.flush()
3559 
 
3560 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3561 
    args = removeAddressForUser_args()
3562 
    args.read(iprot)
3563 
    iprot.readMessageEnd()
3564 
    result = removeAddressForUser_result()
3565 
    try:
3566 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3567 
    except UserContextException, ucx:
3568 
      result.ucx = ucx
3569 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3570 
    result.write(oprot)
3571 
    oprot.writeMessageEnd()
3572 
    oprot.trans.flush()
3573 
 
3574 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3575 
    args = setUserAsLoggedIn_args()
3576 
    args.read(iprot)
3577 
    iprot.readMessageEnd()
3578 
    result = setUserAsLoggedIn_result()
3579 
    try:
3580 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3581 
    except UserContextException, ucx:
3582 
      result.ucx = ucx
3583 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3584 
    result.write(oprot)
3585 
    oprot.writeMessageEnd()
3586 
    oprot.trans.flush()
3587 
 
3588 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3589 
    args = setUserAsLoggedOut_args()
3590 
    args.read(iprot)
3591 
    iprot.readMessageEnd()
3592 
    result = setUserAsLoggedOut_result()
3593 
    try:
3594 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3595 
    except UserContextException, ucx:
3596 
      result.ucx = ucx
3597 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3598 
    result.write(oprot)
3599 
    oprot.writeMessageEnd()
3600 
    oprot.trans.flush()
3601 
 
504 rajveer 3602 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3603 
    args = setDefaultAddress_args()
3604 
    args.read(iprot)
3605 
    iprot.readMessageEnd()
3606 
    result = setDefaultAddress_result()
3607 
    try:
3608 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3609 
    except UserContextException, ucx:
3610 
      result.ucx = ucx
3611 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3612 
    result.write(oprot)
3613 
    oprot.writeMessageEnd()
3614 
    oprot.trans.flush()
3615 
 
94 ashish 3616 
  def process_updatePassword(self, seqid, iprot, oprot):
3617 
    args = updatePassword_args()
3618 
    args.read(iprot)
3619 
    iprot.readMessageEnd()
3620 
    result = updatePassword_result()
3621 
    try:
594 rajveer 3622 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3623 
    except UserContextException, ucx:
3624 
      result.ucx = ucx
3625 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3626 
    result.write(oprot)
3627 
    oprot.writeMessageEnd()
3628 
    oprot.trans.flush()
3629 
 
581 rajveer 3630 
  def process_forgotPassword(self, seqid, iprot, oprot):
3631 
    args = forgotPassword_args()
3632 
    args.read(iprot)
3633 
    iprot.readMessageEnd()
3634 
    result = forgotPassword_result()
3635 
    try:
884 rajveer 3636 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3637 
    except UserContextException, ucx:
3638 
      result.ucx = ucx
3639 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3640 
    result.write(oprot)
3641 
    oprot.writeMessageEnd()
3642 
    oprot.trans.flush()
3643 
 
594 rajveer 3644 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3645 
    args = getAllAddressesForUser_args()
3646 
    args.read(iprot)
3647 
    iprot.readMessageEnd()
3648 
    result = getAllAddressesForUser_result()
3649 
    try:
3650 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3651 
    except UserContextException, ucx:
3652 
      result.ucx = ucx
3653 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3654 
    result.write(oprot)
3655 
    oprot.writeMessageEnd()
3656 
    oprot.trans.flush()
3657 
 
1894 vikas 3658 
  def process_getAddressById(self, seqid, iprot, oprot):
3659 
    args = getAddressById_args()
3660 
    args.read(iprot)
3661 
    iprot.readMessageEnd()
3662 
    result = getAddressById_result()
3663 
    try:
3664 
      result.success = self._handler.getAddressById(args.addressId)
3665 
    except UserContextException, ucx:
3666 
      result.ucx = ucx
3667 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3668 
    result.write(oprot)
3669 
    oprot.writeMessageEnd()
3670 
    oprot.trans.flush()
3671 
 
594 rajveer 3672 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3673 
    args = getDefaultAddressId_args()
3674 
    args.read(iprot)
3675 
    iprot.readMessageEnd()
3676 
    result = getDefaultAddressId_result()
3677 
    try:
3678 
      result.success = self._handler.getDefaultAddressId(args.userId)
3679 
    except UserContextException, ucx:
3680 
      result.ucx = ucx
3681 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3682 
    result.write(oprot)
3683 
    oprot.writeMessageEnd()
3684 
    oprot.trans.flush()
3685 
 
785 rajveer 3686 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3687 
    args = getDefaultPincode_args()
3688 
    args.read(iprot)
3689 
    iprot.readMessageEnd()
3690 
    result = getDefaultPincode_result()
3691 
    try:
3692 
      result.success = self._handler.getDefaultPincode(args.userId)
3693 
    except UserContextException, ucx:
3694 
      result.ucx = ucx
3695 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3696 
    result.write(oprot)
3697 
    oprot.writeMessageEnd()
3698 
    oprot.trans.flush()
3699 
 
1274 varun.gupt 3700 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3701 
    args = saveUserCommunication_args()
3702 
    args.read(iprot)
3703 
    iprot.readMessageEnd()
3704 
    result = saveUserCommunication_result()
3705 
    try:
3706 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3707 
    except UserCommunicationException, ucx:
3708 
      result.ucx = ucx
3709 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3710 
    result.write(oprot)
3711 
    oprot.writeMessageEnd()
3712 
    oprot.trans.flush()
3713 
 
1590 varun.gupt 3714 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3715 
    args = getUserCommunicationById_args()
3716 
    args.read(iprot)
3717 
    iprot.readMessageEnd()
3718 
    result = getUserCommunicationById_result()
3719 
    try:
3720 
      result.success = self._handler.getUserCommunicationById(args.id)
3721 
    except UserCommunicationException, ucx:
3722 
      result.ucx = ucx
3723 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3724 
    result.write(oprot)
3725 
    oprot.writeMessageEnd()
3726 
    oprot.trans.flush()
3727 
 
3728 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3729 
    args = getUserCommunicationByUser_args()
3730 
    args.read(iprot)
3731 
    iprot.readMessageEnd()
3732 
    result = getUserCommunicationByUser_result()
3733 
    try:
3734 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3735 
    except UserCommunicationException, ucx:
3736 
      result.ucx = ucx
3737 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3738 
    result.write(oprot)
3739 
    oprot.writeMessageEnd()
3740 
    oprot.trans.flush()
3741 
 
3742 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3743 
    args = getAllUserCommunications_args()
3744 
    args.read(iprot)
3745 
    iprot.readMessageEnd()
3746 
    result = getAllUserCommunications_result()
3747 
    try:
3748 
      result.success = self._handler.getAllUserCommunications()
3749 
    except UserCommunicationException, ucx:
3750 
      result.ucx = ucx
3751 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3752 
    result.write(oprot)
3753 
    oprot.writeMessageEnd()
3754 
    oprot.trans.flush()
3755 
 
5407 amar.kumar 3756 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3757 
    args = removeUserCommunication_args()
3758 
    args.read(iprot)
3759 
    iprot.readMessageEnd()
3760 
    result = removeUserCommunication_result()
3761 
    try:
3762 
      self._handler.removeUserCommunication(args.id)
3763 
    except UserCommunicationException, ucx:
3764 
      result.ucx = ucx
3765 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3766 
    result.write(oprot)
3767 
    oprot.writeMessageEnd()
3768 
    oprot.trans.flush()
3769 
 
1845 vikas 3770 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3771 
    args = createMasterAffiliate_args()
3772 
    args.read(iprot)
3773 
    iprot.readMessageEnd()
3774 
    result = createMasterAffiliate_result()
3775 
    try:
1859 vikas 3776 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3777 
    except UserAffiliateException, utx:
1845 vikas 3778 
      result.utx = utx
3779 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3780 
    result.write(oprot)
3781 
    oprot.writeMessageEnd()
3782 
    oprot.trans.flush()
3783 
 
1899 vikas 3784 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3785 
    args = getAllMasterAffiliates_args()
3786 
    args.read(iprot)
3787 
    iprot.readMessageEnd()
3788 
    result = getAllMasterAffiliates_result()
3789 
    try:
3790 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3791 
    except UserAffiliateException, utx:
1899 vikas 3792 
      result.utx = utx
3793 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3794 
    result.write(oprot)
3795 
    oprot.writeMessageEnd()
3796 
    oprot.trans.flush()
3797 
 
1845 vikas 3798 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3799 
    args = getMasterAffiliateById_args()
3800 
    args.read(iprot)
3801 
    iprot.readMessageEnd()
3802 
    result = getMasterAffiliateById_result()
3803 
    try:
3804 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3805 
    except UserAffiliateException, utx:
1845 vikas 3806 
      result.utx = utx
3807 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3808 
    result.write(oprot)
3809 
    oprot.writeMessageEnd()
3810 
    oprot.trans.flush()
3811 
 
3812 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3813 
    args = getMasterAffiliateByName_args()
3814 
    args.read(iprot)
3815 
    iprot.readMessageEnd()
3816 
    result = getMasterAffiliateByName_result()
3817 
    try:
3818 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3819 
    except UserAffiliateException, utx:
1845 vikas 3820 
      result.utx = utx
3821 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3822 
    result.write(oprot)
3823 
    oprot.writeMessageEnd()
3824 
    oprot.trans.flush()
3825 
 
3826 
  def process_createAffiliate(self, seqid, iprot, oprot):
3827 
    args = createAffiliate_args()
3828 
    args.read(iprot)
3829 
    iprot.readMessageEnd()
3830 
    result = createAffiliate_result()
3831 
    try:
1859 vikas 3832 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3833 
    except UserAffiliateException, utx:
1845 vikas 3834 
      result.utx = utx
3835 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3836 
    result.write(oprot)
3837 
    oprot.writeMessageEnd()
3838 
    oprot.trans.flush()
3839 
 
3840 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3841 
    args = getAffiliateById_args()
3842 
    args.read(iprot)
3843 
    iprot.readMessageEnd()
3844 
    result = getAffiliateById_result()
3845 
    try:
3846 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3847 
    except UserAffiliateException, utx:
1845 vikas 3848 
      result.utx = utx
3849 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3850 
    result.write(oprot)
3851 
    oprot.writeMessageEnd()
3852 
    oprot.trans.flush()
3853 
 
3854 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3855 
    args = getAffiliateByName_args()
3856 
    args.read(iprot)
3857 
    iprot.readMessageEnd()
3858 
    result = getAffiliateByName_result()
3859 
    try:
3860 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3861 
    except UserAffiliateException, utx:
1845 vikas 3862 
      result.utx = utx
3863 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3864 
    result.write(oprot)
3865 
    oprot.writeMessageEnd()
3866 
    oprot.trans.flush()
3867 
 
3868 
  def process_getTrackerById(self, seqid, iprot, oprot):
3869 
    args = getTrackerById_args()
3870 
    args.read(iprot)
3871 
    iprot.readMessageEnd()
3872 
    result = getTrackerById_result()
3873 
    try:
1996 vikas 3874 
      result.success = self._handler.getTrackerById(args.id)
3875 
    except UserAffiliateException, utx:
1845 vikas 3876 
      result.utx = utx
3877 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3878 
    result.write(oprot)
3879 
    oprot.writeMessageEnd()
3880 
    oprot.trans.flush()
3881 
 
1996 vikas 3882 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3883 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3884 
    args.read(iprot)
3885 
    iprot.readMessageEnd()
1996 vikas 3886 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3887 
    try:
1996 vikas 3888 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3889 
    except UserAffiliateException, utx:
1845 vikas 3890 
      result.utx = utx
1996 vikas 3891 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3892 
    result.write(oprot)
3893 
    oprot.writeMessageEnd()
3894 
    oprot.trans.flush()
3895 
 
3896 
  def process_addTrackLog(self, seqid, iprot, oprot):
3897 
    args = addTrackLog_args()
3898 
    args.read(iprot)
3899 
    iprot.readMessageEnd()
3900 
    result = addTrackLog_result()
3901 
    try:
1996 vikas 3902 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3903 
    except UserAffiliateException, utx:
1845 vikas 3904 
      result.utx = utx
3905 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3906 
    result.write(oprot)
3907 
    oprot.writeMessageEnd()
3908 
    oprot.trans.flush()
3909 
 
3910 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3911 
    args = getTrackLogById_args()
3912 
    args.read(iprot)
3913 
    iprot.readMessageEnd()
3914 
    result = getTrackLogById_result()
3915 
    try:
3916 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3917 
    except UserAffiliateException, utx:
1845 vikas 3918 
      result.utx = utx
3919 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3920 
    result.write(oprot)
3921 
    oprot.writeMessageEnd()
3922 
    oprot.trans.flush()
3923 
 
1996 vikas 3924 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3925 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3926 
    args.read(iprot)
3927 
    iprot.readMessageEnd()
1996 vikas 3928 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3929 
    try:
3293 vikas 3930 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3931 
    except UserAffiliateException, utx:
1845 vikas 3932 
      result.utx = utx
1996 vikas 3933 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3934 
    result.write(oprot)
3935 
    oprot.writeMessageEnd()
3936 
    oprot.trans.flush()
3937 
 
3938 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3939 
    args = getTrackLogsByUser_args()
3940 
    args.read(iprot)
3941 
    iprot.readMessageEnd()
3942 
    result = getTrackLogsByUser_result()
3943 
    try:
3944 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3945 
    except UserAffiliateException, utx:
1845 vikas 3946 
      result.utx = utx
3947 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3948 
    result.write(oprot)
3949 
    oprot.writeMessageEnd()
3950 
    oprot.trans.flush()
3951 
 
3952 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3953 
    args = getTrackLogs_args()
3954 
    args.read(iprot)
3955 
    iprot.readMessageEnd()
3956 
    result = getTrackLogs_result()
3957 
    try:
1996 vikas 3958 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3959 
    except UserAffiliateException, utx:
1845 vikas 3960 
      result.utx = utx
3961 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3962 
    result.write(oprot)
3963 
    oprot.writeMessageEnd()
3964 
    oprot.trans.flush()
3965 
 
559 chandransh 3966 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3967 
    args = getCurrentCart_args()
94 ashish 3968 
    args.read(iprot)
3969 
    iprot.readMessageEnd()
559 chandransh 3970 
    result = getCurrentCart_result()
94 ashish 3971 
    try:
559 chandransh 3972 
      result.success = self._handler.getCurrentCart(args.userId)
3973 
    except ShoppingCartException, scx:
3974 
      result.scx = scx
3975 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3976 
    result.write(oprot)
3977 
    oprot.writeMessageEnd()
3978 
    oprot.trans.flush()
3979 
 
559 chandransh 3980 
  def process_getCart(self, seqid, iprot, oprot):
3981 
    args = getCart_args()
94 ashish 3982 
    args.read(iprot)
3983 
    iprot.readMessageEnd()
559 chandransh 3984 
    result = getCart_result()
94 ashish 3985 
    try:
559 chandransh 3986 
      result.success = self._handler.getCart(args.cartId)
3987 
    except ShoppingCartException, scx:
3988 
      result.scx = scx
3989 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3990 
    result.write(oprot)
3991 
    oprot.writeMessageEnd()
3992 
    oprot.trans.flush()
3993 
 
559 chandransh 3994 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3995 
    args = getCartsByTime_args()
94 ashish 3996 
    args.read(iprot)
3997 
    iprot.readMessageEnd()
559 chandransh 3998 
    result = getCartsByTime_result()
94 ashish 3999 
    try:
559 chandransh 4000 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4001 
    except ShoppingCartException, scx:
4002 
      result.scx = scx
4003 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4004 
    result.write(oprot)
4005 
    oprot.writeMessageEnd()
4006 
    oprot.trans.flush()
4007 
 
559 chandransh 4008 
  def process_addItemToCart(self, seqid, iprot, oprot):
4009 
    args = addItemToCart_args()
130 ashish 4010 
    args.read(iprot)
4011 
    iprot.readMessageEnd()
559 chandransh 4012 
    result = addItemToCart_result()
130 ashish 4013 
    try:
3557 rajveer 4014 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4015 
    except ShoppingCartException, scx:
4016 
      result.scx = scx
4017 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4018 
    result.write(oprot)
4019 
    oprot.writeMessageEnd()
4020 
    oprot.trans.flush()
4021 
 
559 chandransh 4022 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4023 
    args = deleteItemFromCart_args()
4024 
    args.read(iprot)
4025 
    iprot.readMessageEnd()
4026 
    result = deleteItemFromCart_result()
4027 
    try:
4028 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4029 
    except ShoppingCartException, scx:
4030 
      result.scx = scx
4031 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4032 
    result.write(oprot)
4033 
    oprot.writeMessageEnd()
4034 
    oprot.trans.flush()
130 ashish 4035 
 
559 chandransh 4036 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4037 
    args = addAddressToCart_args()
4038 
    args.read(iprot)
4039 
    iprot.readMessageEnd()
4040 
    result = addAddressToCart_result()
575 chandransh 4041 
    try:
4042 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4043 
    except ShoppingCartException, scx:
4044 
      result.scx = scx
559 chandransh 4045 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4046 
    result.write(oprot)
4047 
    oprot.writeMessageEnd()
4048 
    oprot.trans.flush()
4049 
 
5553 rajveer 4050 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4051 
    args = addStoreToCart_args()
4052 
    args.read(iprot)
4053 
    iprot.readMessageEnd()
4054 
    result = addStoreToCart_result()
4055 
    try:
4056 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4057 
    except ShoppingCartException, scx:
4058 
      result.scx = scx
4059 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4060 
    result.write(oprot)
4061 
    oprot.writeMessageEnd()
4062 
    oprot.trans.flush()
4063 
 
1976 varun.gupt 4064 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4065 
    args = applyCouponToCart_args()
4066 
    args.read(iprot)
4067 
    iprot.readMessageEnd()
4068 
    result = applyCouponToCart_result()
4069 
    try:
6922 anupam.sin 4070 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4071 
    except ShoppingCartException, scx:
4072 
      result.scx = scx
4073 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4074 
    result.write(oprot)
4075 
    oprot.writeMessageEnd()
4076 
    oprot.trans.flush()
4077 
 
4078 
  def process_removeCoupon(self, seqid, iprot, oprot):
4079 
    args = removeCoupon_args()
4080 
    args.read(iprot)
4081 
    iprot.readMessageEnd()
4082 
    result = removeCoupon_result()
4083 
    try:
4084 
      self._handler.removeCoupon(args.cartId)
4085 
    except ShoppingCartException, scx:
4086 
      result.scx = scx
4087 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4088 
    result.write(oprot)
4089 
    oprot.writeMessageEnd()
4090 
    oprot.trans.flush()
4091 
 
3554 varun.gupt 4092 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4093 
    args = deleteDiscountsFromCart_args()
4094 
    args.read(iprot)
4095 
    iprot.readMessageEnd()
4096 
    result = deleteDiscountsFromCart_result()
4097 
    try:
4098 
      self._handler.deleteDiscountsFromCart(args.cartId)
4099 
    except ShoppingCartException, scx:
4100 
      result.scx = scx
4101 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4102 
    result.write(oprot)
4103 
    oprot.writeMessageEnd()
4104 
    oprot.trans.flush()
4105 
 
4106 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4107 
    args = saveDiscounts_args()
4108 
    args.read(iprot)
4109 
    iprot.readMessageEnd()
4110 
    result = saveDiscounts_result()
4111 
    try:
4112 
      self._handler.saveDiscounts(args.discounts)
4113 
    except ShoppingCartException, scx:
4114 
      result.scx = scx
4115 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4116 
    result.write(oprot)
4117 
    oprot.writeMessageEnd()
4118 
    oprot.trans.flush()
4119 
 
690 chandransh 4120 
  def process_createOrders(self, seqid, iprot, oprot):
4121 
    args = createOrders_args()
559 chandransh 4122 
    args.read(iprot)
4123 
    iprot.readMessageEnd()
690 chandransh 4124 
    result = createOrders_result()
559 chandransh 4125 
    try:
11526 amit.gupta 4126 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4127 
    except ShoppingCartException, scx:
4128 
      result.scx = scx
690 chandransh 4129 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4130 
    result.write(oprot)
4131 
    oprot.writeMessageEnd()
4132 
    oprot.trans.flush()
4133 
 
4134 
  def process_validateCart(self, seqid, iprot, oprot):
4135 
    args = validateCart_args()
4136 
    args.read(iprot)
4137 
    iprot.readMessageEnd()
4138 
    result = validateCart_result()
575 chandransh 4139 
    try:
3557 rajveer 4140 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4141 
    except ShoppingCartException, scex:
4142 
      result.scex = scex
559 chandransh 4143 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4144 
    result.write(oprot)
4145 
    oprot.writeMessageEnd()
4146 
    oprot.trans.flush()
4147 
 
11980 amit.gupta 4148 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4149 
    args = validateCartWithDealerCoupon_args()
4150 
    args.read(iprot)
4151 
    iprot.readMessageEnd()
4152 
    result = validateCartWithDealerCoupon_result()
4153 
    try:
4154 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4155 
    except ShoppingCartException, scex:
4156 
      result.scex = scex
4157 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4158 
    result.write(oprot)
4159 
    oprot.writeMessageEnd()
4160 
    oprot.trans.flush()
4161 
 
690 chandransh 4162 
  def process_mergeCart(self, seqid, iprot, oprot):
4163 
    args = mergeCart_args()
575 chandransh 4164 
    args.read(iprot)
4165 
    iprot.readMessageEnd()
690 chandransh 4166 
    result = mergeCart_result()
4167 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4168 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4169 
    result.write(oprot)
4170 
    oprot.writeMessageEnd()
4171 
    oprot.trans.flush()
4172 
 
4173 
  def process_checkOut(self, seqid, iprot, oprot):
4174 
    args = checkOut_args()
4175 
    args.read(iprot)
4176 
    iprot.readMessageEnd()
4177 
    result = checkOut_result()
575 chandransh 4178 
    try:
690 chandransh 4179 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4180 
    except ShoppingCartException, scex:
4181 
      result.scex = scex
690 chandransh 4182 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4183 
    result.write(oprot)
4184 
    oprot.writeMessageEnd()
4185 
    oprot.trans.flush()
4186 
 
690 chandransh 4187 
  def process_resetCart(self, seqid, iprot, oprot):
4188 
    args = resetCart_args()
559 chandransh 4189 
    args.read(iprot)
4190 
    iprot.readMessageEnd()
690 chandransh 4191 
    result = resetCart_result()
4192 
    try:
4193 
      result.success = self._handler.resetCart(args.cartId, args.items)
4194 
    except ShoppingCartException, scex:
4195 
      result.scex = scex
4196 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4197 
    result.write(oprot)
4198 
    oprot.writeMessageEnd()
4199 
    oprot.trans.flush()
4200 
 
2981 rajveer 4201 
  def process_getUserCount(self, seqid, iprot, oprot):
4202 
    args = getUserCount_args()
559 chandransh 4203 
    args.read(iprot)
4204 
    iprot.readMessageEnd()
2981 rajveer 4205 
    result = getUserCount_result()
4206 
    result.success = self._handler.getUserCount(args.userType)
4207 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
4211 
 
2981 rajveer 4212 
  def process_getAllUsers(self, seqid, iprot, oprot):
4213 
    args = getAllUsers_args()
559 chandransh 4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
2981 rajveer 4216 
    result = getAllUsers_result()
4217 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4218 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
2981 rajveer 4223 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4224 
    args = getMyResearchItems_args()
559 chandransh 4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
2981 rajveer 4227 
    result = getMyResearchItems_result()
559 chandransh 4228 
    try:
2981 rajveer 4229 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4230 
    except WidgetException, scx:
4231 
      result.scx = scx
2981 rajveer 4232 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
4236 
 
2981 rajveer 4237 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4238 
    args = updateMyResearch_args()
772 rajveer 4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
2981 rajveer 4241 
    result = updateMyResearch_result()
4242 
    try:
4243 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4244 
    except WidgetException, scx:
4245 
      result.scx = scx
4246 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4247 
    result.write(oprot)
4248 
    oprot.writeMessageEnd()
4249 
    oprot.trans.flush()
559 chandransh 4250 
 
2981 rajveer 4251 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4252 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4253 
    args.read(iprot)
4254 
    iprot.readMessageEnd()
2981 rajveer 4255 
    result = deleteItemFromMyResearch_result()
4256 
    try:
4257 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4258 
    except WidgetException, scx:
4259 
      result.scx = scx
4260 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4261 
    result.write(oprot)
4262 
    oprot.writeMessageEnd()
4263 
    oprot.trans.flush()
772 rajveer 4264 
 
2981 rajveer 4265 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4266 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4267 
    args.read(iprot)
4268 
    iprot.readMessageEnd()
2981 rajveer 4269 
    result = getBrowseHistoryItems_result()
4270 
    try:
4271 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4272 
    except WidgetException, scx:
4273 
      result.scx = scx
4274 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4275 
    result.write(oprot)
4276 
    oprot.writeMessageEnd()
4277 
    oprot.trans.flush()
1596 ankur.sing 4278 
 
2981 rajveer 4279 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4280 
    args = updateBrowseHistory_args()
2642 varun.gupt 4281 
    args.read(iprot)
4282 
    iprot.readMessageEnd()
2981 rajveer 4283 
    result = updateBrowseHistory_result()
4284 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4285 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
1673 ankur.sing 4289 
 
3385 varun.gupt 4290 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4291 
    args = getCartsWithCouponCount_args()
4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
4294 
    result = getCartsWithCouponCount_result()
4295 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4296 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
2642 varun.gupt 4300 
 
3499 mandeep.dh 4301 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4302 
    args = increaseTrustLevel_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4306 
    return
3385 varun.gupt 4307 
 
5407 amar.kumar 4308 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4309 
    args = getTrustLevel_args()
4310 
    args.read(iprot)
4311 
    iprot.readMessageEnd()
4312 
    result = getTrustLevel_result()
4313 
    result.success = self._handler.getTrustLevel(args.userId)
4314 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4315 
    result.write(oprot)
4316 
    oprot.writeMessageEnd()
4317 
    oprot.trans.flush()
4318 
 
4668 varun.gupt 4319 
  def process_showCODOption(self, seqid, iprot, oprot):
4320 
    args = showCODOption_args()
4321 
    args.read(iprot)
4322 
    iprot.readMessageEnd()
4323 
    result = showCODOption_result()
4324 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4325 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4326 
    result.write(oprot)
4327 
    oprot.writeMessageEnd()
4328 
    oprot.trans.flush()
3499 mandeep.dh 4329 
 
5623 anupam.sin 4330 
  def process_getUserEmails(self, seqid, iprot, oprot):
4331 
    args = getUserEmails_args()
4332 
    args.read(iprot)
4333 
    iprot.readMessageEnd()
4334 
    result = getUserEmails_result()
4335 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4336 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4337 
    result.write(oprot)
4338 
    oprot.writeMessageEnd()
4339 
    oprot.trans.flush()
4668 varun.gupt 4340 
 
6903 anupam.sin 4341 
  def process_insureItem(self, seqid, iprot, oprot):
4342 
    args = insureItem_args()
4343 
    args.read(iprot)
4344 
    iprot.readMessageEnd()
4345 
    result = insureItem_result()
9299 kshitij.so 4346 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4347 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4348 
    result.write(oprot)
4349 
    oprot.writeMessageEnd()
4350 
    oprot.trans.flush()
4351 
 
4352 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4353 
    args = cancelInsurance_args()
4354 
    args.read(iprot)
4355 
    iprot.readMessageEnd()
4356 
    result = cancelInsurance_result()
4357 
    result.success = self._handler.cancelInsurance(args.cartId)
4358 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4359 
    result.write(oprot)
4360 
    oprot.writeMessageEnd()
4361 
    oprot.trans.flush()
4362 
 
4363 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4364 
    args = storeInsuranceSpecificDetails_args()
4365 
    args.read(iprot)
4366 
    iprot.readMessageEnd()
4367 
    result = storeInsuranceSpecificDetails_result()
4368 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4369 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4374 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4375 
    args = isInsuranceDetailPresent_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = isInsuranceDetailPresent_result()
4379 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4380 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
9791 rajveer 4385 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4386 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
9791 rajveer 4389 
    result = getProductsAddedToCart_result()
4390 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4391 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4392 
    result.write(oprot)
4393 
    oprot.writeMessageEnd()
4394 
    oprot.trans.flush()
5623 anupam.sin 4395 
 
11592 amit.gupta 4396 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4397 
    args = validateCartPlus_args()
4398 
    args.read(iprot)
4399 
    iprot.readMessageEnd()
4400 
    result = validateCartPlus_result()
4401 
    try:
11980 amit.gupta 4402 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4403 
    except ShoppingCartException, scex:
4404 
      result.scex = scex
4405 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4406 
    result.write(oprot)
4407 
    oprot.writeMessageEnd()
4408 
    oprot.trans.flush()
6821 amar.kumar 4409 
 
11679 vikram.rag 4410 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4411 
    args = isPrivateDealUser_args()
4412 
    args.read(iprot)
4413 
    iprot.readMessageEnd()
4414 
    result = isPrivateDealUser_result()
4415 
    result.success = self._handler.isPrivateDealUser(args.userId)
4416 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
11592 amit.gupta 4420 
 
11890 kshitij.so 4421 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4422 
    args = addPrivateDealUser_args()
4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
4425 
    result = addPrivateDealUser_result()
4426 
    result.success = self._handler.addPrivateDealUser(args.userId)
4427 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4428 
    result.write(oprot)
4429 
    oprot.writeMessageEnd()
4430 
    oprot.trans.flush()
11679 vikram.rag 4431 
 
11890 kshitij.so 4432 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4433 
    args = changePrivateDealUserStatus_args()
4434 
    args.read(iprot)
4435 
    iprot.readMessageEnd()
4436 
    result = changePrivateDealUserStatus_result()
4437 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4438 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
4442 
 
4443 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4444 
    args = getPrivateDealUser_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = getPrivateDealUser_result()
4448 
    result.success = self._handler.getPrivateDealUser(args.userId)
4449 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4450 
    result.write(oprot)
4451 
    oprot.writeMessageEnd()
4452 
    oprot.trans.flush()
4453 
 
4454 
 
94 ashish 4455 
# HELPER FUNCTIONS AND STRUCTURES
4456 
 
559 chandransh 4457 
class createAnonymousUser_args:
94 ashish 4458 
  """
4459 
  Attributes:
559 chandransh 4460 
   - jsessionId
94 ashish 4461 
  """
4462 
 
4463 
  thrift_spec = (
4464 
    None, # 0
559 chandransh 4465 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4466 
  )
4467 
 
559 chandransh 4468 
  def __init__(self, jsessionId=None,):
4469 
    self.jsessionId = jsessionId
94 ashish 4470 
 
4471 
  def read(self, iprot):
4472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4474 
      return
4475 
    iprot.readStructBegin()
4476 
    while True:
4477 
      (fname, ftype, fid) = iprot.readFieldBegin()
4478 
      if ftype == TType.STOP:
4479 
        break
4480 
      if fid == 1:
559 chandransh 4481 
        if ftype == TType.STRING:
4482 
          self.jsessionId = iprot.readString();
94 ashish 4483 
        else:
4484 
          iprot.skip(ftype)
4485 
      else:
4486 
        iprot.skip(ftype)
4487 
      iprot.readFieldEnd()
4488 
    iprot.readStructEnd()
4489 
 
4490 
  def write(self, oprot):
4491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4493 
      return
559 chandransh 4494 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4495 
    if self.jsessionId is not None:
559 chandransh 4496 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4497 
      oprot.writeString(self.jsessionId)
94 ashish 4498 
      oprot.writeFieldEnd()
4499 
    oprot.writeFieldStop()
4500 
    oprot.writeStructEnd()
4501 
 
3431 rajveer 4502 
  def validate(self):
4503 
    return
4504 
 
4505 
 
94 ashish 4506 
  def __repr__(self):
4507 
    L = ['%s=%r' % (key, value)
4508 
      for key, value in self.__dict__.iteritems()]
4509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4510 
 
4511 
  def __eq__(self, other):
4512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4513 
 
4514 
  def __ne__(self, other):
4515 
    return not (self == other)
4516 
 
559 chandransh 4517 
class createAnonymousUser_result:
94 ashish 4518 
  """
4519 
  Attributes:
4520 
   - success
559 chandransh 4521 
   - ucex
94 ashish 4522 
  """
4523 
 
4524 
  thrift_spec = (
559 chandransh 4525 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4526 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4527 
  )
4528 
 
559 chandransh 4529 
  def __init__(self, success=None, ucex=None,):
94 ashish 4530 
    self.success = success
559 chandransh 4531 
    self.ucex = ucex
94 ashish 4532 
 
4533 
  def read(self, iprot):
4534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4536 
      return
4537 
    iprot.readStructBegin()
4538 
    while True:
4539 
      (fname, ftype, fid) = iprot.readFieldBegin()
4540 
      if ftype == TType.STOP:
4541 
        break
4542 
      if fid == 0:
4543 
        if ftype == TType.STRUCT:
559 chandransh 4544 
          self.success = User()
94 ashish 4545 
          self.success.read(iprot)
4546 
        else:
4547 
          iprot.skip(ftype)
4548 
      elif fid == 1:
4549 
        if ftype == TType.STRUCT:
559 chandransh 4550 
          self.ucex = UserContextException()
4551 
          self.ucex.read(iprot)
94 ashish 4552 
        else:
4553 
          iprot.skip(ftype)
4554 
      else:
4555 
        iprot.skip(ftype)
4556 
      iprot.readFieldEnd()
4557 
    iprot.readStructEnd()
4558 
 
4559 
  def write(self, oprot):
4560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4562 
      return
559 chandransh 4563 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4564 
    if self.success is not None:
94 ashish 4565 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4566 
      self.success.write(oprot)
4567 
      oprot.writeFieldEnd()
3431 rajveer 4568 
    if self.ucex is not None:
559 chandransh 4569 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4570 
      self.ucex.write(oprot)
94 ashish 4571 
      oprot.writeFieldEnd()
4572 
    oprot.writeFieldStop()
4573 
    oprot.writeStructEnd()
4574 
 
3431 rajveer 4575 
  def validate(self):
4576 
    return
4577 
 
4578 
 
94 ashish 4579 
  def __repr__(self):
4580 
    L = ['%s=%r' % (key, value)
4581 
      for key, value in self.__dict__.iteritems()]
4582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4583 
 
4584 
  def __eq__(self, other):
4585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4586 
 
4587 
  def __ne__(self, other):
4588 
    return not (self == other)
4589 
 
559 chandransh 4590 
class getUserById_args:
94 ashish 4591 
  """
4592 
  Attributes:
4593 
   - userId
4594 
  """
4595 
 
4596 
  thrift_spec = (
4597 
    None, # 0
4598 
    (1, TType.I64, 'userId', None, None, ), # 1
4599 
  )
4600 
 
559 chandransh 4601 
  def __init__(self, userId=None,):
94 ashish 4602 
    self.userId = userId
4603 
 
4604 
  def read(self, iprot):
4605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4607 
      return
4608 
    iprot.readStructBegin()
4609 
    while True:
4610 
      (fname, ftype, fid) = iprot.readFieldBegin()
4611 
      if ftype == TType.STOP:
4612 
        break
4613 
      if fid == 1:
4614 
        if ftype == TType.I64:
4615 
          self.userId = iprot.readI64();
4616 
        else:
4617 
          iprot.skip(ftype)
4618 
      else:
4619 
        iprot.skip(ftype)
4620 
      iprot.readFieldEnd()
4621 
    iprot.readStructEnd()
4622 
 
4623 
  def write(self, oprot):
4624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4626 
      return
559 chandransh 4627 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4628 
    if self.userId is not None:
94 ashish 4629 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4630 
      oprot.writeI64(self.userId)
4631 
      oprot.writeFieldEnd()
4632 
    oprot.writeFieldStop()
4633 
    oprot.writeStructEnd()
4634 
 
3431 rajveer 4635 
  def validate(self):
4636 
    return
4637 
 
4638 
 
94 ashish 4639 
  def __repr__(self):
4640 
    L = ['%s=%r' % (key, value)
4641 
      for key, value in self.__dict__.iteritems()]
4642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4643 
 
4644 
  def __eq__(self, other):
4645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4646 
 
4647 
  def __ne__(self, other):
4648 
    return not (self == other)
4649 
 
559 chandransh 4650 
class getUserById_result:
94 ashish 4651 
  """
4652 
  Attributes:
4653 
   - success
559 chandransh 4654 
   - ucex
94 ashish 4655 
  """
4656 
 
4657 
  thrift_spec = (
559 chandransh 4658 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4659 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4660 
  )
4661 
 
559 chandransh 4662 
  def __init__(self, success=None, ucex=None,):
94 ashish 4663 
    self.success = success
559 chandransh 4664 
    self.ucex = ucex
94 ashish 4665 
 
4666 
  def read(self, iprot):
4667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4669 
      return
4670 
    iprot.readStructBegin()
4671 
    while True:
4672 
      (fname, ftype, fid) = iprot.readFieldBegin()
4673 
      if ftype == TType.STOP:
4674 
        break
4675 
      if fid == 0:
4676 
        if ftype == TType.STRUCT:
559 chandransh 4677 
          self.success = User()
94 ashish 4678 
          self.success.read(iprot)
4679 
        else:
4680 
          iprot.skip(ftype)
4681 
      elif fid == 1:
4682 
        if ftype == TType.STRUCT:
559 chandransh 4683 
          self.ucex = UserContextException()
4684 
          self.ucex.read(iprot)
94 ashish 4685 
        else:
4686 
          iprot.skip(ftype)
4687 
      else:
4688 
        iprot.skip(ftype)
4689 
      iprot.readFieldEnd()
4690 
    iprot.readStructEnd()
4691 
 
4692 
  def write(self, oprot):
4693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4695 
      return
559 chandransh 4696 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4697 
    if self.success is not None:
94 ashish 4698 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4699 
      self.success.write(oprot)
4700 
      oprot.writeFieldEnd()
3431 rajveer 4701 
    if self.ucex is not None:
559 chandransh 4702 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4703 
      self.ucex.write(oprot)
94 ashish 4704 
      oprot.writeFieldEnd()
4705 
    oprot.writeFieldStop()
4706 
    oprot.writeStructEnd()
4707 
 
3431 rajveer 4708 
  def validate(self):
4709 
    return
4710 
 
4711 
 
94 ashish 4712 
  def __repr__(self):
4713 
    L = ['%s=%r' % (key, value)
4714 
      for key, value in self.__dict__.iteritems()]
4715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4716 
 
4717 
  def __eq__(self, other):
4718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4719 
 
4720 
  def __ne__(self, other):
4721 
    return not (self == other)
4722 
 
5326 rajveer 4723 
class getUserByCartId_args:
1491 vikas 4724 
  """
4725 
  Attributes:
5326 rajveer 4726 
   - cartId
1491 vikas 4727 
  """
4728 
 
4729 
  thrift_spec = (
4730 
    None, # 0
5326 rajveer 4731 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4732 
  )
4733 
 
5326 rajveer 4734 
  def __init__(self, cartId=None,):
4735 
    self.cartId = cartId
1491 vikas 4736 
 
4737 
  def read(self, iprot):
4738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4740 
      return
4741 
    iprot.readStructBegin()
4742 
    while True:
4743 
      (fname, ftype, fid) = iprot.readFieldBegin()
4744 
      if ftype == TType.STOP:
4745 
        break
4746 
      if fid == 1:
5326 rajveer 4747 
        if ftype == TType.I64:
4748 
          self.cartId = iprot.readI64();
1491 vikas 4749 
        else:
4750 
          iprot.skip(ftype)
4751 
      else:
4752 
        iprot.skip(ftype)
4753 
      iprot.readFieldEnd()
4754 
    iprot.readStructEnd()
4755 
 
4756 
  def write(self, oprot):
4757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4759 
      return
5326 rajveer 4760 
    oprot.writeStructBegin('getUserByCartId_args')
4761 
    if self.cartId is not None:
4762 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4763 
      oprot.writeI64(self.cartId)
1491 vikas 4764 
      oprot.writeFieldEnd()
4765 
    oprot.writeFieldStop()
4766 
    oprot.writeStructEnd()
4767 
 
3431 rajveer 4768 
  def validate(self):
4769 
    return
4770 
 
4771 
 
1491 vikas 4772 
  def __repr__(self):
4773 
    L = ['%s=%r' % (key, value)
4774 
      for key, value in self.__dict__.iteritems()]
4775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4776 
 
4777 
  def __eq__(self, other):
4778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4779 
 
4780 
  def __ne__(self, other):
4781 
    return not (self == other)
4782 
 
5326 rajveer 4783 
class getUserByCartId_result:
1491 vikas 4784 
  """
4785 
  Attributes:
4786 
   - success
4787 
   - ucex
4788 
  """
4789 
 
4790 
  thrift_spec = (
4791 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4792 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4793 
  )
4794 
 
4795 
  def __init__(self, success=None, ucex=None,):
4796 
    self.success = success
4797 
    self.ucex = ucex
4798 
 
4799 
  def read(self, iprot):
4800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4802 
      return
4803 
    iprot.readStructBegin()
4804 
    while True:
4805 
      (fname, ftype, fid) = iprot.readFieldBegin()
4806 
      if ftype == TType.STOP:
4807 
        break
4808 
      if fid == 0:
4809 
        if ftype == TType.STRUCT:
4810 
          self.success = User()
4811 
          self.success.read(iprot)
4812 
        else:
4813 
          iprot.skip(ftype)
4814 
      elif fid == 1:
4815 
        if ftype == TType.STRUCT:
4816 
          self.ucex = UserContextException()
4817 
          self.ucex.read(iprot)
4818 
        else:
4819 
          iprot.skip(ftype)
4820 
      else:
4821 
        iprot.skip(ftype)
4822 
      iprot.readFieldEnd()
4823 
    iprot.readStructEnd()
4824 
 
4825 
  def write(self, oprot):
4826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4828 
      return
5326 rajveer 4829 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 4830 
    if self.success is not None:
1491 vikas 4831 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4832 
      self.success.write(oprot)
4833 
      oprot.writeFieldEnd()
3431 rajveer 4834 
    if self.ucex is not None:
1491 vikas 4835 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4836 
      self.ucex.write(oprot)
4837 
      oprot.writeFieldEnd()
4838 
    oprot.writeFieldStop()
4839 
    oprot.writeStructEnd()
4840 
 
3431 rajveer 4841 
  def validate(self):
4842 
    return
4843 
 
4844 
 
1491 vikas 4845 
  def __repr__(self):
4846 
    L = ['%s=%r' % (key, value)
4847 
      for key, value in self.__dict__.iteritems()]
4848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4849 
 
4850 
  def __eq__(self, other):
4851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4852 
 
4853 
  def __ne__(self, other):
4854 
    return not (self == other)
4855 
 
5326 rajveer 4856 
class getUserByEmail_args:
3032 mandeep.dh 4857 
  """
4858 
  Attributes:
5326 rajveer 4859 
   - email
3032 mandeep.dh 4860 
  """
4861 
 
4862 
  thrift_spec = (
4863 
    None, # 0
5326 rajveer 4864 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 4865 
  )
4866 
 
5326 rajveer 4867 
  def __init__(self, email=None,):
4868 
    self.email = email
3032 mandeep.dh 4869 
 
4870 
  def read(self, iprot):
4871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4873 
      return
4874 
    iprot.readStructBegin()
4875 
    while True:
4876 
      (fname, ftype, fid) = iprot.readFieldBegin()
4877 
      if ftype == TType.STOP:
4878 
        break
4879 
      if fid == 1:
5326 rajveer 4880 
        if ftype == TType.STRING:
4881 
          self.email = iprot.readString();
3032 mandeep.dh 4882 
        else:
4883 
          iprot.skip(ftype)
4884 
      else:
4885 
        iprot.skip(ftype)
4886 
      iprot.readFieldEnd()
4887 
    iprot.readStructEnd()
4888 
 
4889 
  def write(self, oprot):
4890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4892 
      return
5326 rajveer 4893 
    oprot.writeStructBegin('getUserByEmail_args')
4894 
    if self.email is not None:
4895 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4896 
      oprot.writeString(self.email)
3032 mandeep.dh 4897 
      oprot.writeFieldEnd()
4898 
    oprot.writeFieldStop()
4899 
    oprot.writeStructEnd()
4900 
 
3431 rajveer 4901 
  def validate(self):
4902 
    return
4903 
 
4904 
 
3032 mandeep.dh 4905 
  def __repr__(self):
4906 
    L = ['%s=%r' % (key, value)
4907 
      for key, value in self.__dict__.iteritems()]
4908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4909 
 
4910 
  def __eq__(self, other):
4911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4912 
 
4913 
  def __ne__(self, other):
4914 
    return not (self == other)
4915 
 
5326 rajveer 4916 
class getUserByEmail_result:
3032 mandeep.dh 4917 
  """
4918 
  Attributes:
4919 
   - success
4920 
   - ucex
4921 
  """
4922 
 
4923 
  thrift_spec = (
4924 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4925 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4926 
  )
4927 
 
4928 
  def __init__(self, success=None, ucex=None,):
4929 
    self.success = success
4930 
    self.ucex = ucex
4931 
 
4932 
  def read(self, iprot):
4933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4935 
      return
4936 
    iprot.readStructBegin()
4937 
    while True:
4938 
      (fname, ftype, fid) = iprot.readFieldBegin()
4939 
      if ftype == TType.STOP:
4940 
        break
4941 
      if fid == 0:
4942 
        if ftype == TType.STRUCT:
4943 
          self.success = User()
4944 
          self.success.read(iprot)
4945 
        else:
4946 
          iprot.skip(ftype)
4947 
      elif fid == 1:
4948 
        if ftype == TType.STRUCT:
4949 
          self.ucex = UserContextException()
4950 
          self.ucex.read(iprot)
4951 
        else:
4952 
          iprot.skip(ftype)
4953 
      else:
4954 
        iprot.skip(ftype)
4955 
      iprot.readFieldEnd()
4956 
    iprot.readStructEnd()
4957 
 
4958 
  def write(self, oprot):
4959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4961 
      return
5326 rajveer 4962 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 4963 
    if self.success is not None:
3032 mandeep.dh 4964 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4965 
      self.success.write(oprot)
4966 
      oprot.writeFieldEnd()
3431 rajveer 4967 
    if self.ucex is not None:
3032 mandeep.dh 4968 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4969 
      self.ucex.write(oprot)
4970 
      oprot.writeFieldEnd()
4971 
    oprot.writeFieldStop()
4972 
    oprot.writeStructEnd()
4973 
 
3431 rajveer 4974 
  def validate(self):
4975 
    return
4976 
 
4977 
 
3032 mandeep.dh 4978 
  def __repr__(self):
4979 
    L = ['%s=%r' % (key, value)
4980 
      for key, value in self.__dict__.iteritems()]
4981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4982 
 
4983 
  def __eq__(self, other):
4984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4985 
 
4986 
  def __ne__(self, other):
4987 
    return not (self == other)
4988 
 
5326 rajveer 4989 
class getUserByMobileNumber_args:
94 ashish 4990 
  """
4991 
  Attributes:
5326 rajveer 4992 
   - mobileNumber
94 ashish 4993 
  """
4994 
 
4995 
  thrift_spec = (
4996 
    None, # 0
5326 rajveer 4997 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 4998 
  )
4999 
 
5326 rajveer 5000 
  def __init__(self, mobileNumber=None,):
5001 
    self.mobileNumber = mobileNumber
94 ashish 5002 
 
5003 
  def read(self, iprot):
5004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5006 
      return
5007 
    iprot.readStructBegin()
5008 
    while True:
5009 
      (fname, ftype, fid) = iprot.readFieldBegin()
5010 
      if ftype == TType.STOP:
5011 
        break
5012 
      if fid == 1:
5326 rajveer 5013 
        if ftype == TType.I64:
5014 
          self.mobileNumber = iprot.readI64();
94 ashish 5015 
        else:
5016 
          iprot.skip(ftype)
5017 
      else:
5018 
        iprot.skip(ftype)
5019 
      iprot.readFieldEnd()
5020 
    iprot.readStructEnd()
5021 
 
5022 
  def write(self, oprot):
5023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5025 
      return
5326 rajveer 5026 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5027 
    if self.mobileNumber is not None:
5028 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5029 
      oprot.writeI64(self.mobileNumber)
94 ashish 5030 
      oprot.writeFieldEnd()
5031 
    oprot.writeFieldStop()
5032 
    oprot.writeStructEnd()
5033 
 
3431 rajveer 5034 
  def validate(self):
5035 
    return
5036 
 
5037 
 
94 ashish 5038 
  def __repr__(self):
5039 
    L = ['%s=%r' % (key, value)
5040 
      for key, value in self.__dict__.iteritems()]
5041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5042 
 
5043 
  def __eq__(self, other):
5044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5045 
 
5046 
  def __ne__(self, other):
5047 
    return not (self == other)
5048 
 
5326 rajveer 5049 
class getUserByMobileNumber_result:
94 ashish 5050 
  """
5051 
  Attributes:
5052 
   - success
559 chandransh 5053 
   - ucex
94 ashish 5054 
  """
5055 
 
5056 
  thrift_spec = (
559 chandransh 5057 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5058 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5059 
  )
5060 
 
559 chandransh 5061 
  def __init__(self, success=None, ucex=None,):
94 ashish 5062 
    self.success = success
559 chandransh 5063 
    self.ucex = ucex
94 ashish 5064 
 
5065 
  def read(self, iprot):
5066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5068 
      return
5069 
    iprot.readStructBegin()
5070 
    while True:
5071 
      (fname, ftype, fid) = iprot.readFieldBegin()
5072 
      if ftype == TType.STOP:
5073 
        break
5074 
      if fid == 0:
5075 
        if ftype == TType.STRUCT:
559 chandransh 5076 
          self.success = User()
94 ashish 5077 
          self.success.read(iprot)
5078 
        else:
5079 
          iprot.skip(ftype)
5080 
      elif fid == 1:
5081 
        if ftype == TType.STRUCT:
559 chandransh 5082 
          self.ucex = UserContextException()
5083 
          self.ucex.read(iprot)
94 ashish 5084 
        else:
5085 
          iprot.skip(ftype)
5086 
      else:
5087 
        iprot.skip(ftype)
5088 
      iprot.readFieldEnd()
5089 
    iprot.readStructEnd()
5090 
 
5091 
  def write(self, oprot):
5092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5094 
      return
5326 rajveer 5095 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5096 
    if self.success is not None:
94 ashish 5097 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5098 
      self.success.write(oprot)
5099 
      oprot.writeFieldEnd()
3431 rajveer 5100 
    if self.ucex is not None:
559 chandransh 5101 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5102 
      self.ucex.write(oprot)
94 ashish 5103 
      oprot.writeFieldEnd()
5104 
    oprot.writeFieldStop()
5105 
    oprot.writeStructEnd()
5106 
 
3431 rajveer 5107 
  def validate(self):
5108 
    return
5109 
 
5110 
 
94 ashish 5111 
  def __repr__(self):
5112 
    L = ['%s=%r' % (key, value)
5113 
      for key, value in self.__dict__.iteritems()]
5114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5115 
 
5116 
  def __eq__(self, other):
5117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5118 
 
5119 
  def __ne__(self, other):
5120 
    return not (self == other)
5121 
 
5326 rajveer 5122 
class createUser_args:
94 ashish 5123 
  """
5124 
  Attributes:
559 chandransh 5125 
   - user
94 ashish 5126 
  """
5127 
 
5128 
  thrift_spec = (
5129 
    None, # 0
559 chandransh 5130 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5131 
  )
5132 
 
559 chandransh 5133 
  def __init__(self, user=None,):
5134 
    self.user = user
94 ashish 5135 
 
5136 
  def read(self, iprot):
5137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5139 
      return
5140 
    iprot.readStructBegin()
5141 
    while True:
5142 
      (fname, ftype, fid) = iprot.readFieldBegin()
5143 
      if ftype == TType.STOP:
5144 
        break
5145 
      if fid == 1:
559 chandransh 5146 
        if ftype == TType.STRUCT:
5147 
          self.user = User()
5148 
          self.user.read(iprot)
94 ashish 5149 
        else:
5150 
          iprot.skip(ftype)
5151 
      else:
5152 
        iprot.skip(ftype)
5153 
      iprot.readFieldEnd()
5154 
    iprot.readStructEnd()
5155 
 
5156 
  def write(self, oprot):
5157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5159 
      return
5326 rajveer 5160 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5161 
    if self.user is not None:
559 chandransh 5162 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5163 
      self.user.write(oprot)
94 ashish 5164 
      oprot.writeFieldEnd()
5165 
    oprot.writeFieldStop()
5166 
    oprot.writeStructEnd()
5167 
 
3431 rajveer 5168 
  def validate(self):
5169 
    return
5170 
 
5171 
 
94 ashish 5172 
  def __repr__(self):
5173 
    L = ['%s=%r' % (key, value)
5174 
      for key, value in self.__dict__.iteritems()]
5175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5176 
 
5177 
  def __eq__(self, other):
5178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5179 
 
5180 
  def __ne__(self, other):
5181 
    return not (self == other)
5182 
 
5326 rajveer 5183 
class createUser_result:
94 ashish 5184 
  """
5185 
  Attributes:
5186 
   - success
559 chandransh 5187 
   - ucex
94 ashish 5188 
  """
5189 
 
5190 
  thrift_spec = (
559 chandransh 5191 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5192 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5193 
  )
5194 
 
559 chandransh 5195 
  def __init__(self, success=None, ucex=None,):
94 ashish 5196 
    self.success = success
559 chandransh 5197 
    self.ucex = ucex
94 ashish 5198 
 
5199 
  def read(self, iprot):
5200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5202 
      return
5203 
    iprot.readStructBegin()
5204 
    while True:
5205 
      (fname, ftype, fid) = iprot.readFieldBegin()
5206 
      if ftype == TType.STOP:
5207 
        break
5208 
      if fid == 0:
5209 
        if ftype == TType.STRUCT:
559 chandransh 5210 
          self.success = User()
94 ashish 5211 
          self.success.read(iprot)
5212 
        else:
5213 
          iprot.skip(ftype)
5214 
      elif fid == 1:
5215 
        if ftype == TType.STRUCT:
559 chandransh 5216 
          self.ucex = UserContextException()
5217 
          self.ucex.read(iprot)
94 ashish 5218 
        else:
5219 
          iprot.skip(ftype)
5220 
      else:
5221 
        iprot.skip(ftype)
5222 
      iprot.readFieldEnd()
5223 
    iprot.readStructEnd()
5224 
 
5225 
  def write(self, oprot):
5226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5228 
      return
5326 rajveer 5229 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5230 
    if self.success is not None:
94 ashish 5231 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5232 
      self.success.write(oprot)
5233 
      oprot.writeFieldEnd()
3431 rajveer 5234 
    if self.ucex is not None:
559 chandransh 5235 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5236 
      self.ucex.write(oprot)
94 ashish 5237 
      oprot.writeFieldEnd()
5238 
    oprot.writeFieldStop()
5239 
    oprot.writeStructEnd()
5240 
 
3431 rajveer 5241 
  def validate(self):
5242 
    return
5243 
 
5244 
 
94 ashish 5245 
  def __repr__(self):
5246 
    L = ['%s=%r' % (key, value)
5247 
      for key, value in self.__dict__.iteritems()]
5248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5249 
 
5250 
  def __eq__(self, other):
5251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5252 
 
5253 
  def __ne__(self, other):
5254 
    return not (self == other)
5255 
 
5326 rajveer 5256 
class updateUser_args:
94 ashish 5257 
  """
5258 
  Attributes:
5326 rajveer 5259 
   - user
94 ashish 5260 
  """
5261 
 
5262 
  thrift_spec = (
5263 
    None, # 0
5326 rajveer 5264 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5265 
  )
5266 
 
5326 rajveer 5267 
  def __init__(self, user=None,):
5268 
    self.user = user
94 ashish 5269 
 
5270 
  def read(self, iprot):
5271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5273 
      return
5274 
    iprot.readStructBegin()
5275 
    while True:
5276 
      (fname, ftype, fid) = iprot.readFieldBegin()
5277 
      if ftype == TType.STOP:
5278 
        break
5279 
      if fid == 1:
5326 rajveer 5280 
        if ftype == TType.STRUCT:
5281 
          self.user = User()
5282 
          self.user.read(iprot)
94 ashish 5283 
        else:
5284 
          iprot.skip(ftype)
5285 
      else:
5286 
        iprot.skip(ftype)
5287 
      iprot.readFieldEnd()
5288 
    iprot.readStructEnd()
5289 
 
5290 
  def write(self, oprot):
5291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5293 
      return
5326 rajveer 5294 
    oprot.writeStructBegin('updateUser_args')
5295 
    if self.user is not None:
5296 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5297 
      self.user.write(oprot)
94 ashish 5298 
      oprot.writeFieldEnd()
5299 
    oprot.writeFieldStop()
5300 
    oprot.writeStructEnd()
5301 
 
3431 rajveer 5302 
  def validate(self):
5303 
    return
5304 
 
5305 
 
94 ashish 5306 
  def __repr__(self):
5307 
    L = ['%s=%r' % (key, value)
5308 
      for key, value in self.__dict__.iteritems()]
5309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5310 
 
5311 
  def __eq__(self, other):
5312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5313 
 
5314 
  def __ne__(self, other):
5315 
    return not (self == other)
5316 
 
5326 rajveer 5317 
class updateUser_result:
94 ashish 5318 
  """
5319 
  Attributes:
5320 
   - success
559 chandransh 5321 
   - ucex
94 ashish 5322 
  """
5323 
 
5324 
  thrift_spec = (
5326 rajveer 5325 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5326 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5327 
  )
5328 
 
559 chandransh 5329 
  def __init__(self, success=None, ucex=None,):
94 ashish 5330 
    self.success = success
559 chandransh 5331 
    self.ucex = ucex
94 ashish 5332 
 
5333 
  def read(self, iprot):
5334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5336 
      return
5337 
    iprot.readStructBegin()
5338 
    while True:
5339 
      (fname, ftype, fid) = iprot.readFieldBegin()
5340 
      if ftype == TType.STOP:
5341 
        break
5342 
      if fid == 0:
5326 rajveer 5343 
        if ftype == TType.STRUCT:
5344 
          self.success = User()
5345 
          self.success.read(iprot)
94 ashish 5346 
        else:
5347 
          iprot.skip(ftype)
5348 
      elif fid == 1:
5349 
        if ftype == TType.STRUCT:
559 chandransh 5350 
          self.ucex = UserContextException()
5351 
          self.ucex.read(iprot)
94 ashish 5352 
        else:
5353 
          iprot.skip(ftype)
5354 
      else:
5355 
        iprot.skip(ftype)
5356 
      iprot.readFieldEnd()
5357 
    iprot.readStructEnd()
5358 
 
5359 
  def write(self, oprot):
5360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5362 
      return
5326 rajveer 5363 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5364 
    if self.success is not None:
5326 rajveer 5365 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5366 
      self.success.write(oprot)
94 ashish 5367 
      oprot.writeFieldEnd()
3431 rajveer 5368 
    if self.ucex is not None:
559 chandransh 5369 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5370 
      self.ucex.write(oprot)
94 ashish 5371 
      oprot.writeFieldEnd()
5372 
    oprot.writeFieldStop()
5373 
    oprot.writeStructEnd()
5374 
 
3431 rajveer 5375 
  def validate(self):
5376 
    return
5377 
 
5378 
 
94 ashish 5379 
  def __repr__(self):
5380 
    L = ['%s=%r' % (key, value)
5381 
      for key, value in self.__dict__.iteritems()]
5382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5383 
 
5384 
  def __eq__(self, other):
5385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5386 
 
5387 
  def __ne__(self, other):
5388 
    return not (self == other)
5389 
 
559 chandransh 5390 
class authenticateUser_args:
94 ashish 5391 
  """
5392 
  Attributes:
5393 
   - email
5394 
   - password
5395 
  """
5396 
 
5397 
  thrift_spec = (
5398 
    None, # 0
5399 
    (1, TType.STRING, 'email', None, None, ), # 1
5400 
    (2, TType.STRING, 'password', None, None, ), # 2
5401 
  )
5402 
 
5403 
  def __init__(self, email=None, password=None,):
5404 
    self.email = email
5405 
    self.password = password
5406 
 
5407 
  def read(self, iprot):
5408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5410 
      return
5411 
    iprot.readStructBegin()
5412 
    while True:
5413 
      (fname, ftype, fid) = iprot.readFieldBegin()
5414 
      if ftype == TType.STOP:
5415 
        break
5416 
      if fid == 1:
5417 
        if ftype == TType.STRING:
5418 
          self.email = iprot.readString();
5419 
        else:
5420 
          iprot.skip(ftype)
5421 
      elif fid == 2:
5422 
        if ftype == TType.STRING:
5423 
          self.password = iprot.readString();
5424 
        else:
5425 
          iprot.skip(ftype)
5426 
      else:
5427 
        iprot.skip(ftype)
5428 
      iprot.readFieldEnd()
5429 
    iprot.readStructEnd()
5430 
 
5431 
  def write(self, oprot):
5432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5434 
      return
559 chandransh 5435 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5436 
    if self.email is not None:
94 ashish 5437 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5438 
      oprot.writeString(self.email)
5439 
      oprot.writeFieldEnd()
3431 rajveer 5440 
    if self.password is not None:
94 ashish 5441 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5442 
      oprot.writeString(self.password)
5443 
      oprot.writeFieldEnd()
5444 
    oprot.writeFieldStop()
5445 
    oprot.writeStructEnd()
5446 
 
3431 rajveer 5447 
  def validate(self):
5448 
    return
5449 
 
5450 
 
94 ashish 5451 
  def __repr__(self):
5452 
    L = ['%s=%r' % (key, value)
5453 
      for key, value in self.__dict__.iteritems()]
5454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5455 
 
5456 
  def __eq__(self, other):
5457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5458 
 
5459 
  def __ne__(self, other):
5460 
    return not (self == other)
5461 
 
559 chandransh 5462 
class authenticateUser_result:
94 ashish 5463 
  """
5464 
  Attributes:
5465 
   - success
559 chandransh 5466 
   - auex
94 ashish 5467 
  """
5468 
 
5469 
  thrift_spec = (
559 chandransh 5470 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5471 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5472 
  )
5473 
 
559 chandransh 5474 
  def __init__(self, success=None, auex=None,):
94 ashish 5475 
    self.success = success
559 chandransh 5476 
    self.auex = auex
94 ashish 5477 
 
5478 
  def read(self, iprot):
5479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5481 
      return
5482 
    iprot.readStructBegin()
5483 
    while True:
5484 
      (fname, ftype, fid) = iprot.readFieldBegin()
5485 
      if ftype == TType.STOP:
5486 
        break
5487 
      if fid == 0:
5488 
        if ftype == TType.STRUCT:
559 chandransh 5489 
          self.success = User()
94 ashish 5490 
          self.success.read(iprot)
5491 
        else:
5492 
          iprot.skip(ftype)
5493 
      elif fid == 1:
5494 
        if ftype == TType.STRUCT:
559 chandransh 5495 
          self.auex = AuthenticationException()
5496 
          self.auex.read(iprot)
94 ashish 5497 
        else:
5498 
          iprot.skip(ftype)
5499 
      else:
5500 
        iprot.skip(ftype)
5501 
      iprot.readFieldEnd()
5502 
    iprot.readStructEnd()
5503 
 
5504 
  def write(self, oprot):
5505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5507 
      return
559 chandransh 5508 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5509 
    if self.success is not None:
94 ashish 5510 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5511 
      self.success.write(oprot)
5512 
      oprot.writeFieldEnd()
3431 rajveer 5513 
    if self.auex is not None:
559 chandransh 5514 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5515 
      self.auex.write(oprot)
94 ashish 5516 
      oprot.writeFieldEnd()
5517 
    oprot.writeFieldStop()
5518 
    oprot.writeStructEnd()
5519 
 
3431 rajveer 5520 
  def validate(self):
5521 
    return
5522 
 
5523 
 
94 ashish 5524 
  def __repr__(self):
5525 
    L = ['%s=%r' % (key, value)
5526 
      for key, value in self.__dict__.iteritems()]
5527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5528 
 
5529 
  def __eq__(self, other):
5530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5531 
 
5532 
  def __ne__(self, other):
5533 
    return not (self == other)
5534 
 
559 chandransh 5535 
class userExists_args:
122 ashish 5536 
  """
5537 
  Attributes:
559 chandransh 5538 
   - email
122 ashish 5539 
  """
5540 
 
5541 
  thrift_spec = (
5542 
    None, # 0
559 chandransh 5543 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5544 
  )
5545 
 
559 chandransh 5546 
  def __init__(self, email=None,):
5547 
    self.email = email
122 ashish 5548 
 
5549 
  def read(self, iprot):
5550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5552 
      return
5553 
    iprot.readStructBegin()
5554 
    while True:
5555 
      (fname, ftype, fid) = iprot.readFieldBegin()
5556 
      if ftype == TType.STOP:
5557 
        break
5558 
      if fid == 1:
5559 
        if ftype == TType.STRING:
559 chandransh 5560 
          self.email = iprot.readString();
122 ashish 5561 
        else:
5562 
          iprot.skip(ftype)
559 chandransh 5563 
      else:
5564 
        iprot.skip(ftype)
5565 
      iprot.readFieldEnd()
5566 
    iprot.readStructEnd()
5567 
 
5568 
  def write(self, oprot):
5569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5571 
      return
5572 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5573 
    if self.email is not None:
559 chandransh 5574 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5575 
      oprot.writeString(self.email)
5576 
      oprot.writeFieldEnd()
5577 
    oprot.writeFieldStop()
5578 
    oprot.writeStructEnd()
5579 
 
3431 rajveer 5580 
  def validate(self):
5581 
    return
5582 
 
5583 
 
559 chandransh 5584 
  def __repr__(self):
5585 
    L = ['%s=%r' % (key, value)
5586 
      for key, value in self.__dict__.iteritems()]
5587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5588 
 
5589 
  def __eq__(self, other):
5590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5591 
 
5592 
  def __ne__(self, other):
5593 
    return not (self == other)
5594 
 
5595 
class userExists_result:
5596 
  """
5597 
  Attributes:
5598 
   - success
5599 
   - ucx
5600 
  """
5601 
 
5602 
  thrift_spec = (
5603 
    (0, TType.BOOL, 'success', None, None, ), # 0
5604 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5605 
  )
5606 
 
5607 
  def __init__(self, success=None, ucx=None,):
5608 
    self.success = success
5609 
    self.ucx = ucx
5610 
 
5611 
  def read(self, iprot):
5612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5614 
      return
5615 
    iprot.readStructBegin()
5616 
    while True:
5617 
      (fname, ftype, fid) = iprot.readFieldBegin()
5618 
      if ftype == TType.STOP:
5619 
        break
5620 
      if fid == 0:
5621 
        if ftype == TType.BOOL:
5622 
          self.success = iprot.readBool();
5623 
        else:
5624 
          iprot.skip(ftype)
5625 
      elif fid == 1:
5626 
        if ftype == TType.STRUCT:
5627 
          self.ucx = UserContextException()
5628 
          self.ucx.read(iprot)
5629 
        else:
5630 
          iprot.skip(ftype)
5631 
      else:
5632 
        iprot.skip(ftype)
5633 
      iprot.readFieldEnd()
5634 
    iprot.readStructEnd()
5635 
 
5636 
  def write(self, oprot):
5637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5639 
      return
5640 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5641 
    if self.success is not None:
559 chandransh 5642 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5643 
      oprot.writeBool(self.success)
5644 
      oprot.writeFieldEnd()
3431 rajveer 5645 
    if self.ucx is not None:
559 chandransh 5646 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5647 
      self.ucx.write(oprot)
5648 
      oprot.writeFieldEnd()
5649 
    oprot.writeFieldStop()
5650 
    oprot.writeStructEnd()
5651 
 
3431 rajveer 5652 
  def validate(self):
5653 
    return
5654 
 
5655 
 
559 chandransh 5656 
  def __repr__(self):
5657 
    L = ['%s=%r' % (key, value)
5658 
      for key, value in self.__dict__.iteritems()]
5659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5660 
 
5661 
  def __eq__(self, other):
5662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5663 
 
5664 
  def __ne__(self, other):
5665 
    return not (self == other)
5666 
 
5667 
class addAddressForUser_args:
5668 
  """
5669 
  Attributes:
5670 
   - userId
5671 
   - address
5672 
   - setDefault
5673 
  """
5674 
 
5675 
  thrift_spec = (
5676 
    None, # 0
5677 
    (1, TType.I64, 'userId', None, None, ), # 1
5678 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5679 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5680 
  )
5681 
 
567 rajveer 5682 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5683 
    self.userId = userId
5684 
    self.address = address
5685 
    self.setDefault = setDefault
5686 
 
5687 
  def read(self, iprot):
5688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5690 
      return
5691 
    iprot.readStructBegin()
5692 
    while True:
5693 
      (fname, ftype, fid) = iprot.readFieldBegin()
5694 
      if ftype == TType.STOP:
5695 
        break
5696 
      if fid == 1:
5697 
        if ftype == TType.I64:
5698 
          self.userId = iprot.readI64();
5699 
        else:
5700 
          iprot.skip(ftype)
122 ashish 5701 
      elif fid == 2:
559 chandransh 5702 
        if ftype == TType.STRUCT:
5703 
          self.address = Address()
5704 
          self.address.read(iprot)
122 ashish 5705 
        else:
5706 
          iprot.skip(ftype)
5707 
      elif fid == 3:
5708 
        if ftype == TType.BOOL:
559 chandransh 5709 
          self.setDefault = iprot.readBool();
122 ashish 5710 
        else:
5711 
          iprot.skip(ftype)
5712 
      else:
5713 
        iprot.skip(ftype)
5714 
      iprot.readFieldEnd()
5715 
    iprot.readStructEnd()
5716 
 
5717 
  def write(self, oprot):
5718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5720 
      return
559 chandransh 5721 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5722 
    if self.userId is not None:
559 chandransh 5723 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5724 
      oprot.writeI64(self.userId)
122 ashish 5725 
      oprot.writeFieldEnd()
3431 rajveer 5726 
    if self.address is not None:
559 chandransh 5727 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5728 
      self.address.write(oprot)
122 ashish 5729 
      oprot.writeFieldEnd()
3431 rajveer 5730 
    if self.setDefault is not None:
567 rajveer 5731 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5732 
      oprot.writeBool(self.setDefault)
5733 
      oprot.writeFieldEnd()
122 ashish 5734 
    oprot.writeFieldStop()
5735 
    oprot.writeStructEnd()
5736 
 
3431 rajveer 5737 
  def validate(self):
5738 
    return
5739 
 
5740 
 
122 ashish 5741 
  def __repr__(self):
5742 
    L = ['%s=%r' % (key, value)
5743 
      for key, value in self.__dict__.iteritems()]
5744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5745 
 
5746 
  def __eq__(self, other):
5747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5748 
 
5749 
  def __ne__(self, other):
5750 
    return not (self == other)
5751 
 
559 chandransh 5752 
class addAddressForUser_result:
122 ashish 5753 
  """
5754 
  Attributes:
5755 
   - success
559 chandransh 5756 
   - ucx
122 ashish 5757 
  """
5758 
 
5759 
  thrift_spec = (
567 rajveer 5760 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5761 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5762 
  )
5763 
 
559 chandransh 5764 
  def __init__(self, success=None, ucx=None,):
122 ashish 5765 
    self.success = success
559 chandransh 5766 
    self.ucx = ucx
122 ashish 5767 
 
5768 
  def read(self, iprot):
5769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5771 
      return
5772 
    iprot.readStructBegin()
5773 
    while True:
5774 
      (fname, ftype, fid) = iprot.readFieldBegin()
5775 
      if ftype == TType.STOP:
5776 
        break
5777 
      if fid == 0:
567 rajveer 5778 
        if ftype == TType.I64:
5779 
          self.success = iprot.readI64();
122 ashish 5780 
        else:
5781 
          iprot.skip(ftype)
5782 
      elif fid == 1:
5783 
        if ftype == TType.STRUCT:
559 chandransh 5784 
          self.ucx = UserContextException()
5785 
          self.ucx.read(iprot)
122 ashish 5786 
        else:
5787 
          iprot.skip(ftype)
5788 
      else:
5789 
        iprot.skip(ftype)
5790 
      iprot.readFieldEnd()
5791 
    iprot.readStructEnd()
5792 
 
5793 
  def write(self, oprot):
5794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5796 
      return
559 chandransh 5797 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 5798 
    if self.success is not None:
567 rajveer 5799 
      oprot.writeFieldBegin('success', TType.I64, 0)
5800 
      oprot.writeI64(self.success)
122 ashish 5801 
      oprot.writeFieldEnd()
3431 rajveer 5802 
    if self.ucx is not None:
559 chandransh 5803 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5804 
      self.ucx.write(oprot)
122 ashish 5805 
      oprot.writeFieldEnd()
5806 
    oprot.writeFieldStop()
5807 
    oprot.writeStructEnd()
5808 
 
3431 rajveer 5809 
  def validate(self):
5810 
    return
5811 
 
5812 
 
122 ashish 5813 
  def __repr__(self):
5814 
    L = ['%s=%r' % (key, value)
5815 
      for key, value in self.__dict__.iteritems()]
5816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5817 
 
5818 
  def __eq__(self, other):
5819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5820 
 
5821 
  def __ne__(self, other):
5822 
    return not (self == other)
5823 
 
559 chandransh 5824 
class removeAddressForUser_args:
94 ashish 5825 
  """
5826 
  Attributes:
559 chandransh 5827 
   - userid
5828 
   - addressId
94 ashish 5829 
  """
5830 
 
5831 
  thrift_spec = (
5832 
    None, # 0
559 chandransh 5833 
    (1, TType.I64, 'userid', None, None, ), # 1
5834 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5835 
  )
5836 
 
559 chandransh 5837 
  def __init__(self, userid=None, addressId=None,):
5838 
    self.userid = userid
5839 
    self.addressId = addressId
94 ashish 5840 
 
5841 
  def read(self, iprot):
5842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5844 
      return
5845 
    iprot.readStructBegin()
5846 
    while True:
5847 
      (fname, ftype, fid) = iprot.readFieldBegin()
5848 
      if ftype == TType.STOP:
5849 
        break
5850 
      if fid == 1:
559 chandransh 5851 
        if ftype == TType.I64:
5852 
          self.userid = iprot.readI64();
94 ashish 5853 
        else:
5854 
          iprot.skip(ftype)
559 chandransh 5855 
      elif fid == 2:
5856 
        if ftype == TType.I64:
5857 
          self.addressId = iprot.readI64();
5858 
        else:
5859 
          iprot.skip(ftype)
94 ashish 5860 
      else:
5861 
        iprot.skip(ftype)
5862 
      iprot.readFieldEnd()
5863 
    iprot.readStructEnd()
5864 
 
5865 
  def write(self, oprot):
5866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5868 
      return
559 chandransh 5869 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 5870 
    if self.userid is not None:
559 chandransh 5871 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5872 
      oprot.writeI64(self.userid)
94 ashish 5873 
      oprot.writeFieldEnd()
3431 rajveer 5874 
    if self.addressId is not None:
559 chandransh 5875 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5876 
      oprot.writeI64(self.addressId)
5877 
      oprot.writeFieldEnd()
94 ashish 5878 
    oprot.writeFieldStop()
5879 
    oprot.writeStructEnd()
5880 
 
3431 rajveer 5881 
  def validate(self):
5882 
    return
5883 
 
5884 
 
94 ashish 5885 
  def __repr__(self):
5886 
    L = ['%s=%r' % (key, value)
5887 
      for key, value in self.__dict__.iteritems()]
5888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5889 
 
5890 
  def __eq__(self, other):
5891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5892 
 
5893 
  def __ne__(self, other):
5894 
    return not (self == other)
5895 
 
559 chandransh 5896 
class removeAddressForUser_result:
94 ashish 5897 
  """
5898 
  Attributes:
5899 
   - success
5900 
   - ucx
5901 
  """
5902 
 
5903 
  thrift_spec = (
5904 
    (0, TType.BOOL, 'success', None, None, ), # 0
5905 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5906 
  )
5907 
 
5908 
  def __init__(self, success=None, ucx=None,):
5909 
    self.success = success
5910 
    self.ucx = ucx
5911 
 
5912 
  def read(self, iprot):
5913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5915 
      return
5916 
    iprot.readStructBegin()
5917 
    while True:
5918 
      (fname, ftype, fid) = iprot.readFieldBegin()
5919 
      if ftype == TType.STOP:
5920 
        break
5921 
      if fid == 0:
5922 
        if ftype == TType.BOOL:
5923 
          self.success = iprot.readBool();
5924 
        else:
5925 
          iprot.skip(ftype)
5926 
      elif fid == 1:
5927 
        if ftype == TType.STRUCT:
5928 
          self.ucx = UserContextException()
5929 
          self.ucx.read(iprot)
5930 
        else:
5931 
          iprot.skip(ftype)
5932 
      else:
5933 
        iprot.skip(ftype)
5934 
      iprot.readFieldEnd()
5935 
    iprot.readStructEnd()
5936 
 
5937 
  def write(self, oprot):
5938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5940 
      return
559 chandransh 5941 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 5942 
    if self.success is not None:
94 ashish 5943 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5944 
      oprot.writeBool(self.success)
5945 
      oprot.writeFieldEnd()
3431 rajveer 5946 
    if self.ucx is not None:
94 ashish 5947 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5948 
      self.ucx.write(oprot)
5949 
      oprot.writeFieldEnd()
5950 
    oprot.writeFieldStop()
5951 
    oprot.writeStructEnd()
5952 
 
3431 rajveer 5953 
  def validate(self):
5954 
    return
5955 
 
5956 
 
94 ashish 5957 
  def __repr__(self):
5958 
    L = ['%s=%r' % (key, value)
5959 
      for key, value in self.__dict__.iteritems()]
5960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5961 
 
5962 
  def __eq__(self, other):
5963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5964 
 
5965 
  def __ne__(self, other):
5966 
    return not (self == other)
5967 
 
559 chandransh 5968 
class setUserAsLoggedIn_args:
94 ashish 5969 
  """
5970 
  Attributes:
559 chandransh 5971 
   - userId
94 ashish 5972 
   - timestamp
5973 
  """
5974 
 
5975 
  thrift_spec = (
5976 
    None, # 0
559 chandransh 5977 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5978 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5979 
  )
5980 
 
559 chandransh 5981 
  def __init__(self, userId=None, timestamp=None,):
5982 
    self.userId = userId
94 ashish 5983 
    self.timestamp = timestamp
5984 
 
5985 
  def read(self, iprot):
5986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5988 
      return
5989 
    iprot.readStructBegin()
5990 
    while True:
5991 
      (fname, ftype, fid) = iprot.readFieldBegin()
5992 
      if ftype == TType.STOP:
5993 
        break
5994 
      if fid == 1:
559 chandransh 5995 
        if ftype == TType.I64:
5996 
          self.userId = iprot.readI64();
94 ashish 5997 
        else:
5998 
          iprot.skip(ftype)
5999 
      elif fid == 2:
6000 
        if ftype == TType.I64:
6001 
          self.timestamp = iprot.readI64();
6002 
        else:
6003 
          iprot.skip(ftype)
6004 
      else:
6005 
        iprot.skip(ftype)
6006 
      iprot.readFieldEnd()
6007 
    iprot.readStructEnd()
6008 
 
6009 
  def write(self, oprot):
6010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6012 
      return
559 chandransh 6013 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6014 
    if self.userId is not None:
559 chandransh 6015 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6016 
      oprot.writeI64(self.userId)
94 ashish 6017 
      oprot.writeFieldEnd()
3431 rajveer 6018 
    if self.timestamp is not None:
94 ashish 6019 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6020 
      oprot.writeI64(self.timestamp)
6021 
      oprot.writeFieldEnd()
6022 
    oprot.writeFieldStop()
6023 
    oprot.writeStructEnd()
6024 
 
3431 rajveer 6025 
  def validate(self):
6026 
    return
6027 
 
6028 
 
94 ashish 6029 
  def __repr__(self):
6030 
    L = ['%s=%r' % (key, value)
6031 
      for key, value in self.__dict__.iteritems()]
6032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6033 
 
6034 
  def __eq__(self, other):
6035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6036 
 
6037 
  def __ne__(self, other):
6038 
    return not (self == other)
6039 
 
559 chandransh 6040 
class setUserAsLoggedIn_result:
94 ashish 6041 
  """
6042 
  Attributes:
6043 
   - success
6044 
   - ucx
6045 
  """
6046 
 
6047 
  thrift_spec = (
6048 
    (0, TType.BOOL, 'success', None, None, ), # 0
6049 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6050 
  )
6051 
 
6052 
  def __init__(self, success=None, ucx=None,):
6053 
    self.success = success
6054 
    self.ucx = ucx
6055 
 
6056 
  def read(self, iprot):
6057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6059 
      return
6060 
    iprot.readStructBegin()
6061 
    while True:
6062 
      (fname, ftype, fid) = iprot.readFieldBegin()
6063 
      if ftype == TType.STOP:
6064 
        break
6065 
      if fid == 0:
6066 
        if ftype == TType.BOOL:
6067 
          self.success = iprot.readBool();
6068 
        else:
6069 
          iprot.skip(ftype)
6070 
      elif fid == 1:
6071 
        if ftype == TType.STRUCT:
6072 
          self.ucx = UserContextException()
6073 
          self.ucx.read(iprot)
6074 
        else:
6075 
          iprot.skip(ftype)
6076 
      else:
6077 
        iprot.skip(ftype)
6078 
      iprot.readFieldEnd()
6079 
    iprot.readStructEnd()
6080 
 
6081 
  def write(self, oprot):
6082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6084 
      return
559 chandransh 6085 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6086 
    if self.success is not None:
94 ashish 6087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6088 
      oprot.writeBool(self.success)
6089 
      oprot.writeFieldEnd()
3431 rajveer 6090 
    if self.ucx is not None:
94 ashish 6091 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6092 
      self.ucx.write(oprot)
6093 
      oprot.writeFieldEnd()
6094 
    oprot.writeFieldStop()
6095 
    oprot.writeStructEnd()
6096 
 
3431 rajveer 6097 
  def validate(self):
6098 
    return
6099 
 
6100 
 
94 ashish 6101 
  def __repr__(self):
6102 
    L = ['%s=%r' % (key, value)
6103 
      for key, value in self.__dict__.iteritems()]
6104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6105 
 
6106 
  def __eq__(self, other):
6107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6108 
 
6109 
  def __ne__(self, other):
6110 
    return not (self == other)
6111 
 
559 chandransh 6112 
class setUserAsLoggedOut_args:
94 ashish 6113 
  """
6114 
  Attributes:
6115 
   - userid
6116 
   - timestamp
6117 
  """
6118 
 
6119 
  thrift_spec = (
6120 
    None, # 0
559 chandransh 6121 
    (1, TType.I64, 'userid', None, None, ), # 1
6122 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6123 
  )
6124 
 
559 chandransh 6125 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6126 
    self.userid = userid
6127 
    self.timestamp = timestamp
6128 
 
6129 
  def read(self, iprot):
6130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6132 
      return
6133 
    iprot.readStructBegin()
6134 
    while True:
6135 
      (fname, ftype, fid) = iprot.readFieldBegin()
6136 
      if ftype == TType.STOP:
6137 
        break
6138 
      if fid == 1:
6139 
        if ftype == TType.I64:
6140 
          self.userid = iprot.readI64();
6141 
        else:
6142 
          iprot.skip(ftype)
559 chandransh 6143 
      elif fid == 2:
94 ashish 6144 
        if ftype == TType.I64:
6145 
          self.timestamp = iprot.readI64();
6146 
        else:
6147 
          iprot.skip(ftype)
6148 
      else:
6149 
        iprot.skip(ftype)
6150 
      iprot.readFieldEnd()
6151 
    iprot.readStructEnd()
6152 
 
6153 
  def write(self, oprot):
6154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6156 
      return
559 chandransh 6157 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6158 
    if self.userid is not None:
559 chandransh 6159 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6160 
      oprot.writeI64(self.userid)
6161 
      oprot.writeFieldEnd()
3431 rajveer 6162 
    if self.timestamp is not None:
559 chandransh 6163 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6164 
      oprot.writeI64(self.timestamp)
6165 
      oprot.writeFieldEnd()
6166 
    oprot.writeFieldStop()
6167 
    oprot.writeStructEnd()
6168 
 
3431 rajveer 6169 
  def validate(self):
6170 
    return
6171 
 
6172 
 
94 ashish 6173 
  def __repr__(self):
6174 
    L = ['%s=%r' % (key, value)
6175 
      for key, value in self.__dict__.iteritems()]
6176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6177 
 
6178 
  def __eq__(self, other):
6179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6180 
 
6181 
  def __ne__(self, other):
6182 
    return not (self == other)
6183 
 
559 chandransh 6184 
class setUserAsLoggedOut_result:
94 ashish 6185 
  """
6186 
  Attributes:
6187 
   - success
6188 
   - ucx
6189 
  """
6190 
 
6191 
  thrift_spec = (
6192 
    (0, TType.BOOL, 'success', None, None, ), # 0
6193 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6194 
  )
6195 
 
6196 
  def __init__(self, success=None, ucx=None,):
6197 
    self.success = success
6198 
    self.ucx = ucx
6199 
 
6200 
  def read(self, iprot):
6201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6203 
      return
6204 
    iprot.readStructBegin()
6205 
    while True:
6206 
      (fname, ftype, fid) = iprot.readFieldBegin()
6207 
      if ftype == TType.STOP:
6208 
        break
6209 
      if fid == 0:
6210 
        if ftype == TType.BOOL:
6211 
          self.success = iprot.readBool();
6212 
        else:
6213 
          iprot.skip(ftype)
6214 
      elif fid == 1:
6215 
        if ftype == TType.STRUCT:
6216 
          self.ucx = UserContextException()
6217 
          self.ucx.read(iprot)
6218 
        else:
6219 
          iprot.skip(ftype)
6220 
      else:
6221 
        iprot.skip(ftype)
6222 
      iprot.readFieldEnd()
6223 
    iprot.readStructEnd()
6224 
 
6225 
  def write(self, oprot):
6226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6228 
      return
559 chandransh 6229 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6230 
    if self.success is not None:
94 ashish 6231 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6232 
      oprot.writeBool(self.success)
6233 
      oprot.writeFieldEnd()
3431 rajveer 6234 
    if self.ucx is not None:
94 ashish 6235 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6236 
      self.ucx.write(oprot)
6237 
      oprot.writeFieldEnd()
6238 
    oprot.writeFieldStop()
6239 
    oprot.writeStructEnd()
6240 
 
3431 rajveer 6241 
  def validate(self):
6242 
    return
6243 
 
6244 
 
94 ashish 6245 
  def __repr__(self):
6246 
    L = ['%s=%r' % (key, value)
6247 
      for key, value in self.__dict__.iteritems()]
6248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6249 
 
6250 
  def __eq__(self, other):
6251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6252 
 
6253 
  def __ne__(self, other):
6254 
    return not (self == other)
6255 
 
559 chandransh 6256 
class setDefaultAddress_args:
94 ashish 6257 
  """
6258 
  Attributes:
6259 
   - userid
6260 
   - addressId
6261 
  """
6262 
 
6263 
  thrift_spec = (
6264 
    None, # 0
6265 
    (1, TType.I64, 'userid', None, None, ), # 1
6266 
    (2, TType.I64, 'addressId', None, None, ), # 2
6267 
  )
6268 
 
6269 
  def __init__(self, userid=None, addressId=None,):
6270 
    self.userid = userid
6271 
    self.addressId = addressId
6272 
 
6273 
  def read(self, iprot):
6274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6276 
      return
6277 
    iprot.readStructBegin()
6278 
    while True:
6279 
      (fname, ftype, fid) = iprot.readFieldBegin()
6280 
      if ftype == TType.STOP:
6281 
        break
6282 
      if fid == 1:
6283 
        if ftype == TType.I64:
6284 
          self.userid = iprot.readI64();
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      elif fid == 2:
6288 
        if ftype == TType.I64:
6289 
          self.addressId = iprot.readI64();
6290 
        else:
6291 
          iprot.skip(ftype)
6292 
      else:
6293 
        iprot.skip(ftype)
6294 
      iprot.readFieldEnd()
6295 
    iprot.readStructEnd()
6296 
 
6297 
  def write(self, oprot):
6298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6300 
      return
559 chandransh 6301 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6302 
    if self.userid is not None:
94 ashish 6303 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6304 
      oprot.writeI64(self.userid)
6305 
      oprot.writeFieldEnd()
3431 rajveer 6306 
    if self.addressId is not None:
94 ashish 6307 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6308 
      oprot.writeI64(self.addressId)
6309 
      oprot.writeFieldEnd()
6310 
    oprot.writeFieldStop()
6311 
    oprot.writeStructEnd()
6312 
 
3431 rajveer 6313 
  def validate(self):
6314 
    return
6315 
 
6316 
 
94 ashish 6317 
  def __repr__(self):
6318 
    L = ['%s=%r' % (key, value)
6319 
      for key, value in self.__dict__.iteritems()]
6320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6321 
 
6322 
  def __eq__(self, other):
6323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6324 
 
6325 
  def __ne__(self, other):
6326 
    return not (self == other)
6327 
 
559 chandransh 6328 
class setDefaultAddress_result:
94 ashish 6329 
  """
6330 
  Attributes:
6331 
   - success
6332 
   - ucx
6333 
  """
6334 
 
6335 
  thrift_spec = (
6336 
    (0, TType.BOOL, 'success', None, None, ), # 0
6337 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6338 
  )
6339 
 
6340 
  def __init__(self, success=None, ucx=None,):
6341 
    self.success = success
6342 
    self.ucx = ucx
6343 
 
6344 
  def read(self, iprot):
6345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6347 
      return
6348 
    iprot.readStructBegin()
6349 
    while True:
6350 
      (fname, ftype, fid) = iprot.readFieldBegin()
6351 
      if ftype == TType.STOP:
6352 
        break
6353 
      if fid == 0:
6354 
        if ftype == TType.BOOL:
6355 
          self.success = iprot.readBool();
6356 
        else:
6357 
          iprot.skip(ftype)
6358 
      elif fid == 1:
6359 
        if ftype == TType.STRUCT:
6360 
          self.ucx = UserContextException()
6361 
          self.ucx.read(iprot)
6362 
        else:
6363 
          iprot.skip(ftype)
6364 
      else:
6365 
        iprot.skip(ftype)
6366 
      iprot.readFieldEnd()
6367 
    iprot.readStructEnd()
6368 
 
6369 
  def write(self, oprot):
6370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6372 
      return
559 chandransh 6373 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6374 
    if self.success is not None:
94 ashish 6375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6376 
      oprot.writeBool(self.success)
6377 
      oprot.writeFieldEnd()
3431 rajveer 6378 
    if self.ucx is not None:
94 ashish 6379 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6380 
      self.ucx.write(oprot)
6381 
      oprot.writeFieldEnd()
6382 
    oprot.writeFieldStop()
6383 
    oprot.writeStructEnd()
6384 
 
3431 rajveer 6385 
  def validate(self):
6386 
    return
6387 
 
6388 
 
94 ashish 6389 
  def __repr__(self):
6390 
    L = ['%s=%r' % (key, value)
6391 
      for key, value in self.__dict__.iteritems()]
6392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6393 
 
6394 
  def __eq__(self, other):
6395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6396 
 
6397 
  def __ne__(self, other):
6398 
    return not (self == other)
6399 
 
559 chandransh 6400 
class updatePassword_args:
94 ashish 6401 
  """
6402 
  Attributes:
559 chandransh 6403 
   - userid
594 rajveer 6404 
   - oldPassword
6405 
   - newPassword
94 ashish 6406 
  """
6407 
 
6408 
  thrift_spec = (
6409 
    None, # 0
559 chandransh 6410 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6411 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6412 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6413 
  )
6414 
 
594 rajveer 6415 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6416 
    self.userid = userid
594 rajveer 6417 
    self.oldPassword = oldPassword
6418 
    self.newPassword = newPassword
94 ashish 6419 
 
6420 
  def read(self, iprot):
6421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6423 
      return
6424 
    iprot.readStructBegin()
6425 
    while True:
6426 
      (fname, ftype, fid) = iprot.readFieldBegin()
6427 
      if ftype == TType.STOP:
6428 
        break
6429 
      if fid == 1:
6430 
        if ftype == TType.I64:
559 chandransh 6431 
          self.userid = iprot.readI64();
94 ashish 6432 
        else:
6433 
          iprot.skip(ftype)
6434 
      elif fid == 2:
559 chandransh 6435 
        if ftype == TType.STRING:
594 rajveer 6436 
          self.oldPassword = iprot.readString();
94 ashish 6437 
        else:
6438 
          iprot.skip(ftype)
594 rajveer 6439 
      elif fid == 3:
6440 
        if ftype == TType.STRING:
6441 
          self.newPassword = iprot.readString();
6442 
        else:
6443 
          iprot.skip(ftype)
94 ashish 6444 
      else:
6445 
        iprot.skip(ftype)
6446 
      iprot.readFieldEnd()
6447 
    iprot.readStructEnd()
6448 
 
6449 
  def write(self, oprot):
6450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6452 
      return
559 chandransh 6453 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6454 
    if self.userid is not None:
559 chandransh 6455 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6456 
      oprot.writeI64(self.userid)
94 ashish 6457 
      oprot.writeFieldEnd()
3431 rajveer 6458 
    if self.oldPassword is not None:
594 rajveer 6459 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6460 
      oprot.writeString(self.oldPassword)
94 ashish 6461 
      oprot.writeFieldEnd()
3431 rajveer 6462 
    if self.newPassword is not None:
594 rajveer 6463 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6464 
      oprot.writeString(self.newPassword)
6465 
      oprot.writeFieldEnd()
94 ashish 6466 
    oprot.writeFieldStop()
6467 
    oprot.writeStructEnd()
6468 
 
3431 rajveer 6469 
  def validate(self):
6470 
    return
6471 
 
6472 
 
94 ashish 6473 
  def __repr__(self):
6474 
    L = ['%s=%r' % (key, value)
6475 
      for key, value in self.__dict__.iteritems()]
6476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6477 
 
6478 
  def __eq__(self, other):
6479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6480 
 
6481 
  def __ne__(self, other):
6482 
    return not (self == other)
6483 
 
559 chandransh 6484 
class updatePassword_result:
94 ashish 6485 
  """
6486 
  Attributes:
6487 
   - success
6488 
   - ucx
6489 
  """
6490 
 
6491 
  thrift_spec = (
6492 
    (0, TType.BOOL, 'success', None, None, ), # 0
6493 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6494 
  )
6495 
 
6496 
  def __init__(self, success=None, ucx=None,):
6497 
    self.success = success
6498 
    self.ucx = ucx
6499 
 
6500 
  def read(self, iprot):
6501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6503 
      return
6504 
    iprot.readStructBegin()
6505 
    while True:
6506 
      (fname, ftype, fid) = iprot.readFieldBegin()
6507 
      if ftype == TType.STOP:
6508 
        break
6509 
      if fid == 0:
6510 
        if ftype == TType.BOOL:
6511 
          self.success = iprot.readBool();
6512 
        else:
6513 
          iprot.skip(ftype)
6514 
      elif fid == 1:
6515 
        if ftype == TType.STRUCT:
6516 
          self.ucx = UserContextException()
6517 
          self.ucx.read(iprot)
6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      else:
6521 
        iprot.skip(ftype)
6522 
      iprot.readFieldEnd()
6523 
    iprot.readStructEnd()
6524 
 
6525 
  def write(self, oprot):
6526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6528 
      return
559 chandransh 6529 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6530 
    if self.success is not None:
94 ashish 6531 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6532 
      oprot.writeBool(self.success)
6533 
      oprot.writeFieldEnd()
3431 rajveer 6534 
    if self.ucx is not None:
94 ashish 6535 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6536 
      self.ucx.write(oprot)
6537 
      oprot.writeFieldEnd()
6538 
    oprot.writeFieldStop()
6539 
    oprot.writeStructEnd()
6540 
 
3431 rajveer 6541 
  def validate(self):
6542 
    return
6543 
 
6544 
 
94 ashish 6545 
  def __repr__(self):
6546 
    L = ['%s=%r' % (key, value)
6547 
      for key, value in self.__dict__.iteritems()]
6548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6549 
 
6550 
  def __eq__(self, other):
6551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6552 
 
6553 
  def __ne__(self, other):
6554 
    return not (self == other)
6555 
 
581 rajveer 6556 
class forgotPassword_args:
6557 
  """
6558 
  Attributes:
6559 
   - email
884 rajveer 6560 
   - newPassword
581 rajveer 6561 
  """
6562 
 
6563 
  thrift_spec = (
6564 
    None, # 0
6565 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6566 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6567 
  )
6568 
 
884 rajveer 6569 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6570 
    self.email = email
884 rajveer 6571 
    self.newPassword = newPassword
581 rajveer 6572 
 
6573 
  def read(self, iprot):
6574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6576 
      return
6577 
    iprot.readStructBegin()
6578 
    while True:
6579 
      (fname, ftype, fid) = iprot.readFieldBegin()
6580 
      if ftype == TType.STOP:
6581 
        break
6582 
      if fid == 1:
6583 
        if ftype == TType.STRING:
6584 
          self.email = iprot.readString();
6585 
        else:
6586 
          iprot.skip(ftype)
884 rajveer 6587 
      elif fid == 2:
6588 
        if ftype == TType.STRING:
6589 
          self.newPassword = iprot.readString();
6590 
        else:
6591 
          iprot.skip(ftype)
581 rajveer 6592 
      else:
6593 
        iprot.skip(ftype)
6594 
      iprot.readFieldEnd()
6595 
    iprot.readStructEnd()
6596 
 
6597 
  def write(self, oprot):
6598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6600 
      return
6601 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6602 
    if self.email is not None:
581 rajveer 6603 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6604 
      oprot.writeString(self.email)
6605 
      oprot.writeFieldEnd()
3431 rajveer 6606 
    if self.newPassword is not None:
884 rajveer 6607 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6608 
      oprot.writeString(self.newPassword)
6609 
      oprot.writeFieldEnd()
581 rajveer 6610 
    oprot.writeFieldStop()
6611 
    oprot.writeStructEnd()
6612 
 
3431 rajveer 6613 
  def validate(self):
6614 
    return
6615 
 
6616 
 
581 rajveer 6617 
  def __repr__(self):
6618 
    L = ['%s=%r' % (key, value)
6619 
      for key, value in self.__dict__.iteritems()]
6620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6621 
 
6622 
  def __eq__(self, other):
6623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6624 
 
6625 
  def __ne__(self, other):
6626 
    return not (self == other)
6627 
 
6628 
class forgotPassword_result:
6629 
  """
6630 
  Attributes:
6631 
   - success
6632 
   - ucx
6633 
  """
6634 
 
6635 
  thrift_spec = (
6636 
    (0, TType.BOOL, 'success', None, None, ), # 0
6637 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6638 
  )
6639 
 
6640 
  def __init__(self, success=None, ucx=None,):
6641 
    self.success = success
6642 
    self.ucx = ucx
6643 
 
6644 
  def read(self, iprot):
6645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6647 
      return
6648 
    iprot.readStructBegin()
6649 
    while True:
6650 
      (fname, ftype, fid) = iprot.readFieldBegin()
6651 
      if ftype == TType.STOP:
6652 
        break
6653 
      if fid == 0:
6654 
        if ftype == TType.BOOL:
6655 
          self.success = iprot.readBool();
6656 
        else:
6657 
          iprot.skip(ftype)
6658 
      elif fid == 1:
6659 
        if ftype == TType.STRUCT:
6660 
          self.ucx = UserContextException()
6661 
          self.ucx.read(iprot)
6662 
        else:
6663 
          iprot.skip(ftype)
6664 
      else:
6665 
        iprot.skip(ftype)
6666 
      iprot.readFieldEnd()
6667 
    iprot.readStructEnd()
6668 
 
6669 
  def write(self, oprot):
6670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6672 
      return
6673 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6674 
    if self.success is not None:
581 rajveer 6675 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6676 
      oprot.writeBool(self.success)
6677 
      oprot.writeFieldEnd()
3431 rajveer 6678 
    if self.ucx is not None:
581 rajveer 6679 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6680 
      self.ucx.write(oprot)
6681 
      oprot.writeFieldEnd()
6682 
    oprot.writeFieldStop()
6683 
    oprot.writeStructEnd()
6684 
 
3431 rajveer 6685 
  def validate(self):
6686 
    return
6687 
 
6688 
 
581 rajveer 6689 
  def __repr__(self):
6690 
    L = ['%s=%r' % (key, value)
6691 
      for key, value in self.__dict__.iteritems()]
6692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6693 
 
6694 
  def __eq__(self, other):
6695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6696 
 
6697 
  def __ne__(self, other):
6698 
    return not (self == other)
6699 
 
594 rajveer 6700 
class getAllAddressesForUser_args:
6701 
  """
6702 
  Attributes:
6703 
   - userId
6704 
  """
6705 
 
6706 
  thrift_spec = (
6707 
    None, # 0
6708 
    (1, TType.I64, 'userId', None, None, ), # 1
6709 
  )
6710 
 
6711 
  def __init__(self, userId=None,):
6712 
    self.userId = userId
6713 
 
6714 
  def read(self, iprot):
6715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6717 
      return
6718 
    iprot.readStructBegin()
6719 
    while True:
6720 
      (fname, ftype, fid) = iprot.readFieldBegin()
6721 
      if ftype == TType.STOP:
6722 
        break
6723 
      if fid == 1:
6724 
        if ftype == TType.I64:
6725 
          self.userId = iprot.readI64();
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      else:
6729 
        iprot.skip(ftype)
6730 
      iprot.readFieldEnd()
6731 
    iprot.readStructEnd()
6732 
 
6733 
  def write(self, oprot):
6734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6736 
      return
6737 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6738 
    if self.userId is not None:
594 rajveer 6739 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6740 
      oprot.writeI64(self.userId)
6741 
      oprot.writeFieldEnd()
6742 
    oprot.writeFieldStop()
6743 
    oprot.writeStructEnd()
6744 
 
3431 rajveer 6745 
  def validate(self):
6746 
    return
6747 
 
6748 
 
594 rajveer 6749 
  def __repr__(self):
6750 
    L = ['%s=%r' % (key, value)
6751 
      for key, value in self.__dict__.iteritems()]
6752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6753 
 
6754 
  def __eq__(self, other):
6755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6756 
 
6757 
  def __ne__(self, other):
6758 
    return not (self == other)
6759 
 
6760 
class getAllAddressesForUser_result:
6761 
  """
6762 
  Attributes:
6763 
   - success
6764 
   - ucx
6765 
  """
6766 
 
6767 
  thrift_spec = (
6768 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6769 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6770 
  )
6771 
 
6772 
  def __init__(self, success=None, ucx=None,):
6773 
    self.success = success
6774 
    self.ucx = ucx
6775 
 
6776 
  def read(self, iprot):
6777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6779 
      return
6780 
    iprot.readStructBegin()
6781 
    while True:
6782 
      (fname, ftype, fid) = iprot.readFieldBegin()
6783 
      if ftype == TType.STOP:
6784 
        break
6785 
      if fid == 0:
6786 
        if ftype == TType.LIST:
6787 
          self.success = []
11592 amit.gupta 6788 
          (_etype100, _size97) = iprot.readListBegin()
6789 
          for _i101 in xrange(_size97):
6790 
            _elem102 = Address()
6791 
            _elem102.read(iprot)
6792 
            self.success.append(_elem102)
594 rajveer 6793 
          iprot.readListEnd()
6794 
        else:
6795 
          iprot.skip(ftype)
6796 
      elif fid == 1:
6797 
        if ftype == TType.STRUCT:
6798 
          self.ucx = UserContextException()
6799 
          self.ucx.read(iprot)
6800 
        else:
6801 
          iprot.skip(ftype)
6802 
      else:
6803 
        iprot.skip(ftype)
6804 
      iprot.readFieldEnd()
6805 
    iprot.readStructEnd()
6806 
 
6807 
  def write(self, oprot):
6808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6810 
      return
6811 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 6812 
    if self.success is not None:
594 rajveer 6813 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6814 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 6815 
      for iter103 in self.success:
6816 
        iter103.write(oprot)
594 rajveer 6817 
      oprot.writeListEnd()
6818 
      oprot.writeFieldEnd()
3431 rajveer 6819 
    if self.ucx is not None:
594 rajveer 6820 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6821 
      self.ucx.write(oprot)
6822 
      oprot.writeFieldEnd()
6823 
    oprot.writeFieldStop()
6824 
    oprot.writeStructEnd()
6825 
 
3431 rajveer 6826 
  def validate(self):
6827 
    return
6828 
 
6829 
 
594 rajveer 6830 
  def __repr__(self):
6831 
    L = ['%s=%r' % (key, value)
6832 
      for key, value in self.__dict__.iteritems()]
6833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6834 
 
6835 
  def __eq__(self, other):
6836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6837 
 
6838 
  def __ne__(self, other):
6839 
    return not (self == other)
6840 
 
1894 vikas 6841 
class getAddressById_args:
6842 
  """
6843 
  Attributes:
6844 
   - addressId
6845 
  """
6846 
 
6847 
  thrift_spec = (
6848 
    None, # 0
6849 
    (1, TType.I64, 'addressId', None, None, ), # 1
6850 
  )
6851 
 
6852 
  def __init__(self, addressId=None,):
6853 
    self.addressId = addressId
6854 
 
6855 
  def read(self, iprot):
6856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6858 
      return
6859 
    iprot.readStructBegin()
6860 
    while True:
6861 
      (fname, ftype, fid) = iprot.readFieldBegin()
6862 
      if ftype == TType.STOP:
6863 
        break
6864 
      if fid == 1:
6865 
        if ftype == TType.I64:
6866 
          self.addressId = iprot.readI64();
6867 
        else:
6868 
          iprot.skip(ftype)
6869 
      else:
6870 
        iprot.skip(ftype)
6871 
      iprot.readFieldEnd()
6872 
    iprot.readStructEnd()
6873 
 
6874 
  def write(self, oprot):
6875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6877 
      return
6878 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 6879 
    if self.addressId is not None:
1894 vikas 6880 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6881 
      oprot.writeI64(self.addressId)
6882 
      oprot.writeFieldEnd()
6883 
    oprot.writeFieldStop()
6884 
    oprot.writeStructEnd()
6885 
 
3431 rajveer 6886 
  def validate(self):
6887 
    return
6888 
 
6889 
 
1894 vikas 6890 
  def __repr__(self):
6891 
    L = ['%s=%r' % (key, value)
6892 
      for key, value in self.__dict__.iteritems()]
6893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6894 
 
6895 
  def __eq__(self, other):
6896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6897 
 
6898 
  def __ne__(self, other):
6899 
    return not (self == other)
6900 
 
6901 
class getAddressById_result:
6902 
  """
6903 
  Attributes:
6904 
   - success
6905 
   - ucx
6906 
  """
6907 
 
6908 
  thrift_spec = (
6909 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6910 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6911 
  )
6912 
 
6913 
  def __init__(self, success=None, ucx=None,):
6914 
    self.success = success
6915 
    self.ucx = ucx
6916 
 
6917 
  def read(self, iprot):
6918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6920 
      return
6921 
    iprot.readStructBegin()
6922 
    while True:
6923 
      (fname, ftype, fid) = iprot.readFieldBegin()
6924 
      if ftype == TType.STOP:
6925 
        break
6926 
      if fid == 0:
6927 
        if ftype == TType.STRUCT:
6928 
          self.success = Address()
6929 
          self.success.read(iprot)
6930 
        else:
6931 
          iprot.skip(ftype)
6932 
      elif fid == 1:
6933 
        if ftype == TType.STRUCT:
6934 
          self.ucx = UserContextException()
6935 
          self.ucx.read(iprot)
6936 
        else:
6937 
          iprot.skip(ftype)
6938 
      else:
6939 
        iprot.skip(ftype)
6940 
      iprot.readFieldEnd()
6941 
    iprot.readStructEnd()
6942 
 
6943 
  def write(self, oprot):
6944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6946 
      return
6947 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 6948 
    if self.success is not None:
1894 vikas 6949 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6950 
      self.success.write(oprot)
6951 
      oprot.writeFieldEnd()
3431 rajveer 6952 
    if self.ucx is not None:
1894 vikas 6953 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6954 
      self.ucx.write(oprot)
6955 
      oprot.writeFieldEnd()
6956 
    oprot.writeFieldStop()
6957 
    oprot.writeStructEnd()
6958 
 
3431 rajveer 6959 
  def validate(self):
6960 
    return
6961 
 
6962 
 
1894 vikas 6963 
  def __repr__(self):
6964 
    L = ['%s=%r' % (key, value)
6965 
      for key, value in self.__dict__.iteritems()]
6966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6967 
 
6968 
  def __eq__(self, other):
6969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6970 
 
6971 
  def __ne__(self, other):
6972 
    return not (self == other)
6973 
 
594 rajveer 6974 
class getDefaultAddressId_args:
6975 
  """
6976 
  Attributes:
6977 
   - userId
6978 
  """
6979 
 
6980 
  thrift_spec = (
6981 
    None, # 0
6982 
    (1, TType.I64, 'userId', None, None, ), # 1
6983 
  )
6984 
 
6985 
  def __init__(self, userId=None,):
6986 
    self.userId = userId
6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 1:
6998 
        if ftype == TType.I64:
6999 
          self.userId = iprot.readI64();
7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      else:
7003 
        iprot.skip(ftype)
7004 
      iprot.readFieldEnd()
7005 
    iprot.readStructEnd()
7006 
 
7007 
  def write(self, oprot):
7008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7010 
      return
7011 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7012 
    if self.userId is not None:
594 rajveer 7013 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7014 
      oprot.writeI64(self.userId)
7015 
      oprot.writeFieldEnd()
7016 
    oprot.writeFieldStop()
7017 
    oprot.writeStructEnd()
7018 
 
3431 rajveer 7019 
  def validate(self):
7020 
    return
7021 
 
7022 
 
594 rajveer 7023 
  def __repr__(self):
7024 
    L = ['%s=%r' % (key, value)
7025 
      for key, value in self.__dict__.iteritems()]
7026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7027 
 
7028 
  def __eq__(self, other):
7029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7030 
 
7031 
  def __ne__(self, other):
7032 
    return not (self == other)
7033 
 
7034 
class getDefaultAddressId_result:
7035 
  """
7036 
  Attributes:
7037 
   - success
7038 
   - ucx
7039 
  """
7040 
 
7041 
  thrift_spec = (
7042 
    (0, TType.I64, 'success', None, None, ), # 0
7043 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7044 
  )
7045 
 
7046 
  def __init__(self, success=None, ucx=None,):
7047 
    self.success = success
7048 
    self.ucx = ucx
7049 
 
7050 
  def read(self, iprot):
7051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7053 
      return
7054 
    iprot.readStructBegin()
7055 
    while True:
7056 
      (fname, ftype, fid) = iprot.readFieldBegin()
7057 
      if ftype == TType.STOP:
7058 
        break
7059 
      if fid == 0:
7060 
        if ftype == TType.I64:
7061 
          self.success = iprot.readI64();
7062 
        else:
7063 
          iprot.skip(ftype)
7064 
      elif fid == 1:
7065 
        if ftype == TType.STRUCT:
7066 
          self.ucx = UserContextException()
7067 
          self.ucx.read(iprot)
7068 
        else:
7069 
          iprot.skip(ftype)
7070 
      else:
7071 
        iprot.skip(ftype)
7072 
      iprot.readFieldEnd()
7073 
    iprot.readStructEnd()
7074 
 
7075 
  def write(self, oprot):
7076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7078 
      return
7079 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7080 
    if self.success is not None:
594 rajveer 7081 
      oprot.writeFieldBegin('success', TType.I64, 0)
7082 
      oprot.writeI64(self.success)
7083 
      oprot.writeFieldEnd()
3431 rajveer 7084 
    if self.ucx is not None:
594 rajveer 7085 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7086 
      self.ucx.write(oprot)
7087 
      oprot.writeFieldEnd()
7088 
    oprot.writeFieldStop()
7089 
    oprot.writeStructEnd()
7090 
 
3431 rajveer 7091 
  def validate(self):
7092 
    return
7093 
 
7094 
 
594 rajveer 7095 
  def __repr__(self):
7096 
    L = ['%s=%r' % (key, value)
7097 
      for key, value in self.__dict__.iteritems()]
7098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7099 
 
7100 
  def __eq__(self, other):
7101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7102 
 
7103 
  def __ne__(self, other):
7104 
    return not (self == other)
7105 
 
785 rajveer 7106 
class getDefaultPincode_args:
7107 
  """
7108 
  Attributes:
7109 
   - userId
7110 
  """
7111 
 
7112 
  thrift_spec = (
7113 
    None, # 0
7114 
    (1, TType.I64, 'userId', None, None, ), # 1
7115 
  )
7116 
 
7117 
  def __init__(self, userId=None,):
7118 
    self.userId = userId
7119 
 
7120 
  def read(self, iprot):
7121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7123 
      return
7124 
    iprot.readStructBegin()
7125 
    while True:
7126 
      (fname, ftype, fid) = iprot.readFieldBegin()
7127 
      if ftype == TType.STOP:
7128 
        break
7129 
      if fid == 1:
7130 
        if ftype == TType.I64:
7131 
          self.userId = iprot.readI64();
7132 
        else:
7133 
          iprot.skip(ftype)
7134 
      else:
7135 
        iprot.skip(ftype)
7136 
      iprot.readFieldEnd()
7137 
    iprot.readStructEnd()
7138 
 
7139 
  def write(self, oprot):
7140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7142 
      return
7143 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7144 
    if self.userId is not None:
785 rajveer 7145 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7146 
      oprot.writeI64(self.userId)
7147 
      oprot.writeFieldEnd()
7148 
    oprot.writeFieldStop()
7149 
    oprot.writeStructEnd()
7150 
 
3431 rajveer 7151 
  def validate(self):
7152 
    return
7153 
 
7154 
 
785 rajveer 7155 
  def __repr__(self):
7156 
    L = ['%s=%r' % (key, value)
7157 
      for key, value in self.__dict__.iteritems()]
7158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7159 
 
7160 
  def __eq__(self, other):
7161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7162 
 
7163 
  def __ne__(self, other):
7164 
    return not (self == other)
7165 
 
7166 
class getDefaultPincode_result:
7167 
  """
7168 
  Attributes:
7169 
   - success
7170 
   - ucx
7171 
  """
7172 
 
7173 
  thrift_spec = (
7174 
    (0, TType.STRING, 'success', None, None, ), # 0
7175 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7176 
  )
7177 
 
7178 
  def __init__(self, success=None, ucx=None,):
7179 
    self.success = success
7180 
    self.ucx = ucx
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 == 0:
7192 
        if ftype == TType.STRING:
7193 
          self.success = iprot.readString();
7194 
        else:
7195 
          iprot.skip(ftype)
7196 
      elif fid == 1:
7197 
        if ftype == TType.STRUCT:
7198 
          self.ucx = UserContextException()
7199 
          self.ucx.read(iprot)
7200 
        else:
7201 
          iprot.skip(ftype)
7202 
      else:
7203 
        iprot.skip(ftype)
7204 
      iprot.readFieldEnd()
7205 
    iprot.readStructEnd()
7206 
 
7207 
  def write(self, oprot):
7208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7210 
      return
7211 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7212 
    if self.success is not None:
785 rajveer 7213 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7214 
      oprot.writeString(self.success)
7215 
      oprot.writeFieldEnd()
3431 rajveer 7216 
    if self.ucx is not None:
785 rajveer 7217 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7218 
      self.ucx.write(oprot)
7219 
      oprot.writeFieldEnd()
7220 
    oprot.writeFieldStop()
7221 
    oprot.writeStructEnd()
7222 
 
3431 rajveer 7223 
  def validate(self):
7224 
    return
7225 
 
7226 
 
785 rajveer 7227 
  def __repr__(self):
7228 
    L = ['%s=%r' % (key, value)
7229 
      for key, value in self.__dict__.iteritems()]
7230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7231 
 
7232 
  def __eq__(self, other):
7233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7234 
 
7235 
  def __ne__(self, other):
7236 
    return not (self == other)
7237 
 
1274 varun.gupt 7238 
class saveUserCommunication_args:
7239 
  """
7240 
  Attributes:
7241 
   - userId
7242 
   - replyTo
7243 
   - communicationType
7244 
   - orderId
7245 
   - airwaybillNo
7246 
   - productName
7247 
   - subject
7248 
   - message
7249 
  """
7250 
 
7251 
  thrift_spec = (
7252 
    None, # 0
7253 
    (1, TType.I64, 'userId', None, None, ), # 1
7254 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7255 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7256 
    (4, TType.I64, 'orderId', None, None, ), # 4
7257 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7258 
    (6, TType.STRING, 'productName', None, None, ), # 6
7259 
    (7, TType.STRING, 'subject', None, None, ), # 7
7260 
    (8, TType.STRING, 'message', None, None, ), # 8
7261 
  )
7262 
 
7263 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7264 
    self.userId = userId
7265 
    self.replyTo = replyTo
7266 
    self.communicationType = communicationType
7267 
    self.orderId = orderId
7268 
    self.airwaybillNo = airwaybillNo
7269 
    self.productName = productName
7270 
    self.subject = subject
7271 
    self.message = message
7272 
 
7273 
  def read(self, iprot):
7274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7276 
      return
7277 
    iprot.readStructBegin()
7278 
    while True:
7279 
      (fname, ftype, fid) = iprot.readFieldBegin()
7280 
      if ftype == TType.STOP:
7281 
        break
7282 
      if fid == 1:
7283 
        if ftype == TType.I64:
7284 
          self.userId = iprot.readI64();
7285 
        else:
7286 
          iprot.skip(ftype)
7287 
      elif fid == 2:
7288 
        if ftype == TType.STRING:
7289 
          self.replyTo = iprot.readString();
7290 
        else:
7291 
          iprot.skip(ftype)
7292 
      elif fid == 3:
7293 
        if ftype == TType.I64:
7294 
          self.communicationType = iprot.readI64();
7295 
        else:
7296 
          iprot.skip(ftype)
7297 
      elif fid == 4:
7298 
        if ftype == TType.I64:
7299 
          self.orderId = iprot.readI64();
7300 
        else:
7301 
          iprot.skip(ftype)
7302 
      elif fid == 5:
7303 
        if ftype == TType.STRING:
7304 
          self.airwaybillNo = iprot.readString();
7305 
        else:
7306 
          iprot.skip(ftype)
7307 
      elif fid == 6:
7308 
        if ftype == TType.STRING:
7309 
          self.productName = iprot.readString();
7310 
        else:
7311 
          iprot.skip(ftype)
7312 
      elif fid == 7:
7313 
        if ftype == TType.STRING:
7314 
          self.subject = iprot.readString();
7315 
        else:
7316 
          iprot.skip(ftype)
7317 
      elif fid == 8:
7318 
        if ftype == TType.STRING:
7319 
          self.message = iprot.readString();
7320 
        else:
7321 
          iprot.skip(ftype)
7322 
      else:
7323 
        iprot.skip(ftype)
7324 
      iprot.readFieldEnd()
7325 
    iprot.readStructEnd()
7326 
 
7327 
  def write(self, oprot):
7328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7330 
      return
7331 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7332 
    if self.userId is not None:
1274 varun.gupt 7333 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7334 
      oprot.writeI64(self.userId)
7335 
      oprot.writeFieldEnd()
3431 rajveer 7336 
    if self.replyTo is not None:
1274 varun.gupt 7337 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7338 
      oprot.writeString(self.replyTo)
7339 
      oprot.writeFieldEnd()
3431 rajveer 7340 
    if self.communicationType is not None:
1274 varun.gupt 7341 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7342 
      oprot.writeI64(self.communicationType)
7343 
      oprot.writeFieldEnd()
3431 rajveer 7344 
    if self.orderId is not None:
1274 varun.gupt 7345 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7346 
      oprot.writeI64(self.orderId)
7347 
      oprot.writeFieldEnd()
3431 rajveer 7348 
    if self.airwaybillNo is not None:
1274 varun.gupt 7349 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7350 
      oprot.writeString(self.airwaybillNo)
7351 
      oprot.writeFieldEnd()
3431 rajveer 7352 
    if self.productName is not None:
1274 varun.gupt 7353 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7354 
      oprot.writeString(self.productName)
7355 
      oprot.writeFieldEnd()
3431 rajveer 7356 
    if self.subject is not None:
1274 varun.gupt 7357 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7358 
      oprot.writeString(self.subject)
7359 
      oprot.writeFieldEnd()
3431 rajveer 7360 
    if self.message is not None:
1274 varun.gupt 7361 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7362 
      oprot.writeString(self.message)
7363 
      oprot.writeFieldEnd()
7364 
    oprot.writeFieldStop()
7365 
    oprot.writeStructEnd()
7366 
 
3431 rajveer 7367 
  def validate(self):
7368 
    return
7369 
 
7370 
 
1274 varun.gupt 7371 
  def __repr__(self):
7372 
    L = ['%s=%r' % (key, value)
7373 
      for key, value in self.__dict__.iteritems()]
7374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7375 
 
7376 
  def __eq__(self, other):
7377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7378 
 
7379 
  def __ne__(self, other):
7380 
    return not (self == other)
7381 
 
7382 
class saveUserCommunication_result:
7383 
  """
7384 
  Attributes:
7385 
   - success
7386 
   - ucx
7387 
  """
7388 
 
7389 
  thrift_spec = (
7390 
    (0, TType.BOOL, 'success', None, None, ), # 0
7391 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7392 
  )
7393 
 
7394 
  def __init__(self, success=None, ucx=None,):
7395 
    self.success = success
7396 
    self.ucx = ucx
7397 
 
7398 
  def read(self, iprot):
7399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7401 
      return
7402 
    iprot.readStructBegin()
7403 
    while True:
7404 
      (fname, ftype, fid) = iprot.readFieldBegin()
7405 
      if ftype == TType.STOP:
7406 
        break
7407 
      if fid == 0:
7408 
        if ftype == TType.BOOL:
7409 
          self.success = iprot.readBool();
7410 
        else:
7411 
          iprot.skip(ftype)
7412 
      elif fid == 1:
7413 
        if ftype == TType.STRUCT:
7414 
          self.ucx = UserCommunicationException()
7415 
          self.ucx.read(iprot)
7416 
        else:
7417 
          iprot.skip(ftype)
7418 
      else:
7419 
        iprot.skip(ftype)
7420 
      iprot.readFieldEnd()
7421 
    iprot.readStructEnd()
7422 
 
7423 
  def write(self, oprot):
7424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7426 
      return
7427 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7428 
    if self.success is not None:
1274 varun.gupt 7429 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7430 
      oprot.writeBool(self.success)
7431 
      oprot.writeFieldEnd()
3431 rajveer 7432 
    if self.ucx is not None:
1274 varun.gupt 7433 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7434 
      self.ucx.write(oprot)
7435 
      oprot.writeFieldEnd()
7436 
    oprot.writeFieldStop()
7437 
    oprot.writeStructEnd()
7438 
 
3431 rajveer 7439 
  def validate(self):
7440 
    return
7441 
 
7442 
 
1274 varun.gupt 7443 
  def __repr__(self):
7444 
    L = ['%s=%r' % (key, value)
7445 
      for key, value in self.__dict__.iteritems()]
7446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7447 
 
7448 
  def __eq__(self, other):
7449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7450 
 
7451 
  def __ne__(self, other):
7452 
    return not (self == other)
7453 
 
1590 varun.gupt 7454 
class getUserCommunicationById_args:
7455 
  """
7456 
  Attributes:
7457 
   - id
7458 
  """
7459 
 
7460 
  thrift_spec = (
7461 
    None, # 0
7462 
    (1, TType.I64, 'id', None, None, ), # 1
7463 
  )
7464 
 
7465 
  def __init__(self, id=None,):
7466 
    self.id = id
7467 
 
7468 
  def read(self, iprot):
7469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7471 
      return
7472 
    iprot.readStructBegin()
7473 
    while True:
7474 
      (fname, ftype, fid) = iprot.readFieldBegin()
7475 
      if ftype == TType.STOP:
7476 
        break
7477 
      if fid == 1:
7478 
        if ftype == TType.I64:
7479 
          self.id = iprot.readI64();
7480 
        else:
7481 
          iprot.skip(ftype)
7482 
      else:
7483 
        iprot.skip(ftype)
7484 
      iprot.readFieldEnd()
7485 
    iprot.readStructEnd()
7486 
 
7487 
  def write(self, oprot):
7488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7490 
      return
7491 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7492 
    if self.id is not None:
1590 varun.gupt 7493 
      oprot.writeFieldBegin('id', TType.I64, 1)
7494 
      oprot.writeI64(self.id)
7495 
      oprot.writeFieldEnd()
7496 
    oprot.writeFieldStop()
7497 
    oprot.writeStructEnd()
7498 
 
3431 rajveer 7499 
  def validate(self):
7500 
    return
7501 
 
7502 
 
1590 varun.gupt 7503 
  def __repr__(self):
7504 
    L = ['%s=%r' % (key, value)
7505 
      for key, value in self.__dict__.iteritems()]
7506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7507 
 
7508 
  def __eq__(self, other):
7509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7510 
 
7511 
  def __ne__(self, other):
7512 
    return not (self == other)
7513 
 
7514 
class getUserCommunicationById_result:
7515 
  """
7516 
  Attributes:
7517 
   - success
7518 
   - ucx
7519 
  """
7520 
 
7521 
  thrift_spec = (
7522 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7523 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7524 
  )
7525 
 
7526 
  def __init__(self, success=None, ucx=None,):
7527 
    self.success = success
7528 
    self.ucx = ucx
7529 
 
7530 
  def read(self, iprot):
7531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7533 
      return
7534 
    iprot.readStructBegin()
7535 
    while True:
7536 
      (fname, ftype, fid) = iprot.readFieldBegin()
7537 
      if ftype == TType.STOP:
7538 
        break
7539 
      if fid == 0:
7540 
        if ftype == TType.STRUCT:
7541 
          self.success = UserCommunication()
7542 
          self.success.read(iprot)
7543 
        else:
7544 
          iprot.skip(ftype)
7545 
      elif fid == 1:
7546 
        if ftype == TType.STRUCT:
7547 
          self.ucx = UserCommunicationException()
7548 
          self.ucx.read(iprot)
7549 
        else:
7550 
          iprot.skip(ftype)
7551 
      else:
7552 
        iprot.skip(ftype)
7553 
      iprot.readFieldEnd()
7554 
    iprot.readStructEnd()
7555 
 
7556 
  def write(self, oprot):
7557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7559 
      return
7560 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7561 
    if self.success is not None:
1590 varun.gupt 7562 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7563 
      self.success.write(oprot)
7564 
      oprot.writeFieldEnd()
3431 rajveer 7565 
    if self.ucx is not None:
1590 varun.gupt 7566 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7567 
      self.ucx.write(oprot)
7568 
      oprot.writeFieldEnd()
7569 
    oprot.writeFieldStop()
7570 
    oprot.writeStructEnd()
7571 
 
3431 rajveer 7572 
  def validate(self):
7573 
    return
7574 
 
7575 
 
1590 varun.gupt 7576 
  def __repr__(self):
7577 
    L = ['%s=%r' % (key, value)
7578 
      for key, value in self.__dict__.iteritems()]
7579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7580 
 
7581 
  def __eq__(self, other):
7582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7583 
 
7584 
  def __ne__(self, other):
7585 
    return not (self == other)
7586 
 
7587 
class getUserCommunicationByUser_args:
7588 
  """
7589 
  Attributes:
7590 
   - userId
7591 
  """
7592 
 
7593 
  thrift_spec = (
7594 
    None, # 0
7595 
    (1, TType.I64, 'userId', None, None, ), # 1
7596 
  )
7597 
 
7598 
  def __init__(self, userId=None,):
7599 
    self.userId = userId
7600 
 
7601 
  def read(self, iprot):
7602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7604 
      return
7605 
    iprot.readStructBegin()
7606 
    while True:
7607 
      (fname, ftype, fid) = iprot.readFieldBegin()
7608 
      if ftype == TType.STOP:
7609 
        break
7610 
      if fid == 1:
7611 
        if ftype == TType.I64:
7612 
          self.userId = iprot.readI64();
7613 
        else:
7614 
          iprot.skip(ftype)
7615 
      else:
7616 
        iprot.skip(ftype)
7617 
      iprot.readFieldEnd()
7618 
    iprot.readStructEnd()
7619 
 
7620 
  def write(self, oprot):
7621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7623 
      return
7624 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7625 
    if self.userId is not None:
1590 varun.gupt 7626 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7627 
      oprot.writeI64(self.userId)
7628 
      oprot.writeFieldEnd()
7629 
    oprot.writeFieldStop()
7630 
    oprot.writeStructEnd()
7631 
 
3431 rajveer 7632 
  def validate(self):
7633 
    return
7634 
 
7635 
 
1590 varun.gupt 7636 
  def __repr__(self):
7637 
    L = ['%s=%r' % (key, value)
7638 
      for key, value in self.__dict__.iteritems()]
7639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7640 
 
7641 
  def __eq__(self, other):
7642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7643 
 
7644 
  def __ne__(self, other):
7645 
    return not (self == other)
7646 
 
7647 
class getUserCommunicationByUser_result:
7648 
  """
7649 
  Attributes:
7650 
   - success
7651 
   - ucx
7652 
  """
7653 
 
7654 
  thrift_spec = (
7655 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7656 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7657 
  )
7658 
 
7659 
  def __init__(self, success=None, ucx=None,):
7660 
    self.success = success
7661 
    self.ucx = ucx
7662 
 
7663 
  def read(self, iprot):
7664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7666 
      return
7667 
    iprot.readStructBegin()
7668 
    while True:
7669 
      (fname, ftype, fid) = iprot.readFieldBegin()
7670 
      if ftype == TType.STOP:
7671 
        break
7672 
      if fid == 0:
7673 
        if ftype == TType.LIST:
7674 
          self.success = []
11592 amit.gupta 7675 
          (_etype107, _size104) = iprot.readListBegin()
7676 
          for _i108 in xrange(_size104):
7677 
            _elem109 = UserCommunication()
7678 
            _elem109.read(iprot)
7679 
            self.success.append(_elem109)
1590 varun.gupt 7680 
          iprot.readListEnd()
7681 
        else:
7682 
          iprot.skip(ftype)
7683 
      elif fid == 1:
7684 
        if ftype == TType.STRUCT:
7685 
          self.ucx = UserCommunicationException()
7686 
          self.ucx.read(iprot)
7687 
        else:
7688 
          iprot.skip(ftype)
7689 
      else:
7690 
        iprot.skip(ftype)
7691 
      iprot.readFieldEnd()
7692 
    iprot.readStructEnd()
7693 
 
7694 
  def write(self, oprot):
7695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7697 
      return
7698 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7699 
    if self.success is not None:
1590 varun.gupt 7700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7702 
      for iter110 in self.success:
7703 
        iter110.write(oprot)
1590 varun.gupt 7704 
      oprot.writeListEnd()
7705 
      oprot.writeFieldEnd()
3431 rajveer 7706 
    if self.ucx is not None:
1590 varun.gupt 7707 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7708 
      self.ucx.write(oprot)
7709 
      oprot.writeFieldEnd()
7710 
    oprot.writeFieldStop()
7711 
    oprot.writeStructEnd()
7712 
 
3431 rajveer 7713 
  def validate(self):
7714 
    return
7715 
 
7716 
 
1590 varun.gupt 7717 
  def __repr__(self):
7718 
    L = ['%s=%r' % (key, value)
7719 
      for key, value in self.__dict__.iteritems()]
7720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7721 
 
7722 
  def __eq__(self, other):
7723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7724 
 
7725 
  def __ne__(self, other):
7726 
    return not (self == other)
7727 
 
7728 
class getAllUserCommunications_args:
7729 
 
7730 
  thrift_spec = (
7731 
  )
7732 
 
7733 
  def read(self, iprot):
7734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7736 
      return
7737 
    iprot.readStructBegin()
7738 
    while True:
7739 
      (fname, ftype, fid) = iprot.readFieldBegin()
7740 
      if ftype == TType.STOP:
7741 
        break
7742 
      else:
7743 
        iprot.skip(ftype)
7744 
      iprot.readFieldEnd()
7745 
    iprot.readStructEnd()
7746 
 
7747 
  def write(self, oprot):
7748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7750 
      return
7751 
    oprot.writeStructBegin('getAllUserCommunications_args')
7752 
    oprot.writeFieldStop()
7753 
    oprot.writeStructEnd()
7754 
 
3431 rajveer 7755 
  def validate(self):
7756 
    return
7757 
 
7758 
 
1590 varun.gupt 7759 
  def __repr__(self):
7760 
    L = ['%s=%r' % (key, value)
7761 
      for key, value in self.__dict__.iteritems()]
7762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7763 
 
7764 
  def __eq__(self, other):
7765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7766 
 
7767 
  def __ne__(self, other):
7768 
    return not (self == other)
7769 
 
7770 
class getAllUserCommunications_result:
7771 
  """
7772 
  Attributes:
7773 
   - success
7774 
   - ucx
7775 
  """
7776 
 
7777 
  thrift_spec = (
7778 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7779 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7780 
  )
7781 
 
7782 
  def __init__(self, success=None, ucx=None,):
7783 
    self.success = success
7784 
    self.ucx = ucx
7785 
 
7786 
  def read(self, iprot):
7787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7789 
      return
7790 
    iprot.readStructBegin()
7791 
    while True:
7792 
      (fname, ftype, fid) = iprot.readFieldBegin()
7793 
      if ftype == TType.STOP:
7794 
        break
7795 
      if fid == 0:
7796 
        if ftype == TType.LIST:
7797 
          self.success = []
11592 amit.gupta 7798 
          (_etype114, _size111) = iprot.readListBegin()
7799 
          for _i115 in xrange(_size111):
7800 
            _elem116 = UserCommunication()
7801 
            _elem116.read(iprot)
7802 
            self.success.append(_elem116)
1590 varun.gupt 7803 
          iprot.readListEnd()
7804 
        else:
7805 
          iprot.skip(ftype)
7806 
      elif fid == 1:
7807 
        if ftype == TType.STRUCT:
7808 
          self.ucx = UserCommunicationException()
7809 
          self.ucx.read(iprot)
7810 
        else:
7811 
          iprot.skip(ftype)
7812 
      else:
7813 
        iprot.skip(ftype)
7814 
      iprot.readFieldEnd()
7815 
    iprot.readStructEnd()
7816 
 
7817 
  def write(self, oprot):
7818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7820 
      return
7821 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 7822 
    if self.success is not None:
1590 varun.gupt 7823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7825 
      for iter117 in self.success:
7826 
        iter117.write(oprot)
1590 varun.gupt 7827 
      oprot.writeListEnd()
7828 
      oprot.writeFieldEnd()
3431 rajveer 7829 
    if self.ucx is not None:
1590 varun.gupt 7830 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7831 
      self.ucx.write(oprot)
7832 
      oprot.writeFieldEnd()
7833 
    oprot.writeFieldStop()
7834 
    oprot.writeStructEnd()
7835 
 
3431 rajveer 7836 
  def validate(self):
7837 
    return
7838 
 
7839 
 
1590 varun.gupt 7840 
  def __repr__(self):
7841 
    L = ['%s=%r' % (key, value)
7842 
      for key, value in self.__dict__.iteritems()]
7843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7844 
 
7845 
  def __eq__(self, other):
7846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7847 
 
7848 
  def __ne__(self, other):
7849 
    return not (self == other)
7850 
 
5407 amar.kumar 7851 
class removeUserCommunication_args:
7852 
  """
7853 
  Attributes:
7854 
   - id
7855 
  """
7856 
 
7857 
  thrift_spec = (
7858 
    None, # 0
7859 
    (1, TType.I64, 'id', None, None, ), # 1
7860 
  )
7861 
 
7862 
  def __init__(self, id=None,):
7863 
    self.id = id
7864 
 
7865 
  def read(self, iprot):
7866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7868 
      return
7869 
    iprot.readStructBegin()
7870 
    while True:
7871 
      (fname, ftype, fid) = iprot.readFieldBegin()
7872 
      if ftype == TType.STOP:
7873 
        break
7874 
      if fid == 1:
7875 
        if ftype == TType.I64:
7876 
          self.id = iprot.readI64();
7877 
        else:
7878 
          iprot.skip(ftype)
7879 
      else:
7880 
        iprot.skip(ftype)
7881 
      iprot.readFieldEnd()
7882 
    iprot.readStructEnd()
7883 
 
7884 
  def write(self, oprot):
7885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7887 
      return
7888 
    oprot.writeStructBegin('removeUserCommunication_args')
7889 
    if self.id is not None:
7890 
      oprot.writeFieldBegin('id', TType.I64, 1)
7891 
      oprot.writeI64(self.id)
7892 
      oprot.writeFieldEnd()
7893 
    oprot.writeFieldStop()
7894 
    oprot.writeStructEnd()
7895 
 
7896 
  def validate(self):
7897 
    return
7898 
 
7899 
 
7900 
  def __repr__(self):
7901 
    L = ['%s=%r' % (key, value)
7902 
      for key, value in self.__dict__.iteritems()]
7903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7904 
 
7905 
  def __eq__(self, other):
7906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7907 
 
7908 
  def __ne__(self, other):
7909 
    return not (self == other)
7910 
 
7911 
class removeUserCommunication_result:
7912 
  """
7913 
  Attributes:
7914 
   - ucx
7915 
  """
7916 
 
7917 
  thrift_spec = (
7918 
    None, # 0
7919 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7920 
  )
7921 
 
7922 
  def __init__(self, ucx=None,):
7923 
    self.ucx = ucx
7924 
 
7925 
  def read(self, iprot):
7926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7928 
      return
7929 
    iprot.readStructBegin()
7930 
    while True:
7931 
      (fname, ftype, fid) = iprot.readFieldBegin()
7932 
      if ftype == TType.STOP:
7933 
        break
7934 
      if fid == 1:
7935 
        if ftype == TType.STRUCT:
7936 
          self.ucx = UserCommunicationException()
7937 
          self.ucx.read(iprot)
7938 
        else:
7939 
          iprot.skip(ftype)
7940 
      else:
7941 
        iprot.skip(ftype)
7942 
      iprot.readFieldEnd()
7943 
    iprot.readStructEnd()
7944 
 
7945 
  def write(self, oprot):
7946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7948 
      return
7949 
    oprot.writeStructBegin('removeUserCommunication_result')
7950 
    if self.ucx is not None:
7951 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7952 
      self.ucx.write(oprot)
7953 
      oprot.writeFieldEnd()
7954 
    oprot.writeFieldStop()
7955 
    oprot.writeStructEnd()
7956 
 
7957 
  def validate(self):
7958 
    return
7959 
 
7960 
 
7961 
  def __repr__(self):
7962 
    L = ['%s=%r' % (key, value)
7963 
      for key, value in self.__dict__.iteritems()]
7964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7965 
 
7966 
  def __eq__(self, other):
7967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7968 
 
7969 
  def __ne__(self, other):
7970 
    return not (self == other)
7971 
 
1845 vikas 7972 
class createMasterAffiliate_args:
7973 
  """
7974 
  Attributes:
7975 
   - name
1859 vikas 7976 
   - addedOn
1845 vikas 7977 
  """
7978 
 
7979 
  thrift_spec = (
7980 
    None, # 0
7981 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7982 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7983 
  )
7984 
 
1859 vikas 7985 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7986 
    self.name = name
1859 vikas 7987 
    self.addedOn = addedOn
1845 vikas 7988 
 
7989 
  def read(self, iprot):
7990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7992 
      return
7993 
    iprot.readStructBegin()
7994 
    while True:
7995 
      (fname, ftype, fid) = iprot.readFieldBegin()
7996 
      if ftype == TType.STOP:
7997 
        break
7998 
      if fid == 1:
7999 
        if ftype == TType.STRING:
8000 
          self.name = iprot.readString();
8001 
        else:
8002 
          iprot.skip(ftype)
1859 vikas 8003 
      elif fid == 2:
8004 
        if ftype == TType.I64:
8005 
          self.addedOn = iprot.readI64();
8006 
        else:
8007 
          iprot.skip(ftype)
1845 vikas 8008 
      else:
8009 
        iprot.skip(ftype)
8010 
      iprot.readFieldEnd()
8011 
    iprot.readStructEnd()
8012 
 
8013 
  def write(self, oprot):
8014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8016 
      return
8017 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8018 
    if self.name is not None:
1845 vikas 8019 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8020 
      oprot.writeString(self.name)
8021 
      oprot.writeFieldEnd()
3431 rajveer 8022 
    if self.addedOn is not None:
1859 vikas 8023 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8024 
      oprot.writeI64(self.addedOn)
8025 
      oprot.writeFieldEnd()
1845 vikas 8026 
    oprot.writeFieldStop()
8027 
    oprot.writeStructEnd()
8028 
 
3431 rajveer 8029 
  def validate(self):
8030 
    return
8031 
 
8032 
 
1845 vikas 8033 
  def __repr__(self):
8034 
    L = ['%s=%r' % (key, value)
8035 
      for key, value in self.__dict__.iteritems()]
8036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8037 
 
8038 
  def __eq__(self, other):
8039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8040 
 
8041 
  def __ne__(self, other):
8042 
    return not (self == other)
8043 
 
8044 
class createMasterAffiliate_result:
8045 
  """
8046 
  Attributes:
8047 
   - success
8048 
   - utx
8049 
  """
8050 
 
8051 
  thrift_spec = (
8052 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8053 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8054 
  )
8055 
 
8056 
  def __init__(self, success=None, utx=None,):
8057 
    self.success = success
8058 
    self.utx = utx
8059 
 
8060 
  def read(self, iprot):
8061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8063 
      return
8064 
    iprot.readStructBegin()
8065 
    while True:
8066 
      (fname, ftype, fid) = iprot.readFieldBegin()
8067 
      if ftype == TType.STOP:
8068 
        break
8069 
      if fid == 0:
8070 
        if ftype == TType.STRUCT:
8071 
          self.success = MasterAffiliate()
8072 
          self.success.read(iprot)
8073 
        else:
8074 
          iprot.skip(ftype)
8075 
      elif fid == 1:
8076 
        if ftype == TType.STRUCT:
1996 vikas 8077 
          self.utx = UserAffiliateException()
1845 vikas 8078 
          self.utx.read(iprot)
8079 
        else:
8080 
          iprot.skip(ftype)
8081 
      else:
8082 
        iprot.skip(ftype)
8083 
      iprot.readFieldEnd()
8084 
    iprot.readStructEnd()
8085 
 
8086 
  def write(self, oprot):
8087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8089 
      return
8090 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8091 
    if self.success is not None:
1845 vikas 8092 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8093 
      self.success.write(oprot)
8094 
      oprot.writeFieldEnd()
3431 rajveer 8095 
    if self.utx is not None:
1845 vikas 8096 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8097 
      self.utx.write(oprot)
8098 
      oprot.writeFieldEnd()
8099 
    oprot.writeFieldStop()
8100 
    oprot.writeStructEnd()
8101 
 
3431 rajveer 8102 
  def validate(self):
8103 
    return
8104 
 
8105 
 
1845 vikas 8106 
  def __repr__(self):
8107 
    L = ['%s=%r' % (key, value)
8108 
      for key, value in self.__dict__.iteritems()]
8109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8110 
 
8111 
  def __eq__(self, other):
8112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8113 
 
8114 
  def __ne__(self, other):
8115 
    return not (self == other)
8116 
 
1899 vikas 8117 
class getAllMasterAffiliates_args:
8118 
 
8119 
  thrift_spec = (
8120 
  )
8121 
 
8122 
  def read(self, iprot):
8123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8125 
      return
8126 
    iprot.readStructBegin()
8127 
    while True:
8128 
      (fname, ftype, fid) = iprot.readFieldBegin()
8129 
      if ftype == TType.STOP:
8130 
        break
8131 
      else:
8132 
        iprot.skip(ftype)
8133 
      iprot.readFieldEnd()
8134 
    iprot.readStructEnd()
8135 
 
8136 
  def write(self, oprot):
8137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8139 
      return
8140 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8141 
    oprot.writeFieldStop()
8142 
    oprot.writeStructEnd()
8143 
 
3431 rajveer 8144 
  def validate(self):
8145 
    return
8146 
 
8147 
 
1899 vikas 8148 
  def __repr__(self):
8149 
    L = ['%s=%r' % (key, value)
8150 
      for key, value in self.__dict__.iteritems()]
8151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8152 
 
8153 
  def __eq__(self, other):
8154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8155 
 
8156 
  def __ne__(self, other):
8157 
    return not (self == other)
8158 
 
8159 
class getAllMasterAffiliates_result:
8160 
  """
8161 
  Attributes:
8162 
   - success
8163 
   - utx
8164 
  """
8165 
 
8166 
  thrift_spec = (
8167 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8168 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8169 
  )
8170 
 
8171 
  def __init__(self, success=None, utx=None,):
8172 
    self.success = success
8173 
    self.utx = utx
8174 
 
8175 
  def read(self, iprot):
8176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8178 
      return
8179 
    iprot.readStructBegin()
8180 
    while True:
8181 
      (fname, ftype, fid) = iprot.readFieldBegin()
8182 
      if ftype == TType.STOP:
8183 
        break
8184 
      if fid == 0:
8185 
        if ftype == TType.LIST:
8186 
          self.success = []
11592 amit.gupta 8187 
          (_etype121, _size118) = iprot.readListBegin()
8188 
          for _i122 in xrange(_size118):
8189 
            _elem123 = MasterAffiliate()
8190 
            _elem123.read(iprot)
8191 
            self.success.append(_elem123)
1899 vikas 8192 
          iprot.readListEnd()
8193 
        else:
8194 
          iprot.skip(ftype)
8195 
      elif fid == 1:
8196 
        if ftype == TType.STRUCT:
1996 vikas 8197 
          self.utx = UserAffiliateException()
1899 vikas 8198 
          self.utx.read(iprot)
8199 
        else:
8200 
          iprot.skip(ftype)
8201 
      else:
8202 
        iprot.skip(ftype)
8203 
      iprot.readFieldEnd()
8204 
    iprot.readStructEnd()
8205 
 
8206 
  def write(self, oprot):
8207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8209 
      return
8210 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8211 
    if self.success is not None:
1899 vikas 8212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8213 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8214 
      for iter124 in self.success:
8215 
        iter124.write(oprot)
1899 vikas 8216 
      oprot.writeListEnd()
8217 
      oprot.writeFieldEnd()
3431 rajveer 8218 
    if self.utx is not None:
1899 vikas 8219 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8220 
      self.utx.write(oprot)
8221 
      oprot.writeFieldEnd()
8222 
    oprot.writeFieldStop()
8223 
    oprot.writeStructEnd()
8224 
 
3431 rajveer 8225 
  def validate(self):
8226 
    return
8227 
 
8228 
 
1899 vikas 8229 
  def __repr__(self):
8230 
    L = ['%s=%r' % (key, value)
8231 
      for key, value in self.__dict__.iteritems()]
8232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8233 
 
8234 
  def __eq__(self, other):
8235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8236 
 
8237 
  def __ne__(self, other):
8238 
    return not (self == other)
8239 
 
1845 vikas 8240 
class getMasterAffiliateById_args:
8241 
  """
8242 
  Attributes:
8243 
   - id
8244 
  """
8245 
 
8246 
  thrift_spec = (
8247 
    None, # 0
8248 
    (1, TType.I64, 'id', None, None, ), # 1
8249 
  )
8250 
 
8251 
  def __init__(self, id=None,):
8252 
    self.id = id
8253 
 
8254 
  def read(self, iprot):
8255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8257 
      return
8258 
    iprot.readStructBegin()
8259 
    while True:
8260 
      (fname, ftype, fid) = iprot.readFieldBegin()
8261 
      if ftype == TType.STOP:
8262 
        break
8263 
      if fid == 1:
8264 
        if ftype == TType.I64:
8265 
          self.id = iprot.readI64();
8266 
        else:
8267 
          iprot.skip(ftype)
8268 
      else:
8269 
        iprot.skip(ftype)
8270 
      iprot.readFieldEnd()
8271 
    iprot.readStructEnd()
8272 
 
8273 
  def write(self, oprot):
8274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8276 
      return
8277 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8278 
    if self.id is not None:
1845 vikas 8279 
      oprot.writeFieldBegin('id', TType.I64, 1)
8280 
      oprot.writeI64(self.id)
8281 
      oprot.writeFieldEnd()
8282 
    oprot.writeFieldStop()
8283 
    oprot.writeStructEnd()
8284 
 
3431 rajveer 8285 
  def validate(self):
8286 
    return
8287 
 
8288 
 
1845 vikas 8289 
  def __repr__(self):
8290 
    L = ['%s=%r' % (key, value)
8291 
      for key, value in self.__dict__.iteritems()]
8292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8293 
 
8294 
  def __eq__(self, other):
8295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8296 
 
8297 
  def __ne__(self, other):
8298 
    return not (self == other)
8299 
 
8300 
class getMasterAffiliateById_result:
8301 
  """
8302 
  Attributes:
8303 
   - success
8304 
   - utx
8305 
  """
8306 
 
8307 
  thrift_spec = (
8308 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8309 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8310 
  )
8311 
 
8312 
  def __init__(self, success=None, utx=None,):
8313 
    self.success = success
8314 
    self.utx = utx
8315 
 
8316 
  def read(self, iprot):
8317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8319 
      return
8320 
    iprot.readStructBegin()
8321 
    while True:
8322 
      (fname, ftype, fid) = iprot.readFieldBegin()
8323 
      if ftype == TType.STOP:
8324 
        break
8325 
      if fid == 0:
8326 
        if ftype == TType.STRUCT:
8327 
          self.success = MasterAffiliate()
8328 
          self.success.read(iprot)
8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      elif fid == 1:
8332 
        if ftype == TType.STRUCT:
1996 vikas 8333 
          self.utx = UserAffiliateException()
1845 vikas 8334 
          self.utx.read(iprot)
8335 
        else:
8336 
          iprot.skip(ftype)
8337 
      else:
8338 
        iprot.skip(ftype)
8339 
      iprot.readFieldEnd()
8340 
    iprot.readStructEnd()
8341 
 
8342 
  def write(self, oprot):
8343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8345 
      return
8346 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8347 
    if self.success is not None:
1845 vikas 8348 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8349 
      self.success.write(oprot)
8350 
      oprot.writeFieldEnd()
3431 rajveer 8351 
    if self.utx is not None:
1845 vikas 8352 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8353 
      self.utx.write(oprot)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
3431 rajveer 8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
1845 vikas 8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
8372 
 
8373 
class getMasterAffiliateByName_args:
8374 
  """
8375 
  Attributes:
8376 
   - name
8377 
  """
8378 
 
8379 
  thrift_spec = (
8380 
    None, # 0
8381 
    (1, TType.STRING, 'name', None, None, ), # 1
8382 
  )
8383 
 
8384 
  def __init__(self, name=None,):
8385 
    self.name = name
8386 
 
8387 
  def read(self, iprot):
8388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8390 
      return
8391 
    iprot.readStructBegin()
8392 
    while True:
8393 
      (fname, ftype, fid) = iprot.readFieldBegin()
8394 
      if ftype == TType.STOP:
8395 
        break
8396 
      if fid == 1:
8397 
        if ftype == TType.STRING:
8398 
          self.name = iprot.readString();
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      else:
8402 
        iprot.skip(ftype)
8403 
      iprot.readFieldEnd()
8404 
    iprot.readStructEnd()
8405 
 
8406 
  def write(self, oprot):
8407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8409 
      return
8410 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8411 
    if self.name is not None:
1845 vikas 8412 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8413 
      oprot.writeString(self.name)
8414 
      oprot.writeFieldEnd()
8415 
    oprot.writeFieldStop()
8416 
    oprot.writeStructEnd()
8417 
 
3431 rajveer 8418 
  def validate(self):
8419 
    return
8420 
 
8421 
 
1845 vikas 8422 
  def __repr__(self):
8423 
    L = ['%s=%r' % (key, value)
8424 
      for key, value in self.__dict__.iteritems()]
8425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8426 
 
8427 
  def __eq__(self, other):
8428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8429 
 
8430 
  def __ne__(self, other):
8431 
    return not (self == other)
8432 
 
8433 
class getMasterAffiliateByName_result:
8434 
  """
8435 
  Attributes:
8436 
   - success
8437 
   - utx
8438 
  """
8439 
 
8440 
  thrift_spec = (
8441 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8442 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8443 
  )
8444 
 
8445 
  def __init__(self, success=None, utx=None,):
8446 
    self.success = success
8447 
    self.utx = utx
8448 
 
8449 
  def read(self, iprot):
8450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8452 
      return
8453 
    iprot.readStructBegin()
8454 
    while True:
8455 
      (fname, ftype, fid) = iprot.readFieldBegin()
8456 
      if ftype == TType.STOP:
8457 
        break
8458 
      if fid == 0:
8459 
        if ftype == TType.STRUCT:
8460 
          self.success = MasterAffiliate()
8461 
          self.success.read(iprot)
8462 
        else:
8463 
          iprot.skip(ftype)
8464 
      elif fid == 1:
8465 
        if ftype == TType.STRUCT:
1996 vikas 8466 
          self.utx = UserAffiliateException()
1845 vikas 8467 
          self.utx.read(iprot)
8468 
        else:
8469 
          iprot.skip(ftype)
8470 
      else:
8471 
        iprot.skip(ftype)
8472 
      iprot.readFieldEnd()
8473 
    iprot.readStructEnd()
8474 
 
8475 
  def write(self, oprot):
8476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8478 
      return
8479 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8480 
    if self.success is not None:
1845 vikas 8481 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8482 
      self.success.write(oprot)
8483 
      oprot.writeFieldEnd()
3431 rajveer 8484 
    if self.utx is not None:
1845 vikas 8485 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8486 
      self.utx.write(oprot)
8487 
      oprot.writeFieldEnd()
8488 
    oprot.writeFieldStop()
8489 
    oprot.writeStructEnd()
8490 
 
3431 rajveer 8491 
  def validate(self):
8492 
    return
8493 
 
8494 
 
1845 vikas 8495 
  def __repr__(self):
8496 
    L = ['%s=%r' % (key, value)
8497 
      for key, value in self.__dict__.iteritems()]
8498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8499 
 
8500 
  def __eq__(self, other):
8501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8502 
 
8503 
  def __ne__(self, other):
8504 
    return not (self == other)
8505 
 
8506 
class createAffiliate_args:
8507 
  """
8508 
  Attributes:
8509 
   - name
8510 
   - url
8511 
   - masterAffiliateId
1859 vikas 8512 
   - addedOn
1845 vikas 8513 
  """
8514 
 
8515 
  thrift_spec = (
8516 
    None, # 0
8517 
    (1, TType.STRING, 'name', None, None, ), # 1
8518 
    (2, TType.STRING, 'url', None, None, ), # 2
8519 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8520 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8521 
  )
8522 
 
1859 vikas 8523 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8524 
    self.name = name
8525 
    self.url = url
8526 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8527 
    self.addedOn = addedOn
1845 vikas 8528 
 
8529 
  def read(self, iprot):
8530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8532 
      return
8533 
    iprot.readStructBegin()
8534 
    while True:
8535 
      (fname, ftype, fid) = iprot.readFieldBegin()
8536 
      if ftype == TType.STOP:
8537 
        break
8538 
      if fid == 1:
8539 
        if ftype == TType.STRING:
8540 
          self.name = iprot.readString();
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 2:
8544 
        if ftype == TType.STRING:
8545 
          self.url = iprot.readString();
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      elif fid == 3:
8549 
        if ftype == TType.I64:
8550 
          self.masterAffiliateId = iprot.readI64();
8551 
        else:
8552 
          iprot.skip(ftype)
1859 vikas 8553 
      elif fid == 4:
8554 
        if ftype == TType.I64:
8555 
          self.addedOn = iprot.readI64();
8556 
        else:
8557 
          iprot.skip(ftype)
1845 vikas 8558 
      else:
8559 
        iprot.skip(ftype)
8560 
      iprot.readFieldEnd()
8561 
    iprot.readStructEnd()
8562 
 
8563 
  def write(self, oprot):
8564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8566 
      return
8567 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8568 
    if self.name is not None:
1845 vikas 8569 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8570 
      oprot.writeString(self.name)
8571 
      oprot.writeFieldEnd()
3431 rajveer 8572 
    if self.url is not None:
1845 vikas 8573 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8574 
      oprot.writeString(self.url)
8575 
      oprot.writeFieldEnd()
3431 rajveer 8576 
    if self.masterAffiliateId is not None:
1845 vikas 8577 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8578 
      oprot.writeI64(self.masterAffiliateId)
8579 
      oprot.writeFieldEnd()
3431 rajveer 8580 
    if self.addedOn is not None:
1859 vikas 8581 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8582 
      oprot.writeI64(self.addedOn)
8583 
      oprot.writeFieldEnd()
1845 vikas 8584 
    oprot.writeFieldStop()
8585 
    oprot.writeStructEnd()
8586 
 
3431 rajveer 8587 
  def validate(self):
8588 
    return
8589 
 
8590 
 
1845 vikas 8591 
  def __repr__(self):
8592 
    L = ['%s=%r' % (key, value)
8593 
      for key, value in self.__dict__.iteritems()]
8594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8595 
 
8596 
  def __eq__(self, other):
8597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8598 
 
8599 
  def __ne__(self, other):
8600 
    return not (self == other)
8601 
 
8602 
class createAffiliate_result:
8603 
  """
8604 
  Attributes:
8605 
   - success
8606 
   - utx
8607 
  """
8608 
 
8609 
  thrift_spec = (
8610 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8611 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8612 
  )
8613 
 
8614 
  def __init__(self, success=None, utx=None,):
8615 
    self.success = success
8616 
    self.utx = utx
8617 
 
8618 
  def read(self, iprot):
8619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8621 
      return
8622 
    iprot.readStructBegin()
8623 
    while True:
8624 
      (fname, ftype, fid) = iprot.readFieldBegin()
8625 
      if ftype == TType.STOP:
8626 
        break
8627 
      if fid == 0:
8628 
        if ftype == TType.STRUCT:
8629 
          self.success = Affiliate()
8630 
          self.success.read(iprot)
8631 
        else:
8632 
          iprot.skip(ftype)
8633 
      elif fid == 1:
8634 
        if ftype == TType.STRUCT:
1996 vikas 8635 
          self.utx = UserAffiliateException()
1845 vikas 8636 
          self.utx.read(iprot)
8637 
        else:
8638 
          iprot.skip(ftype)
8639 
      else:
8640 
        iprot.skip(ftype)
8641 
      iprot.readFieldEnd()
8642 
    iprot.readStructEnd()
8643 
 
8644 
  def write(self, oprot):
8645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8647 
      return
8648 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8649 
    if self.success is not None:
1845 vikas 8650 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8651 
      self.success.write(oprot)
8652 
      oprot.writeFieldEnd()
3431 rajveer 8653 
    if self.utx is not None:
1845 vikas 8654 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8655 
      self.utx.write(oprot)
8656 
      oprot.writeFieldEnd()
8657 
    oprot.writeFieldStop()
8658 
    oprot.writeStructEnd()
8659 
 
3431 rajveer 8660 
  def validate(self):
8661 
    return
8662 
 
8663 
 
1845 vikas 8664 
  def __repr__(self):
8665 
    L = ['%s=%r' % (key, value)
8666 
      for key, value in self.__dict__.iteritems()]
8667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8668 
 
8669 
  def __eq__(self, other):
8670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8671 
 
8672 
  def __ne__(self, other):
8673 
    return not (self == other)
8674 
 
8675 
class getAffiliateById_args:
8676 
  """
8677 
  Attributes:
8678 
   - id
8679 
  """
8680 
 
8681 
  thrift_spec = (
8682 
    None, # 0
8683 
    (1, TType.I64, 'id', None, None, ), # 1
8684 
  )
8685 
 
8686 
  def __init__(self, id=None,):
8687 
    self.id = id
8688 
 
8689 
  def read(self, iprot):
8690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8692 
      return
8693 
    iprot.readStructBegin()
8694 
    while True:
8695 
      (fname, ftype, fid) = iprot.readFieldBegin()
8696 
      if ftype == TType.STOP:
8697 
        break
8698 
      if fid == 1:
8699 
        if ftype == TType.I64:
8700 
          self.id = iprot.readI64();
8701 
        else:
8702 
          iprot.skip(ftype)
8703 
      else:
8704 
        iprot.skip(ftype)
8705 
      iprot.readFieldEnd()
8706 
    iprot.readStructEnd()
8707 
 
8708 
  def write(self, oprot):
8709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8711 
      return
8712 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8713 
    if self.id is not None:
1845 vikas 8714 
      oprot.writeFieldBegin('id', TType.I64, 1)
8715 
      oprot.writeI64(self.id)
8716 
      oprot.writeFieldEnd()
8717 
    oprot.writeFieldStop()
8718 
    oprot.writeStructEnd()
8719 
 
3431 rajveer 8720 
  def validate(self):
8721 
    return
8722 
 
8723 
 
1845 vikas 8724 
  def __repr__(self):
8725 
    L = ['%s=%r' % (key, value)
8726 
      for key, value in self.__dict__.iteritems()]
8727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8728 
 
8729 
  def __eq__(self, other):
8730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8731 
 
8732 
  def __ne__(self, other):
8733 
    return not (self == other)
8734 
 
8735 
class getAffiliateById_result:
8736 
  """
8737 
  Attributes:
8738 
   - success
8739 
   - utx
8740 
  """
8741 
 
8742 
  thrift_spec = (
8743 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8744 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8745 
  )
8746 
 
8747 
  def __init__(self, success=None, utx=None,):
8748 
    self.success = success
8749 
    self.utx = utx
8750 
 
8751 
  def read(self, iprot):
8752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8754 
      return
8755 
    iprot.readStructBegin()
8756 
    while True:
8757 
      (fname, ftype, fid) = iprot.readFieldBegin()
8758 
      if ftype == TType.STOP:
8759 
        break
8760 
      if fid == 0:
8761 
        if ftype == TType.STRUCT:
8762 
          self.success = Affiliate()
8763 
          self.success.read(iprot)
8764 
        else:
8765 
          iprot.skip(ftype)
8766 
      elif fid == 1:
8767 
        if ftype == TType.STRUCT:
1996 vikas 8768 
          self.utx = UserAffiliateException()
1845 vikas 8769 
          self.utx.read(iprot)
8770 
        else:
8771 
          iprot.skip(ftype)
8772 
      else:
8773 
        iprot.skip(ftype)
8774 
      iprot.readFieldEnd()
8775 
    iprot.readStructEnd()
8776 
 
8777 
  def write(self, oprot):
8778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8780 
      return
8781 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 8782 
    if self.success is not None:
1845 vikas 8783 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8784 
      self.success.write(oprot)
8785 
      oprot.writeFieldEnd()
3431 rajveer 8786 
    if self.utx is not None:
1845 vikas 8787 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8788 
      self.utx.write(oprot)
8789 
      oprot.writeFieldEnd()
8790 
    oprot.writeFieldStop()
8791 
    oprot.writeStructEnd()
8792 
 
3431 rajveer 8793 
  def validate(self):
8794 
    return
8795 
 
8796 
 
1845 vikas 8797 
  def __repr__(self):
8798 
    L = ['%s=%r' % (key, value)
8799 
      for key, value in self.__dict__.iteritems()]
8800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8801 
 
8802 
  def __eq__(self, other):
8803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8804 
 
8805 
  def __ne__(self, other):
8806 
    return not (self == other)
8807 
 
8808 
class getAffiliateByName_args:
8809 
  """
8810 
  Attributes:
8811 
   - name
8812 
  """
8813 
 
8814 
  thrift_spec = (
8815 
    None, # 0
8816 
    (1, TType.STRING, 'name', None, None, ), # 1
8817 
  )
8818 
 
8819 
  def __init__(self, name=None,):
8820 
    self.name = name
8821 
 
8822 
  def read(self, iprot):
8823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8825 
      return
8826 
    iprot.readStructBegin()
8827 
    while True:
8828 
      (fname, ftype, fid) = iprot.readFieldBegin()
8829 
      if ftype == TType.STOP:
8830 
        break
8831 
      if fid == 1:
8832 
        if ftype == TType.STRING:
8833 
          self.name = iprot.readString();
8834 
        else:
8835 
          iprot.skip(ftype)
8836 
      else:
8837 
        iprot.skip(ftype)
8838 
      iprot.readFieldEnd()
8839 
    iprot.readStructEnd()
8840 
 
8841 
  def write(self, oprot):
8842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8844 
      return
8845 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 8846 
    if self.name is not None:
1845 vikas 8847 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8848 
      oprot.writeString(self.name)
8849 
      oprot.writeFieldEnd()
8850 
    oprot.writeFieldStop()
8851 
    oprot.writeStructEnd()
8852 
 
3431 rajveer 8853 
  def validate(self):
8854 
    return
8855 
 
8856 
 
1845 vikas 8857 
  def __repr__(self):
8858 
    L = ['%s=%r' % (key, value)
8859 
      for key, value in self.__dict__.iteritems()]
8860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8861 
 
8862 
  def __eq__(self, other):
8863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8864 
 
8865 
  def __ne__(self, other):
8866 
    return not (self == other)
8867 
 
8868 
class getAffiliateByName_result:
8869 
  """
8870 
  Attributes:
8871 
   - success
8872 
   - utx
8873 
  """
8874 
 
8875 
  thrift_spec = (
8876 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8877 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8878 
  )
8879 
 
8880 
  def __init__(self, success=None, utx=None,):
8881 
    self.success = success
8882 
    self.utx = utx
8883 
 
8884 
  def read(self, iprot):
8885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8887 
      return
8888 
    iprot.readStructBegin()
8889 
    while True:
8890 
      (fname, ftype, fid) = iprot.readFieldBegin()
8891 
      if ftype == TType.STOP:
8892 
        break
8893 
      if fid == 0:
8894 
        if ftype == TType.STRUCT:
8895 
          self.success = Affiliate()
8896 
          self.success.read(iprot)
8897 
        else:
8898 
          iprot.skip(ftype)
8899 
      elif fid == 1:
8900 
        if ftype == TType.STRUCT:
1996 vikas 8901 
          self.utx = UserAffiliateException()
1845 vikas 8902 
          self.utx.read(iprot)
8903 
        else:
8904 
          iprot.skip(ftype)
8905 
      else:
8906 
        iprot.skip(ftype)
8907 
      iprot.readFieldEnd()
8908 
    iprot.readStructEnd()
8909 
 
8910 
  def write(self, oprot):
8911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8913 
      return
8914 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 8915 
    if self.success is not None:
1845 vikas 8916 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8917 
      self.success.write(oprot)
8918 
      oprot.writeFieldEnd()
3431 rajveer 8919 
    if self.utx is not None:
1845 vikas 8920 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8921 
      self.utx.write(oprot)
8922 
      oprot.writeFieldEnd()
8923 
    oprot.writeFieldStop()
8924 
    oprot.writeStructEnd()
8925 
 
3431 rajveer 8926 
  def validate(self):
8927 
    return
8928 
 
8929 
 
1845 vikas 8930 
  def __repr__(self):
8931 
    L = ['%s=%r' % (key, value)
8932 
      for key, value in self.__dict__.iteritems()]
8933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8934 
 
8935 
  def __eq__(self, other):
8936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8937 
 
8938 
  def __ne__(self, other):
8939 
    return not (self == other)
8940 
 
1996 vikas 8941 
class getTrackerById_args:
1845 vikas 8942 
  """
8943 
  Attributes:
8944 
   - id
8945 
  """
8946 
 
8947 
  thrift_spec = (
8948 
    None, # 0
8949 
    (1, TType.I64, 'id', None, None, ), # 1
8950 
  )
8951 
 
8952 
  def __init__(self, id=None,):
8953 
    self.id = id
8954 
 
8955 
  def read(self, iprot):
8956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8958 
      return
8959 
    iprot.readStructBegin()
8960 
    while True:
8961 
      (fname, ftype, fid) = iprot.readFieldBegin()
8962 
      if ftype == TType.STOP:
8963 
        break
8964 
      if fid == 1:
8965 
        if ftype == TType.I64:
8966 
          self.id = iprot.readI64();
8967 
        else:
8968 
          iprot.skip(ftype)
8969 
      else:
8970 
        iprot.skip(ftype)
8971 
      iprot.readFieldEnd()
8972 
    iprot.readStructEnd()
8973 
 
8974 
  def write(self, oprot):
8975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8977 
      return
1996 vikas 8978 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 8979 
    if self.id is not None:
1845 vikas 8980 
      oprot.writeFieldBegin('id', TType.I64, 1)
8981 
      oprot.writeI64(self.id)
8982 
      oprot.writeFieldEnd()
8983 
    oprot.writeFieldStop()
8984 
    oprot.writeStructEnd()
8985 
 
3431 rajveer 8986 
  def validate(self):
8987 
    return
8988 
 
8989 
 
1845 vikas 8990 
  def __repr__(self):
8991 
    L = ['%s=%r' % (key, value)
8992 
      for key, value in self.__dict__.iteritems()]
8993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8994 
 
8995 
  def __eq__(self, other):
8996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8997 
 
8998 
  def __ne__(self, other):
8999 
    return not (self == other)
9000 
 
9001 
class getTrackerById_result:
9002 
  """
9003 
  Attributes:
9004 
   - success
9005 
   - utx
9006 
  """
9007 
 
9008 
  thrift_spec = (
9009 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9010 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9011 
  )
9012 
 
9013 
  def __init__(self, success=None, utx=None,):
9014 
    self.success = success
9015 
    self.utx = utx
9016 
 
9017 
  def read(self, iprot):
9018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9020 
      return
9021 
    iprot.readStructBegin()
9022 
    while True:
9023 
      (fname, ftype, fid) = iprot.readFieldBegin()
9024 
      if ftype == TType.STOP:
9025 
        break
9026 
      if fid == 0:
9027 
        if ftype == TType.STRUCT:
9028 
          self.success = Tracker()
9029 
          self.success.read(iprot)
9030 
        else:
9031 
          iprot.skip(ftype)
9032 
      elif fid == 1:
9033 
        if ftype == TType.STRUCT:
1996 vikas 9034 
          self.utx = UserAffiliateException()
1845 vikas 9035 
          self.utx.read(iprot)
9036 
        else:
9037 
          iprot.skip(ftype)
9038 
      else:
9039 
        iprot.skip(ftype)
9040 
      iprot.readFieldEnd()
9041 
    iprot.readStructEnd()
9042 
 
9043 
  def write(self, oprot):
9044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9046 
      return
9047 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9048 
    if self.success is not None:
1845 vikas 9049 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9050 
      self.success.write(oprot)
9051 
      oprot.writeFieldEnd()
3431 rajveer 9052 
    if self.utx is not None:
1845 vikas 9053 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9054 
      self.utx.write(oprot)
9055 
      oprot.writeFieldEnd()
9056 
    oprot.writeFieldStop()
9057 
    oprot.writeStructEnd()
9058 
 
3431 rajveer 9059 
  def validate(self):
9060 
    return
9061 
 
9062 
 
1845 vikas 9063 
  def __repr__(self):
9064 
    L = ['%s=%r' % (key, value)
9065 
      for key, value in self.__dict__.iteritems()]
9066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9067 
 
9068 
  def __eq__(self, other):
9069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9070 
 
9071 
  def __ne__(self, other):
9072 
    return not (self == other)
9073 
 
1996 vikas 9074 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9075 
  """
9076 
  Attributes:
1996 vikas 9077 
   - id
1845 vikas 9078 
  """
9079 
 
9080 
  thrift_spec = (
9081 
    None, # 0
1996 vikas 9082 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9083 
  )
9084 
 
1996 vikas 9085 
  def __init__(self, id=None,):
9086 
    self.id = id
1845 vikas 9087 
 
9088 
  def read(self, iprot):
9089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9091 
      return
9092 
    iprot.readStructBegin()
9093 
    while True:
9094 
      (fname, ftype, fid) = iprot.readFieldBegin()
9095 
      if ftype == TType.STOP:
9096 
        break
9097 
      if fid == 1:
9098 
        if ftype == TType.I64:
1996 vikas 9099 
          self.id = iprot.readI64();
1845 vikas 9100 
        else:
9101 
          iprot.skip(ftype)
9102 
      else:
9103 
        iprot.skip(ftype)
9104 
      iprot.readFieldEnd()
9105 
    iprot.readStructEnd()
9106 
 
9107 
  def write(self, oprot):
9108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9110 
      return
1996 vikas 9111 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9112 
    if self.id is not None:
1996 vikas 9113 
      oprot.writeFieldBegin('id', TType.I64, 1)
9114 
      oprot.writeI64(self.id)
1845 vikas 9115 
      oprot.writeFieldEnd()
9116 
    oprot.writeFieldStop()
9117 
    oprot.writeStructEnd()
9118 
 
3431 rajveer 9119 
  def validate(self):
9120 
    return
9121 
 
9122 
 
1845 vikas 9123 
  def __repr__(self):
9124 
    L = ['%s=%r' % (key, value)
9125 
      for key, value in self.__dict__.iteritems()]
9126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9127 
 
9128 
  def __eq__(self, other):
9129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9130 
 
9131 
  def __ne__(self, other):
9132 
    return not (self == other)
9133 
 
1996 vikas 9134 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9135 
  """
9136 
  Attributes:
9137 
   - success
9138 
   - utx
9139 
  """
9140 
 
9141 
  thrift_spec = (
1996 vikas 9142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9143 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9144 
  )
9145 
 
9146 
  def __init__(self, success=None, utx=None,):
9147 
    self.success = success
9148 
    self.utx = utx
9149 
 
9150 
  def read(self, iprot):
9151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9153 
      return
9154 
    iprot.readStructBegin()
9155 
    while True:
9156 
      (fname, ftype, fid) = iprot.readFieldBegin()
9157 
      if ftype == TType.STOP:
9158 
        break
9159 
      if fid == 0:
9160 
        if ftype == TType.LIST:
9161 
          self.success = []
11592 amit.gupta 9162 
          (_etype128, _size125) = iprot.readListBegin()
9163 
          for _i129 in xrange(_size125):
9164 
            _elem130 = Affiliate()
9165 
            _elem130.read(iprot)
9166 
            self.success.append(_elem130)
1845 vikas 9167 
          iprot.readListEnd()
9168 
        else:
9169 
          iprot.skip(ftype)
9170 
      elif fid == 1:
9171 
        if ftype == TType.STRUCT:
1996 vikas 9172 
          self.utx = UserAffiliateException()
1845 vikas 9173 
          self.utx.read(iprot)
9174 
        else:
9175 
          iprot.skip(ftype)
9176 
      else:
9177 
        iprot.skip(ftype)
9178 
      iprot.readFieldEnd()
9179 
    iprot.readStructEnd()
9180 
 
9181 
  def write(self, oprot):
9182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9184 
      return
1996 vikas 9185 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9186 
    if self.success is not None:
1845 vikas 9187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9189 
      for iter131 in self.success:
9190 
        iter131.write(oprot)
1845 vikas 9191 
      oprot.writeListEnd()
9192 
      oprot.writeFieldEnd()
3431 rajveer 9193 
    if self.utx is not None:
1845 vikas 9194 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9195 
      self.utx.write(oprot)
9196 
      oprot.writeFieldEnd()
9197 
    oprot.writeFieldStop()
9198 
    oprot.writeStructEnd()
9199 
 
3431 rajveer 9200 
  def validate(self):
9201 
    return
9202 
 
9203 
 
1845 vikas 9204 
  def __repr__(self):
9205 
    L = ['%s=%r' % (key, value)
9206 
      for key, value in self.__dict__.iteritems()]
9207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9208 
 
9209 
  def __eq__(self, other):
9210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9211 
 
9212 
  def __ne__(self, other):
9213 
    return not (self == other)
9214 
 
9215 
class addTrackLog_args:
9216 
  """
9217 
  Attributes:
1996 vikas 9218 
   - affiliateId
1845 vikas 9219 
   - userId
9220 
   - event
9221 
   - url
9222 
   - data
1859 vikas 9223 
   - addedOn
1845 vikas 9224 
  """
9225 
 
9226 
  thrift_spec = (
9227 
    None, # 0
1996 vikas 9228 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9229 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9230 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9231 
    (4, TType.STRING, 'url', None, None, ), # 4
9232 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9233 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9234 
  )
9235 
 
1996 vikas 9236 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9237 
    self.affiliateId = affiliateId
1845 vikas 9238 
    self.userId = userId
9239 
    self.event = event
9240 
    self.url = url
9241 
    self.data = data
1859 vikas 9242 
    self.addedOn = addedOn
1845 vikas 9243 
 
9244 
  def read(self, iprot):
9245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9247 
      return
9248 
    iprot.readStructBegin()
9249 
    while True:
9250 
      (fname, ftype, fid) = iprot.readFieldBegin()
9251 
      if ftype == TType.STOP:
9252 
        break
9253 
      if fid == 1:
9254 
        if ftype == TType.I64:
1996 vikas 9255 
          self.affiliateId = iprot.readI64();
1845 vikas 9256 
        else:
9257 
          iprot.skip(ftype)
9258 
      elif fid == 2:
9259 
        if ftype == TType.I64:
9260 
          self.userId = iprot.readI64();
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      elif fid == 3:
3378 vikas 9264 
        if ftype == TType.I32:
9265 
          self.event = iprot.readI32();
1845 vikas 9266 
        else:
9267 
          iprot.skip(ftype)
9268 
      elif fid == 4:
9269 
        if ftype == TType.STRING:
9270 
          self.url = iprot.readString();
9271 
        else:
9272 
          iprot.skip(ftype)
9273 
      elif fid == 5:
9274 
        if ftype == TType.STRING:
9275 
          self.data = iprot.readString();
9276 
        else:
9277 
          iprot.skip(ftype)
1859 vikas 9278 
      elif fid == 6:
9279 
        if ftype == TType.I64:
9280 
          self.addedOn = iprot.readI64();
9281 
        else:
9282 
          iprot.skip(ftype)
1845 vikas 9283 
      else:
9284 
        iprot.skip(ftype)
9285 
      iprot.readFieldEnd()
9286 
    iprot.readStructEnd()
9287 
 
9288 
  def write(self, oprot):
9289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9291 
      return
9292 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9293 
    if self.affiliateId is not None:
1996 vikas 9294 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9295 
      oprot.writeI64(self.affiliateId)
1845 vikas 9296 
      oprot.writeFieldEnd()
3431 rajveer 9297 
    if self.userId is not None:
1845 vikas 9298 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9299 
      oprot.writeI64(self.userId)
9300 
      oprot.writeFieldEnd()
3431 rajveer 9301 
    if self.event is not None:
3378 vikas 9302 
      oprot.writeFieldBegin('event', TType.I32, 3)
9303 
      oprot.writeI32(self.event)
1845 vikas 9304 
      oprot.writeFieldEnd()
3431 rajveer 9305 
    if self.url is not None:
1845 vikas 9306 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9307 
      oprot.writeString(self.url)
9308 
      oprot.writeFieldEnd()
3431 rajveer 9309 
    if self.data is not None:
1845 vikas 9310 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9311 
      oprot.writeString(self.data)
9312 
      oprot.writeFieldEnd()
3431 rajveer 9313 
    if self.addedOn is not None:
1859 vikas 9314 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9315 
      oprot.writeI64(self.addedOn)
9316 
      oprot.writeFieldEnd()
1845 vikas 9317 
    oprot.writeFieldStop()
9318 
    oprot.writeStructEnd()
9319 
 
3431 rajveer 9320 
  def validate(self):
9321 
    return
9322 
 
9323 
 
1845 vikas 9324 
  def __repr__(self):
9325 
    L = ['%s=%r' % (key, value)
9326 
      for key, value in self.__dict__.iteritems()]
9327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9328 
 
9329 
  def __eq__(self, other):
9330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9331 
 
9332 
  def __ne__(self, other):
9333 
    return not (self == other)
9334 
 
9335 
class addTrackLog_result:
9336 
  """
9337 
  Attributes:
9338 
   - success
9339 
   - utx
9340 
  """
9341 
 
9342 
  thrift_spec = (
9343 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9344 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9345 
  )
9346 
 
9347 
  def __init__(self, success=None, utx=None,):
9348 
    self.success = success
9349 
    self.utx = utx
9350 
 
9351 
  def read(self, iprot):
9352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9354 
      return
9355 
    iprot.readStructBegin()
9356 
    while True:
9357 
      (fname, ftype, fid) = iprot.readFieldBegin()
9358 
      if ftype == TType.STOP:
9359 
        break
9360 
      if fid == 0:
9361 
        if ftype == TType.I64:
9362 
          self.success = iprot.readI64();
9363 
        else:
9364 
          iprot.skip(ftype)
9365 
      elif fid == 1:
9366 
        if ftype == TType.STRUCT:
1996 vikas 9367 
          self.utx = UserAffiliateException()
1845 vikas 9368 
          self.utx.read(iprot)
9369 
        else:
9370 
          iprot.skip(ftype)
9371 
      else:
9372 
        iprot.skip(ftype)
9373 
      iprot.readFieldEnd()
9374 
    iprot.readStructEnd()
9375 
 
9376 
  def write(self, oprot):
9377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9379 
      return
9380 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9381 
    if self.success is not None:
1845 vikas 9382 
      oprot.writeFieldBegin('success', TType.I64, 0)
9383 
      oprot.writeI64(self.success)
9384 
      oprot.writeFieldEnd()
3431 rajveer 9385 
    if self.utx is not None:
1845 vikas 9386 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9387 
      self.utx.write(oprot)
9388 
      oprot.writeFieldEnd()
9389 
    oprot.writeFieldStop()
9390 
    oprot.writeStructEnd()
9391 
 
3431 rajveer 9392 
  def validate(self):
9393 
    return
9394 
 
9395 
 
1845 vikas 9396 
  def __repr__(self):
9397 
    L = ['%s=%r' % (key, value)
9398 
      for key, value in self.__dict__.iteritems()]
9399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9400 
 
9401 
  def __eq__(self, other):
9402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9403 
 
9404 
  def __ne__(self, other):
9405 
    return not (self == other)
9406 
 
9407 
class getTrackLogById_args:
9408 
  """
9409 
  Attributes:
9410 
   - id
9411 
  """
9412 
 
9413 
  thrift_spec = (
9414 
    None, # 0
9415 
    (1, TType.I64, 'id', None, None, ), # 1
9416 
  )
9417 
 
9418 
  def __init__(self, id=None,):
9419 
    self.id = id
9420 
 
9421 
  def read(self, iprot):
9422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9424 
      return
9425 
    iprot.readStructBegin()
9426 
    while True:
9427 
      (fname, ftype, fid) = iprot.readFieldBegin()
9428 
      if ftype == TType.STOP:
9429 
        break
9430 
      if fid == 1:
9431 
        if ftype == TType.I64:
9432 
          self.id = iprot.readI64();
9433 
        else:
9434 
          iprot.skip(ftype)
9435 
      else:
9436 
        iprot.skip(ftype)
9437 
      iprot.readFieldEnd()
9438 
    iprot.readStructEnd()
9439 
 
9440 
  def write(self, oprot):
9441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9443 
      return
9444 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9445 
    if self.id is not None:
1845 vikas 9446 
      oprot.writeFieldBegin('id', TType.I64, 1)
9447 
      oprot.writeI64(self.id)
9448 
      oprot.writeFieldEnd()
9449 
    oprot.writeFieldStop()
9450 
    oprot.writeStructEnd()
9451 
 
3431 rajveer 9452 
  def validate(self):
9453 
    return
9454 
 
9455 
 
1845 vikas 9456 
  def __repr__(self):
9457 
    L = ['%s=%r' % (key, value)
9458 
      for key, value in self.__dict__.iteritems()]
9459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9460 
 
9461 
  def __eq__(self, other):
9462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9463 
 
9464 
  def __ne__(self, other):
9465 
    return not (self == other)
9466 
 
9467 
class getTrackLogById_result:
9468 
  """
9469 
  Attributes:
9470 
   - success
9471 
   - utx
9472 
  """
9473 
 
9474 
  thrift_spec = (
9475 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9476 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9477 
  )
9478 
 
9479 
  def __init__(self, success=None, utx=None,):
9480 
    self.success = success
9481 
    self.utx = utx
9482 
 
9483 
  def read(self, iprot):
9484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9486 
      return
9487 
    iprot.readStructBegin()
9488 
    while True:
9489 
      (fname, ftype, fid) = iprot.readFieldBegin()
9490 
      if ftype == TType.STOP:
9491 
        break
9492 
      if fid == 0:
9493 
        if ftype == TType.STRUCT:
9494 
          self.success = TrackLog()
9495 
          self.success.read(iprot)
9496 
        else:
9497 
          iprot.skip(ftype)
9498 
      elif fid == 1:
9499 
        if ftype == TType.STRUCT:
1996 vikas 9500 
          self.utx = UserAffiliateException()
1845 vikas 9501 
          self.utx.read(iprot)
9502 
        else:
9503 
          iprot.skip(ftype)
9504 
      else:
9505 
        iprot.skip(ftype)
9506 
      iprot.readFieldEnd()
9507 
    iprot.readStructEnd()
9508 
 
9509 
  def write(self, oprot):
9510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9512 
      return
9513 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9514 
    if self.success is not None:
1845 vikas 9515 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9516 
      self.success.write(oprot)
9517 
      oprot.writeFieldEnd()
3431 rajveer 9518 
    if self.utx is not None:
1845 vikas 9519 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9520 
      self.utx.write(oprot)
9521 
      oprot.writeFieldEnd()
9522 
    oprot.writeFieldStop()
9523 
    oprot.writeStructEnd()
9524 
 
3431 rajveer 9525 
  def validate(self):
9526 
    return
9527 
 
9528 
 
1845 vikas 9529 
  def __repr__(self):
9530 
    L = ['%s=%r' % (key, value)
9531 
      for key, value in self.__dict__.iteritems()]
9532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9533 
 
9534 
  def __eq__(self, other):
9535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9536 
 
9537 
  def __ne__(self, other):
9538 
    return not (self == other)
9539 
 
1996 vikas 9540 
class getTrackLogsByAffiliate_args:
1845 vikas 9541 
  """
9542 
  Attributes:
1996 vikas 9543 
   - affiliateId
3293 vikas 9544 
   - startDate
9545 
   - endDate
1845 vikas 9546 
  """
9547 
 
9548 
  thrift_spec = (
9549 
    None, # 0
1996 vikas 9550 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9551 
    (2, TType.I64, 'startDate', None, None, ), # 2
9552 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9553 
  )
9554 
 
3293 vikas 9555 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9556 
    self.affiliateId = affiliateId
3293 vikas 9557 
    self.startDate = startDate
9558 
    self.endDate = endDate
1845 vikas 9559 
 
9560 
  def read(self, iprot):
9561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9563 
      return
9564 
    iprot.readStructBegin()
9565 
    while True:
9566 
      (fname, ftype, fid) = iprot.readFieldBegin()
9567 
      if ftype == TType.STOP:
9568 
        break
9569 
      if fid == 1:
9570 
        if ftype == TType.I64:
1996 vikas 9571 
          self.affiliateId = iprot.readI64();
1845 vikas 9572 
        else:
9573 
          iprot.skip(ftype)
3293 vikas 9574 
      elif fid == 2:
9575 
        if ftype == TType.I64:
9576 
          self.startDate = iprot.readI64();
9577 
        else:
9578 
          iprot.skip(ftype)
9579 
      elif fid == 3:
9580 
        if ftype == TType.I64:
9581 
          self.endDate = iprot.readI64();
9582 
        else:
9583 
          iprot.skip(ftype)
1845 vikas 9584 
      else:
9585 
        iprot.skip(ftype)
9586 
      iprot.readFieldEnd()
9587 
    iprot.readStructEnd()
9588 
 
9589 
  def write(self, oprot):
9590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9592 
      return
1996 vikas 9593 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9594 
    if self.affiliateId is not None:
1996 vikas 9595 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9596 
      oprot.writeI64(self.affiliateId)
1845 vikas 9597 
      oprot.writeFieldEnd()
3431 rajveer 9598 
    if self.startDate is not None:
3293 vikas 9599 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9600 
      oprot.writeI64(self.startDate)
9601 
      oprot.writeFieldEnd()
3431 rajveer 9602 
    if self.endDate is not None:
3293 vikas 9603 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9604 
      oprot.writeI64(self.endDate)
9605 
      oprot.writeFieldEnd()
1845 vikas 9606 
    oprot.writeFieldStop()
9607 
    oprot.writeStructEnd()
9608 
 
3431 rajveer 9609 
  def validate(self):
9610 
    return
9611 
 
9612 
 
1845 vikas 9613 
  def __repr__(self):
9614 
    L = ['%s=%r' % (key, value)
9615 
      for key, value in self.__dict__.iteritems()]
9616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9617 
 
9618 
  def __eq__(self, other):
9619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9620 
 
9621 
  def __ne__(self, other):
9622 
    return not (self == other)
9623 
 
1996 vikas 9624 
class getTrackLogsByAffiliate_result:
1845 vikas 9625 
  """
9626 
  Attributes:
9627 
   - success
9628 
   - utx
9629 
  """
9630 
 
9631 
  thrift_spec = (
9632 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9633 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9634 
  )
9635 
 
9636 
  def __init__(self, success=None, utx=None,):
9637 
    self.success = success
9638 
    self.utx = utx
9639 
 
9640 
  def read(self, iprot):
9641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9643 
      return
9644 
    iprot.readStructBegin()
9645 
    while True:
9646 
      (fname, ftype, fid) = iprot.readFieldBegin()
9647 
      if ftype == TType.STOP:
9648 
        break
9649 
      if fid == 0:
9650 
        if ftype == TType.LIST:
9651 
          self.success = []
11592 amit.gupta 9652 
          (_etype135, _size132) = iprot.readListBegin()
9653 
          for _i136 in xrange(_size132):
9654 
            _elem137 = TrackLog()
9655 
            _elem137.read(iprot)
9656 
            self.success.append(_elem137)
1845 vikas 9657 
          iprot.readListEnd()
9658 
        else:
9659 
          iprot.skip(ftype)
9660 
      elif fid == 1:
9661 
        if ftype == TType.STRUCT:
1996 vikas 9662 
          self.utx = UserAffiliateException()
1845 vikas 9663 
          self.utx.read(iprot)
9664 
        else:
9665 
          iprot.skip(ftype)
9666 
      else:
9667 
        iprot.skip(ftype)
9668 
      iprot.readFieldEnd()
9669 
    iprot.readStructEnd()
9670 
 
9671 
  def write(self, oprot):
9672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9674 
      return
1996 vikas 9675 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9676 
    if self.success is not None:
1845 vikas 9677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9678 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9679 
      for iter138 in self.success:
9680 
        iter138.write(oprot)
1845 vikas 9681 
      oprot.writeListEnd()
9682 
      oprot.writeFieldEnd()
3431 rajveer 9683 
    if self.utx is not None:
1845 vikas 9684 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9685 
      self.utx.write(oprot)
9686 
      oprot.writeFieldEnd()
9687 
    oprot.writeFieldStop()
9688 
    oprot.writeStructEnd()
9689 
 
3431 rajveer 9690 
  def validate(self):
9691 
    return
9692 
 
9693 
 
1845 vikas 9694 
  def __repr__(self):
9695 
    L = ['%s=%r' % (key, value)
9696 
      for key, value in self.__dict__.iteritems()]
9697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9698 
 
9699 
  def __eq__(self, other):
9700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9701 
 
9702 
  def __ne__(self, other):
9703 
    return not (self == other)
9704 
 
9705 
class getTrackLogsByUser_args:
9706 
  """
9707 
  Attributes:
9708 
   - userId
9709 
  """
9710 
 
9711 
  thrift_spec = (
9712 
    None, # 0
9713 
    (1, TType.I64, 'userId', None, None, ), # 1
9714 
  )
9715 
 
9716 
  def __init__(self, userId=None,):
9717 
    self.userId = userId
9718 
 
9719 
  def read(self, iprot):
9720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9722 
      return
9723 
    iprot.readStructBegin()
9724 
    while True:
9725 
      (fname, ftype, fid) = iprot.readFieldBegin()
9726 
      if ftype == TType.STOP:
9727 
        break
9728 
      if fid == 1:
9729 
        if ftype == TType.I64:
9730 
          self.userId = iprot.readI64();
9731 
        else:
9732 
          iprot.skip(ftype)
9733 
      else:
9734 
        iprot.skip(ftype)
9735 
      iprot.readFieldEnd()
9736 
    iprot.readStructEnd()
9737 
 
9738 
  def write(self, oprot):
9739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9741 
      return
9742 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9743 
    if self.userId is not None:
1845 vikas 9744 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9745 
      oprot.writeI64(self.userId)
9746 
      oprot.writeFieldEnd()
9747 
    oprot.writeFieldStop()
9748 
    oprot.writeStructEnd()
9749 
 
3431 rajveer 9750 
  def validate(self):
9751 
    return
9752 
 
9753 
 
1845 vikas 9754 
  def __repr__(self):
9755 
    L = ['%s=%r' % (key, value)
9756 
      for key, value in self.__dict__.iteritems()]
9757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9758 
 
9759 
  def __eq__(self, other):
9760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9761 
 
9762 
  def __ne__(self, other):
9763 
    return not (self == other)
9764 
 
9765 
class getTrackLogsByUser_result:
9766 
  """
9767 
  Attributes:
9768 
   - success
9769 
   - utx
9770 
  """
9771 
 
9772 
  thrift_spec = (
9773 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9774 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9775 
  )
9776 
 
9777 
  def __init__(self, success=None, utx=None,):
9778 
    self.success = success
9779 
    self.utx = utx
9780 
 
9781 
  def read(self, iprot):
9782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9784 
      return
9785 
    iprot.readStructBegin()
9786 
    while True:
9787 
      (fname, ftype, fid) = iprot.readFieldBegin()
9788 
      if ftype == TType.STOP:
9789 
        break
9790 
      if fid == 0:
9791 
        if ftype == TType.LIST:
9792 
          self.success = []
11592 amit.gupta 9793 
          (_etype142, _size139) = iprot.readListBegin()
9794 
          for _i143 in xrange(_size139):
9795 
            _elem144 = TrackLog()
9796 
            _elem144.read(iprot)
9797 
            self.success.append(_elem144)
1845 vikas 9798 
          iprot.readListEnd()
9799 
        else:
9800 
          iprot.skip(ftype)
9801 
      elif fid == 1:
9802 
        if ftype == TType.STRUCT:
1996 vikas 9803 
          self.utx = UserAffiliateException()
1845 vikas 9804 
          self.utx.read(iprot)
9805 
        else:
9806 
          iprot.skip(ftype)
9807 
      else:
9808 
        iprot.skip(ftype)
9809 
      iprot.readFieldEnd()
9810 
    iprot.readStructEnd()
9811 
 
9812 
  def write(self, oprot):
9813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9815 
      return
9816 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 9817 
    if self.success is not None:
1845 vikas 9818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9820 
      for iter145 in self.success:
9821 
        iter145.write(oprot)
1845 vikas 9822 
      oprot.writeListEnd()
9823 
      oprot.writeFieldEnd()
3431 rajveer 9824 
    if self.utx is not None:
1845 vikas 9825 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9826 
      self.utx.write(oprot)
9827 
      oprot.writeFieldEnd()
9828 
    oprot.writeFieldStop()
9829 
    oprot.writeStructEnd()
9830 
 
3431 rajveer 9831 
  def validate(self):
9832 
    return
9833 
 
9834 
 
1845 vikas 9835 
  def __repr__(self):
9836 
    L = ['%s=%r' % (key, value)
9837 
      for key, value in self.__dict__.iteritems()]
9838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9839 
 
9840 
  def __eq__(self, other):
9841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9842 
 
9843 
  def __ne__(self, other):
9844 
    return not (self == other)
9845 
 
9846 
class getTrackLogs_args:
9847 
  """
9848 
  Attributes:
9849 
   - userId
9850 
   - event
9851 
   - url
9852 
  """
9853 
 
9854 
  thrift_spec = (
9855 
    None, # 0
1996 vikas 9856 
    (1, TType.I64, 'userId', None, None, ), # 1
9857 
    (2, TType.STRING, 'event', None, None, ), # 2
9858 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9859 
  )
9860 
 
1996 vikas 9861 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9862 
    self.userId = userId
9863 
    self.event = event
9864 
    self.url = url
9865 
 
9866 
  def read(self, iprot):
9867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9869 
      return
9870 
    iprot.readStructBegin()
9871 
    while True:
9872 
      (fname, ftype, fid) = iprot.readFieldBegin()
9873 
      if ftype == TType.STOP:
9874 
        break
9875 
      if fid == 1:
9876 
        if ftype == TType.I64:
1996 vikas 9877 
          self.userId = iprot.readI64();
1845 vikas 9878 
        else:
9879 
          iprot.skip(ftype)
9880 
      elif fid == 2:
9881 
        if ftype == TType.STRING:
9882 
          self.event = iprot.readString();
9883 
        else:
9884 
          iprot.skip(ftype)
1996 vikas 9885 
      elif fid == 3:
1845 vikas 9886 
        if ftype == TType.STRING:
9887 
          self.url = iprot.readString();
9888 
        else:
9889 
          iprot.skip(ftype)
9890 
      else:
9891 
        iprot.skip(ftype)
9892 
      iprot.readFieldEnd()
9893 
    iprot.readStructEnd()
9894 
 
9895 
  def write(self, oprot):
9896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9898 
      return
9899 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 9900 
    if self.userId is not None:
1996 vikas 9901 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9902 
      oprot.writeI64(self.userId)
9903 
      oprot.writeFieldEnd()
3431 rajveer 9904 
    if self.event is not None:
1996 vikas 9905 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9906 
      oprot.writeString(self.event)
9907 
      oprot.writeFieldEnd()
3431 rajveer 9908 
    if self.url is not None:
1996 vikas 9909 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9910 
      oprot.writeString(self.url)
9911 
      oprot.writeFieldEnd()
9912 
    oprot.writeFieldStop()
9913 
    oprot.writeStructEnd()
9914 
 
3431 rajveer 9915 
  def validate(self):
9916 
    return
9917 
 
9918 
 
1845 vikas 9919 
  def __repr__(self):
9920 
    L = ['%s=%r' % (key, value)
9921 
      for key, value in self.__dict__.iteritems()]
9922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9923 
 
9924 
  def __eq__(self, other):
9925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9926 
 
9927 
  def __ne__(self, other):
9928 
    return not (self == other)
9929 
 
9930 
class getTrackLogs_result:
9931 
  """
9932 
  Attributes:
9933 
   - success
9934 
   - utx
9935 
  """
9936 
 
9937 
  thrift_spec = (
9938 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9939 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9940 
  )
9941 
 
9942 
  def __init__(self, success=None, utx=None,):
9943 
    self.success = success
9944 
    self.utx = utx
9945 
 
9946 
  def read(self, iprot):
9947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9949 
      return
9950 
    iprot.readStructBegin()
9951 
    while True:
9952 
      (fname, ftype, fid) = iprot.readFieldBegin()
9953 
      if ftype == TType.STOP:
9954 
        break
9955 
      if fid == 0:
9956 
        if ftype == TType.LIST:
9957 
          self.success = []
11592 amit.gupta 9958 
          (_etype149, _size146) = iprot.readListBegin()
9959 
          for _i150 in xrange(_size146):
9960 
            _elem151 = TrackLog()
9961 
            _elem151.read(iprot)
9962 
            self.success.append(_elem151)
1845 vikas 9963 
          iprot.readListEnd()
9964 
        else:
9965 
          iprot.skip(ftype)
9966 
      elif fid == 1:
9967 
        if ftype == TType.STRUCT:
1996 vikas 9968 
          self.utx = UserAffiliateException()
1845 vikas 9969 
          self.utx.read(iprot)
9970 
        else:
9971 
          iprot.skip(ftype)
9972 
      else:
9973 
        iprot.skip(ftype)
9974 
      iprot.readFieldEnd()
9975 
    iprot.readStructEnd()
9976 
 
9977 
  def write(self, oprot):
9978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9980 
      return
9981 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 9982 
    if self.success is not None:
1845 vikas 9983 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9984 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9985 
      for iter152 in self.success:
9986 
        iter152.write(oprot)
1845 vikas 9987 
      oprot.writeListEnd()
9988 
      oprot.writeFieldEnd()
3431 rajveer 9989 
    if self.utx is not None:
1845 vikas 9990 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9991 
      self.utx.write(oprot)
9992 
      oprot.writeFieldEnd()
9993 
    oprot.writeFieldStop()
9994 
    oprot.writeStructEnd()
9995 
 
3431 rajveer 9996 
  def validate(self):
9997 
    return
9998 
 
9999 
 
1845 vikas 10000 
  def __repr__(self):
10001 
    L = ['%s=%r' % (key, value)
10002 
      for key, value in self.__dict__.iteritems()]
10003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10004 
 
10005 
  def __eq__(self, other):
10006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10007 
 
10008 
  def __ne__(self, other):
10009 
    return not (self == other)
10010 
 
559 chandransh 10011 
class getCurrentCart_args:
94 ashish 10012 
  """
10013 
  Attributes:
559 chandransh 10014 
   - userId
10015 
  """
10016 
 
10017 
  thrift_spec = (
10018 
    None, # 0
10019 
    (1, TType.I64, 'userId', None, None, ), # 1
10020 
  )
10021 
 
10022 
  def __init__(self, userId=None,):
10023 
    self.userId = userId
10024 
 
10025 
  def read(self, iprot):
10026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10028 
      return
10029 
    iprot.readStructBegin()
10030 
    while True:
10031 
      (fname, ftype, fid) = iprot.readFieldBegin()
10032 
      if ftype == TType.STOP:
10033 
        break
10034 
      if fid == 1:
10035 
        if ftype == TType.I64:
10036 
          self.userId = iprot.readI64();
10037 
        else:
10038 
          iprot.skip(ftype)
10039 
      else:
10040 
        iprot.skip(ftype)
10041 
      iprot.readFieldEnd()
10042 
    iprot.readStructEnd()
10043 
 
10044 
  def write(self, oprot):
10045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10047 
      return
10048 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10049 
    if self.userId is not None:
559 chandransh 10050 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10051 
      oprot.writeI64(self.userId)
10052 
      oprot.writeFieldEnd()
10053 
    oprot.writeFieldStop()
10054 
    oprot.writeStructEnd()
10055 
 
3431 rajveer 10056 
  def validate(self):
10057 
    return
10058 
 
10059 
 
559 chandransh 10060 
  def __repr__(self):
10061 
    L = ['%s=%r' % (key, value)
10062 
      for key, value in self.__dict__.iteritems()]
10063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10064 
 
10065 
  def __eq__(self, other):
10066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10067 
 
10068 
  def __ne__(self, other):
10069 
    return not (self == other)
10070 
 
10071 
class getCurrentCart_result:
10072 
  """
10073 
  Attributes:
94 ashish 10074 
   - success
559 chandransh 10075 
   - scx
94 ashish 10076 
  """
10077 
 
10078 
  thrift_spec = (
559 chandransh 10079 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10080 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10081 
  )
10082 
 
559 chandransh 10083 
  def __init__(self, success=None, scx=None,):
94 ashish 10084 
    self.success = success
559 chandransh 10085 
    self.scx = scx
94 ashish 10086 
 
10087 
  def read(self, iprot):
10088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10090 
      return
10091 
    iprot.readStructBegin()
10092 
    while True:
10093 
      (fname, ftype, fid) = iprot.readFieldBegin()
10094 
      if ftype == TType.STOP:
10095 
        break
10096 
      if fid == 0:
559 chandransh 10097 
        if ftype == TType.STRUCT:
10098 
          self.success = Cart()
10099 
          self.success.read(iprot)
94 ashish 10100 
        else:
10101 
          iprot.skip(ftype)
10102 
      elif fid == 1:
10103 
        if ftype == TType.STRUCT:
559 chandransh 10104 
          self.scx = ShoppingCartException()
10105 
          self.scx.read(iprot)
94 ashish 10106 
        else:
10107 
          iprot.skip(ftype)
10108 
      else:
10109 
        iprot.skip(ftype)
10110 
      iprot.readFieldEnd()
10111 
    iprot.readStructEnd()
10112 
 
10113 
  def write(self, oprot):
10114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10116 
      return
559 chandransh 10117 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10118 
    if self.success is not None:
559 chandransh 10119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10120 
      self.success.write(oprot)
94 ashish 10121 
      oprot.writeFieldEnd()
3431 rajveer 10122 
    if self.scx is not None:
559 chandransh 10123 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10124 
      self.scx.write(oprot)
94 ashish 10125 
      oprot.writeFieldEnd()
10126 
    oprot.writeFieldStop()
10127 
    oprot.writeStructEnd()
10128 
 
3431 rajveer 10129 
  def validate(self):
10130 
    return
10131 
 
10132 
 
94 ashish 10133 
  def __repr__(self):
10134 
    L = ['%s=%r' % (key, value)
10135 
      for key, value in self.__dict__.iteritems()]
10136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10137 
 
10138 
  def __eq__(self, other):
10139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10140 
 
10141 
  def __ne__(self, other):
10142 
    return not (self == other)
10143 
 
559 chandransh 10144 
class getCart_args:
504 rajveer 10145 
  """
10146 
  Attributes:
559 chandransh 10147 
   - cartId
504 rajveer 10148 
  """
10149 
 
10150 
  thrift_spec = (
10151 
    None, # 0
559 chandransh 10152 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10153 
  )
10154 
 
559 chandransh 10155 
  def __init__(self, cartId=None,):
10156 
    self.cartId = cartId
504 rajveer 10157 
 
10158 
  def read(self, iprot):
10159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10161 
      return
10162 
    iprot.readStructBegin()
10163 
    while True:
10164 
      (fname, ftype, fid) = iprot.readFieldBegin()
10165 
      if ftype == TType.STOP:
10166 
        break
10167 
      if fid == 1:
10168 
        if ftype == TType.I64:
559 chandransh 10169 
          self.cartId = iprot.readI64();
504 rajveer 10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      else:
10173 
        iprot.skip(ftype)
10174 
      iprot.readFieldEnd()
10175 
    iprot.readStructEnd()
10176 
 
10177 
  def write(self, oprot):
10178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10180 
      return
559 chandransh 10181 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10182 
    if self.cartId is not None:
559 chandransh 10183 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10184 
      oprot.writeI64(self.cartId)
504 rajveer 10185 
      oprot.writeFieldEnd()
10186 
    oprot.writeFieldStop()
10187 
    oprot.writeStructEnd()
10188 
 
3431 rajveer 10189 
  def validate(self):
10190 
    return
10191 
 
10192 
 
504 rajveer 10193 
  def __repr__(self):
10194 
    L = ['%s=%r' % (key, value)
10195 
      for key, value in self.__dict__.iteritems()]
10196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10197 
 
10198 
  def __eq__(self, other):
10199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10200 
 
10201 
  def __ne__(self, other):
10202 
    return not (self == other)
10203 
 
559 chandransh 10204 
class getCart_result:
504 rajveer 10205 
  """
10206 
  Attributes:
10207 
   - success
559 chandransh 10208 
   - scx
504 rajveer 10209 
  """
10210 
 
10211 
  thrift_spec = (
559 chandransh 10212 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10213 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10214 
  )
10215 
 
559 chandransh 10216 
  def __init__(self, success=None, scx=None,):
504 rajveer 10217 
    self.success = success
559 chandransh 10218 
    self.scx = scx
504 rajveer 10219 
 
10220 
  def read(self, iprot):
10221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10223 
      return
10224 
    iprot.readStructBegin()
10225 
    while True:
10226 
      (fname, ftype, fid) = iprot.readFieldBegin()
10227 
      if ftype == TType.STOP:
10228 
        break
10229 
      if fid == 0:
559 chandransh 10230 
        if ftype == TType.STRUCT:
10231 
          self.success = Cart()
10232 
          self.success.read(iprot)
504 rajveer 10233 
        else:
10234 
          iprot.skip(ftype)
10235 
      elif fid == 1:
10236 
        if ftype == TType.STRUCT:
559 chandransh 10237 
          self.scx = ShoppingCartException()
10238 
          self.scx.read(iprot)
504 rajveer 10239 
        else:
10240 
          iprot.skip(ftype)
10241 
      else:
10242 
        iprot.skip(ftype)
10243 
      iprot.readFieldEnd()
10244 
    iprot.readStructEnd()
10245 
 
10246 
  def write(self, oprot):
10247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10249 
      return
559 chandransh 10250 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10251 
    if self.success is not None:
559 chandransh 10252 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10253 
      self.success.write(oprot)
504 rajveer 10254 
      oprot.writeFieldEnd()
3431 rajveer 10255 
    if self.scx is not None:
559 chandransh 10256 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10257 
      self.scx.write(oprot)
504 rajveer 10258 
      oprot.writeFieldEnd()
10259 
    oprot.writeFieldStop()
10260 
    oprot.writeStructEnd()
10261 
 
3431 rajveer 10262 
  def validate(self):
10263 
    return
10264 
 
10265 
 
504 rajveer 10266 
  def __repr__(self):
10267 
    L = ['%s=%r' % (key, value)
10268 
      for key, value in self.__dict__.iteritems()]
10269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10270 
 
10271 
  def __eq__(self, other):
10272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10273 
 
10274 
  def __ne__(self, other):
10275 
    return not (self == other)
10276 
 
559 chandransh 10277 
class getCartsByTime_args:
10278 
  """
10279 
  Attributes:
10280 
   - from_time
10281 
   - to_time
10282 
   - status
10283 
  """
10284 
 
10285 
  thrift_spec = (
10286 
    None, # 0
10287 
    (1, TType.I64, 'from_time', None, None, ), # 1
10288 
    (2, TType.I64, 'to_time', None, None, ), # 2
10289 
    (3, TType.I32, 'status', None, None, ), # 3
10290 
  )
10291 
 
10292 
  def __init__(self, from_time=None, to_time=None, status=None,):
10293 
    self.from_time = from_time
10294 
    self.to_time = to_time
10295 
    self.status = status
10296 
 
10297 
  def read(self, iprot):
10298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10300 
      return
10301 
    iprot.readStructBegin()
10302 
    while True:
10303 
      (fname, ftype, fid) = iprot.readFieldBegin()
10304 
      if ftype == TType.STOP:
10305 
        break
10306 
      if fid == 1:
94 ashish 10307 
        if ftype == TType.I64:
559 chandransh 10308 
          self.from_time = iprot.readI64();
94 ashish 10309 
        else:
10310 
          iprot.skip(ftype)
122 ashish 10311 
      elif fid == 2:
559 chandransh 10312 
        if ftype == TType.I64:
10313 
          self.to_time = iprot.readI64();
122 ashish 10314 
        else:
10315 
          iprot.skip(ftype)
559 chandransh 10316 
      elif fid == 3:
10317 
        if ftype == TType.I32:
10318 
          self.status = iprot.readI32();
10319 
        else:
10320 
          iprot.skip(ftype)
94 ashish 10321 
      else:
10322 
        iprot.skip(ftype)
10323 
      iprot.readFieldEnd()
10324 
    iprot.readStructEnd()
10325 
 
10326 
  def write(self, oprot):
10327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10329 
      return
559 chandransh 10330 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10331 
    if self.from_time is not None:
559 chandransh 10332 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10333 
      oprot.writeI64(self.from_time)
94 ashish 10334 
      oprot.writeFieldEnd()
3431 rajveer 10335 
    if self.to_time is not None:
559 chandransh 10336 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10337 
      oprot.writeI64(self.to_time)
122 ashish 10338 
      oprot.writeFieldEnd()
3431 rajveer 10339 
    if self.status is not None:
559 chandransh 10340 
      oprot.writeFieldBegin('status', TType.I32, 3)
10341 
      oprot.writeI32(self.status)
10342 
      oprot.writeFieldEnd()
94 ashish 10343 
    oprot.writeFieldStop()
10344 
    oprot.writeStructEnd()
10345 
 
3431 rajveer 10346 
  def validate(self):
10347 
    return
10348 
 
10349 
 
94 ashish 10350 
  def __repr__(self):
10351 
    L = ['%s=%r' % (key, value)
10352 
      for key, value in self.__dict__.iteritems()]
10353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10354 
 
10355 
  def __eq__(self, other):
10356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10357 
 
10358 
  def __ne__(self, other):
10359 
    return not (self == other)
10360 
 
559 chandransh 10361 
class getCartsByTime_result:
94 ashish 10362 
  """
10363 
  Attributes:
10364 
   - success
559 chandransh 10365 
   - scx
94 ashish 10366 
  """
10367 
 
10368 
  thrift_spec = (
559 chandransh 10369 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10370 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10371 
  )
10372 
 
559 chandransh 10373 
  def __init__(self, success=None, scx=None,):
94 ashish 10374 
    self.success = success
559 chandransh 10375 
    self.scx = scx
94 ashish 10376 
 
10377 
  def read(self, iprot):
10378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10380 
      return
10381 
    iprot.readStructBegin()
10382 
    while True:
10383 
      (fname, ftype, fid) = iprot.readFieldBegin()
10384 
      if ftype == TType.STOP:
10385 
        break
10386 
      if fid == 0:
559 chandransh 10387 
        if ftype == TType.LIST:
10388 
          self.success = []
11592 amit.gupta 10389 
          (_etype156, _size153) = iprot.readListBegin()
10390 
          for _i157 in xrange(_size153):
10391 
            _elem158 = Cart()
10392 
            _elem158.read(iprot)
10393 
            self.success.append(_elem158)
559 chandransh 10394 
          iprot.readListEnd()
94 ashish 10395 
        else:
10396 
          iprot.skip(ftype)
10397 
      elif fid == 1:
10398 
        if ftype == TType.STRUCT:
559 chandransh 10399 
          self.scx = ShoppingCartException()
10400 
          self.scx.read(iprot)
94 ashish 10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      else:
10404 
        iprot.skip(ftype)
10405 
      iprot.readFieldEnd()
10406 
    iprot.readStructEnd()
10407 
 
10408 
  def write(self, oprot):
10409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10411 
      return
559 chandransh 10412 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10413 
    if self.success is not None:
559 chandransh 10414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10416 
      for iter159 in self.success:
10417 
        iter159.write(oprot)
559 chandransh 10418 
      oprot.writeListEnd()
94 ashish 10419 
      oprot.writeFieldEnd()
3431 rajveer 10420 
    if self.scx is not None:
559 chandransh 10421 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10422 
      self.scx.write(oprot)
94 ashish 10423 
      oprot.writeFieldEnd()
10424 
    oprot.writeFieldStop()
10425 
    oprot.writeStructEnd()
10426 
 
3431 rajveer 10427 
  def validate(self):
10428 
    return
10429 
 
10430 
 
94 ashish 10431 
  def __repr__(self):
10432 
    L = ['%s=%r' % (key, value)
10433 
      for key, value in self.__dict__.iteritems()]
10434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10435 
 
10436 
  def __eq__(self, other):
10437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10438 
 
10439 
  def __ne__(self, other):
10440 
    return not (self == other)
10441 
 
559 chandransh 10442 
class addItemToCart_args:
10443 
  """
10444 
  Attributes:
10445 
   - cartId
10446 
   - itemId
10447 
   - quantity
3557 rajveer 10448 
   - sourceId
559 chandransh 10449 
  """
10450 
 
10451 
  thrift_spec = (
10452 
    None, # 0
10453 
    (1, TType.I64, 'cartId', None, None, ), # 1
10454 
    (2, TType.I64, 'itemId', None, None, ), # 2
10455 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10456 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10457 
  )
10458 
 
3557 rajveer 10459 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10460 
    self.cartId = cartId
10461 
    self.itemId = itemId
10462 
    self.quantity = quantity
3557 rajveer 10463 
    self.sourceId = sourceId
559 chandransh 10464 
 
10465 
  def read(self, iprot):
10466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10468 
      return
10469 
    iprot.readStructBegin()
10470 
    while True:
10471 
      (fname, ftype, fid) = iprot.readFieldBegin()
10472 
      if ftype == TType.STOP:
10473 
        break
10474 
      if fid == 1:
10475 
        if ftype == TType.I64:
10476 
          self.cartId = iprot.readI64();
10477 
        else:
10478 
          iprot.skip(ftype)
10479 
      elif fid == 2:
10480 
        if ftype == TType.I64:
10481 
          self.itemId = iprot.readI64();
10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      elif fid == 3:
10485 
        if ftype == TType.I64:
10486 
          self.quantity = iprot.readI64();
10487 
        else:
10488 
          iprot.skip(ftype)
3557 rajveer 10489 
      elif fid == 4:
10490 
        if ftype == TType.I64:
10491 
          self.sourceId = iprot.readI64();
10492 
        else:
10493 
          iprot.skip(ftype)
559 chandransh 10494 
      else:
10495 
        iprot.skip(ftype)
10496 
      iprot.readFieldEnd()
10497 
    iprot.readStructEnd()
10498 
 
10499 
  def write(self, oprot):
10500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10502 
      return
10503 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10504 
    if self.cartId is not None:
559 chandransh 10505 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10506 
      oprot.writeI64(self.cartId)
10507 
      oprot.writeFieldEnd()
3431 rajveer 10508 
    if self.itemId is not None:
559 chandransh 10509 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10510 
      oprot.writeI64(self.itemId)
10511 
      oprot.writeFieldEnd()
3431 rajveer 10512 
    if self.quantity is not None:
559 chandransh 10513 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10514 
      oprot.writeI64(self.quantity)
10515 
      oprot.writeFieldEnd()
3557 rajveer 10516 
    if self.sourceId is not None:
10517 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10518 
      oprot.writeI64(self.sourceId)
10519 
      oprot.writeFieldEnd()
559 chandransh 10520 
    oprot.writeFieldStop()
10521 
    oprot.writeStructEnd()
10522 
 
3431 rajveer 10523 
  def validate(self):
10524 
    return
10525 
 
10526 
 
559 chandransh 10527 
  def __repr__(self):
10528 
    L = ['%s=%r' % (key, value)
10529 
      for key, value in self.__dict__.iteritems()]
10530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10531 
 
10532 
  def __eq__(self, other):
10533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10534 
 
10535 
  def __ne__(self, other):
10536 
    return not (self == other)
10537 
 
10538 
class addItemToCart_result:
10539 
  """
10540 
  Attributes:
2035 rajveer 10541 
   - success
559 chandransh 10542 
   - scx
10543 
  """
10544 
 
10545 
  thrift_spec = (
2035 rajveer 10546 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10547 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10548 
  )
10549 
 
2035 rajveer 10550 
  def __init__(self, success=None, scx=None,):
10551 
    self.success = success
559 chandransh 10552 
    self.scx = scx
10553 
 
10554 
  def read(self, iprot):
10555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10557 
      return
10558 
    iprot.readStructBegin()
10559 
    while True:
10560 
      (fname, ftype, fid) = iprot.readFieldBegin()
10561 
      if ftype == TType.STOP:
10562 
        break
2035 rajveer 10563 
      if fid == 0:
10564 
        if ftype == TType.STRING:
10565 
          self.success = iprot.readString();
10566 
        else:
10567 
          iprot.skip(ftype)
10568 
      elif fid == 1:
559 chandransh 10569 
        if ftype == TType.STRUCT:
10570 
          self.scx = ShoppingCartException()
10571 
          self.scx.read(iprot)
10572 
        else:
10573 
          iprot.skip(ftype)
10574 
      else:
10575 
        iprot.skip(ftype)
10576 
      iprot.readFieldEnd()
10577 
    iprot.readStructEnd()
10578 
 
10579 
  def write(self, oprot):
10580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10582 
      return
10583 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10584 
    if self.success is not None:
2035 rajveer 10585 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10586 
      oprot.writeString(self.success)
10587 
      oprot.writeFieldEnd()
3431 rajveer 10588 
    if self.scx is not None:
559 chandransh 10589 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10590 
      self.scx.write(oprot)
10591 
      oprot.writeFieldEnd()
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
3431 rajveer 10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
559 chandransh 10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
10610 
class deleteItemFromCart_args:
10611 
  """
10612 
  Attributes:
10613 
   - cartId
10614 
   - itemId
10615 
  """
10616 
 
10617 
  thrift_spec = (
10618 
    None, # 0
10619 
    (1, TType.I64, 'cartId', None, None, ), # 1
10620 
    (2, TType.I64, 'itemId', None, None, ), # 2
10621 
  )
10622 
 
10623 
  def __init__(self, cartId=None, itemId=None,):
10624 
    self.cartId = cartId
10625 
    self.itemId = itemId
10626 
 
10627 
  def read(self, iprot):
10628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10630 
      return
10631 
    iprot.readStructBegin()
10632 
    while True:
10633 
      (fname, ftype, fid) = iprot.readFieldBegin()
10634 
      if ftype == TType.STOP:
10635 
        break
10636 
      if fid == 1:
10637 
        if ftype == TType.I64:
10638 
          self.cartId = iprot.readI64();
10639 
        else:
10640 
          iprot.skip(ftype)
10641 
      elif fid == 2:
10642 
        if ftype == TType.I64:
10643 
          self.itemId = iprot.readI64();
10644 
        else:
10645 
          iprot.skip(ftype)
10646 
      else:
10647 
        iprot.skip(ftype)
10648 
      iprot.readFieldEnd()
10649 
    iprot.readStructEnd()
10650 
 
10651 
  def write(self, oprot):
10652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10654 
      return
10655 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10656 
    if self.cartId is not None:
559 chandransh 10657 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10658 
      oprot.writeI64(self.cartId)
10659 
      oprot.writeFieldEnd()
3431 rajveer 10660 
    if self.itemId is not None:
559 chandransh 10661 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10662 
      oprot.writeI64(self.itemId)
10663 
      oprot.writeFieldEnd()
10664 
    oprot.writeFieldStop()
10665 
    oprot.writeStructEnd()
10666 
 
3431 rajveer 10667 
  def validate(self):
10668 
    return
10669 
 
10670 
 
559 chandransh 10671 
  def __repr__(self):
10672 
    L = ['%s=%r' % (key, value)
10673 
      for key, value in self.__dict__.iteritems()]
10674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10675 
 
10676 
  def __eq__(self, other):
10677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10678 
 
10679 
  def __ne__(self, other):
10680 
    return not (self == other)
10681 
 
10682 
class deleteItemFromCart_result:
10683 
  """
10684 
  Attributes:
10685 
   - scx
10686 
  """
10687 
 
10688 
  thrift_spec = (
10689 
    None, # 0
10690 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10691 
  )
10692 
 
10693 
  def __init__(self, scx=None,):
10694 
    self.scx = scx
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 == 1:
10706 
        if ftype == TType.STRUCT:
10707 
          self.scx = ShoppingCartException()
10708 
          self.scx.read(iprot)
10709 
        else:
10710 
          iprot.skip(ftype)
10711 
      else:
10712 
        iprot.skip(ftype)
10713 
      iprot.readFieldEnd()
10714 
    iprot.readStructEnd()
10715 
 
10716 
  def write(self, oprot):
10717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10719 
      return
10720 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10721 
    if self.scx is not None:
559 chandransh 10722 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10723 
      self.scx.write(oprot)
10724 
      oprot.writeFieldEnd()
10725 
    oprot.writeFieldStop()
10726 
    oprot.writeStructEnd()
10727 
 
3431 rajveer 10728 
  def validate(self):
10729 
    return
10730 
 
10731 
 
559 chandransh 10732 
  def __repr__(self):
10733 
    L = ['%s=%r' % (key, value)
10734 
      for key, value in self.__dict__.iteritems()]
10735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10736 
 
10737 
  def __eq__(self, other):
10738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10739 
 
10740 
  def __ne__(self, other):
10741 
    return not (self == other)
10742 
 
10743 
class addAddressToCart_args:
10744 
  """
10745 
  Attributes:
10746 
   - cartId
10747 
   - addressId
10748 
  """
10749 
 
10750 
  thrift_spec = (
10751 
    None, # 0
10752 
    (1, TType.I64, 'cartId', None, None, ), # 1
10753 
    (2, TType.I64, 'addressId', None, None, ), # 2
10754 
  )
10755 
 
10756 
  def __init__(self, cartId=None, addressId=None,):
10757 
    self.cartId = cartId
10758 
    self.addressId = addressId
10759 
 
10760 
  def read(self, iprot):
10761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10763 
      return
10764 
    iprot.readStructBegin()
10765 
    while True:
10766 
      (fname, ftype, fid) = iprot.readFieldBegin()
10767 
      if ftype == TType.STOP:
10768 
        break
10769 
      if fid == 1:
10770 
        if ftype == TType.I64:
10771 
          self.cartId = iprot.readI64();
10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      elif fid == 2:
10775 
        if ftype == TType.I64:
10776 
          self.addressId = iprot.readI64();
10777 
        else:
10778 
          iprot.skip(ftype)
10779 
      else:
10780 
        iprot.skip(ftype)
10781 
      iprot.readFieldEnd()
10782 
    iprot.readStructEnd()
10783 
 
10784 
  def write(self, oprot):
10785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10787 
      return
10788 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 10789 
    if self.cartId is not None:
559 chandransh 10790 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10791 
      oprot.writeI64(self.cartId)
10792 
      oprot.writeFieldEnd()
3431 rajveer 10793 
    if self.addressId is not None:
559 chandransh 10794 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10795 
      oprot.writeI64(self.addressId)
10796 
      oprot.writeFieldEnd()
10797 
    oprot.writeFieldStop()
10798 
    oprot.writeStructEnd()
10799 
 
3431 rajveer 10800 
  def validate(self):
10801 
    return
10802 
 
10803 
 
559 chandransh 10804 
  def __repr__(self):
10805 
    L = ['%s=%r' % (key, value)
10806 
      for key, value in self.__dict__.iteritems()]
10807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10808 
 
10809 
  def __eq__(self, other):
10810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10811 
 
10812 
  def __ne__(self, other):
10813 
    return not (self == other)
10814 
 
10815 
class addAddressToCart_result:
575 chandransh 10816 
  """
10817 
  Attributes:
10818 
   - scx
10819 
  """
559 chandransh 10820 
 
10821 
  thrift_spec = (
575 chandransh 10822 
    None, # 0
10823 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10824 
  )
10825 
 
575 chandransh 10826 
  def __init__(self, scx=None,):
10827 
    self.scx = scx
10828 
 
559 chandransh 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
575 chandransh 10838 
      if fid == 1:
10839 
        if ftype == TType.STRUCT:
10840 
          self.scx = ShoppingCartException()
10841 
          self.scx.read(iprot)
10842 
        else:
10843 
          iprot.skip(ftype)
559 chandransh 10844 
      else:
10845 
        iprot.skip(ftype)
10846 
      iprot.readFieldEnd()
10847 
    iprot.readStructEnd()
10848 
 
10849 
  def write(self, oprot):
10850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10852 
      return
10853 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 10854 
    if self.scx is not None:
575 chandransh 10855 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10856 
      self.scx.write(oprot)
10857 
      oprot.writeFieldEnd()
559 chandransh 10858 
    oprot.writeFieldStop()
10859 
    oprot.writeStructEnd()
10860 
 
3431 rajveer 10861 
  def validate(self):
10862 
    return
10863 
 
10864 
 
559 chandransh 10865 
  def __repr__(self):
10866 
    L = ['%s=%r' % (key, value)
10867 
      for key, value in self.__dict__.iteritems()]
10868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10869 
 
10870 
  def __eq__(self, other):
10871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10872 
 
10873 
  def __ne__(self, other):
10874 
    return not (self == other)
10875 
 
5553 rajveer 10876 
class addStoreToCart_args:
10877 
  """
10878 
  Attributes:
10879 
   - cartId
10880 
   - storeId
10881 
  """
10882 
 
10883 
  thrift_spec = (
10884 
    None, # 0
10885 
    (1, TType.I64, 'cartId', None, None, ), # 1
10886 
    (2, TType.I64, 'storeId', None, None, ), # 2
10887 
  )
10888 
 
10889 
  def __init__(self, cartId=None, storeId=None,):
10890 
    self.cartId = cartId
10891 
    self.storeId = storeId
10892 
 
10893 
  def read(self, iprot):
10894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10896 
      return
10897 
    iprot.readStructBegin()
10898 
    while True:
10899 
      (fname, ftype, fid) = iprot.readFieldBegin()
10900 
      if ftype == TType.STOP:
10901 
        break
10902 
      if fid == 1:
10903 
        if ftype == TType.I64:
10904 
          self.cartId = iprot.readI64();
10905 
        else:
10906 
          iprot.skip(ftype)
10907 
      elif fid == 2:
10908 
        if ftype == TType.I64:
10909 
          self.storeId = iprot.readI64();
10910 
        else:
10911 
          iprot.skip(ftype)
10912 
      else:
10913 
        iprot.skip(ftype)
10914 
      iprot.readFieldEnd()
10915 
    iprot.readStructEnd()
10916 
 
10917 
  def write(self, oprot):
10918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10920 
      return
10921 
    oprot.writeStructBegin('addStoreToCart_args')
10922 
    if self.cartId is not None:
10923 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10924 
      oprot.writeI64(self.cartId)
10925 
      oprot.writeFieldEnd()
10926 
    if self.storeId is not None:
10927 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
10928 
      oprot.writeI64(self.storeId)
10929 
      oprot.writeFieldEnd()
10930 
    oprot.writeFieldStop()
10931 
    oprot.writeStructEnd()
10932 
 
10933 
  def validate(self):
10934 
    return
10935 
 
10936 
 
10937 
  def __repr__(self):
10938 
    L = ['%s=%r' % (key, value)
10939 
      for key, value in self.__dict__.iteritems()]
10940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10941 
 
10942 
  def __eq__(self, other):
10943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10944 
 
10945 
  def __ne__(self, other):
10946 
    return not (self == other)
10947 
 
10948 
class addStoreToCart_result:
10949 
  """
10950 
  Attributes:
10951 
   - scx
10952 
  """
10953 
 
10954 
  thrift_spec = (
10955 
    None, # 0
10956 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10957 
  )
10958 
 
10959 
  def __init__(self, scx=None,):
10960 
    self.scx = scx
10961 
 
10962 
  def read(self, iprot):
10963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10965 
      return
10966 
    iprot.readStructBegin()
10967 
    while True:
10968 
      (fname, ftype, fid) = iprot.readFieldBegin()
10969 
      if ftype == TType.STOP:
10970 
        break
10971 
      if fid == 1:
10972 
        if ftype == TType.STRUCT:
10973 
          self.scx = ShoppingCartException()
10974 
          self.scx.read(iprot)
10975 
        else:
10976 
          iprot.skip(ftype)
10977 
      else:
10978 
        iprot.skip(ftype)
10979 
      iprot.readFieldEnd()
10980 
    iprot.readStructEnd()
10981 
 
10982 
  def write(self, oprot):
10983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10985 
      return
10986 
    oprot.writeStructBegin('addStoreToCart_result')
10987 
    if self.scx is not None:
10988 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10989 
      self.scx.write(oprot)
10990 
      oprot.writeFieldEnd()
10991 
    oprot.writeFieldStop()
10992 
    oprot.writeStructEnd()
10993 
 
10994 
  def validate(self):
10995 
    return
10996 
 
10997 
 
10998 
  def __repr__(self):
10999 
    L = ['%s=%r' % (key, value)
11000 
      for key, value in self.__dict__.iteritems()]
11001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11002 
 
11003 
  def __eq__(self, other):
11004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11005 
 
11006 
  def __ne__(self, other):
11007 
    return not (self == other)
11008 
 
1976 varun.gupt 11009 
class applyCouponToCart_args:
11010 
  """
11011 
  Attributes:
6922 anupam.sin 11012 
   - cart
1976 varun.gupt 11013 
   - couponCode
11014 
  """
11015 
 
11016 
  thrift_spec = (
11017 
    None, # 0
6922 anupam.sin 11018 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11019 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11020 
  )
11021 
 
6922 anupam.sin 11022 
  def __init__(self, cart=None, couponCode=None,):
11023 
    self.cart = cart
1976 varun.gupt 11024 
    self.couponCode = couponCode
11025 
 
11026 
  def read(self, iprot):
11027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11029 
      return
11030 
    iprot.readStructBegin()
11031 
    while True:
11032 
      (fname, ftype, fid) = iprot.readFieldBegin()
11033 
      if ftype == TType.STOP:
11034 
        break
11035 
      if fid == 1:
6922 anupam.sin 11036 
        if ftype == TType.STRUCT:
11037 
          self.cart = Cart()
11038 
          self.cart.read(iprot)
1976 varun.gupt 11039 
        else:
11040 
          iprot.skip(ftype)
11041 
      elif fid == 2:
11042 
        if ftype == TType.STRING:
11043 
          self.couponCode = iprot.readString();
11044 
        else:
11045 
          iprot.skip(ftype)
11046 
      else:
11047 
        iprot.skip(ftype)
11048 
      iprot.readFieldEnd()
11049 
    iprot.readStructEnd()
11050 
 
11051 
  def write(self, oprot):
11052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11054 
      return
11055 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11056 
    if self.cart is not None:
11057 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11058 
      self.cart.write(oprot)
1976 varun.gupt 11059 
      oprot.writeFieldEnd()
3431 rajveer 11060 
    if self.couponCode is not None:
1976 varun.gupt 11061 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11062 
      oprot.writeString(self.couponCode)
11063 
      oprot.writeFieldEnd()
11064 
    oprot.writeFieldStop()
11065 
    oprot.writeStructEnd()
11066 
 
3431 rajveer 11067 
  def validate(self):
11068 
    return
11069 
 
11070 
 
1976 varun.gupt 11071 
  def __repr__(self):
11072 
    L = ['%s=%r' % (key, value)
11073 
      for key, value in self.__dict__.iteritems()]
11074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11075 
 
11076 
  def __eq__(self, other):
11077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11078 
 
11079 
  def __ne__(self, other):
11080 
    return not (self == other)
11081 
 
11082 
class applyCouponToCart_result:
11083 
  """
11084 
  Attributes:
11085 
   - scx
11086 
  """
11087 
 
11088 
  thrift_spec = (
11089 
    None, # 0
11090 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11091 
  )
11092 
 
11093 
  def __init__(self, scx=None,):
11094 
    self.scx = scx
11095 
 
11096 
  def read(self, iprot):
11097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11099 
      return
11100 
    iprot.readStructBegin()
11101 
    while True:
11102 
      (fname, ftype, fid) = iprot.readFieldBegin()
11103 
      if ftype == TType.STOP:
11104 
        break
11105 
      if fid == 1:
11106 
        if ftype == TType.STRUCT:
11107 
          self.scx = ShoppingCartException()
11108 
          self.scx.read(iprot)
11109 
        else:
11110 
          iprot.skip(ftype)
11111 
      else:
11112 
        iprot.skip(ftype)
11113 
      iprot.readFieldEnd()
11114 
    iprot.readStructEnd()
11115 
 
11116 
  def write(self, oprot):
11117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11119 
      return
11120 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11121 
    if self.scx is not None:
1976 varun.gupt 11122 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11123 
      self.scx.write(oprot)
11124 
      oprot.writeFieldEnd()
11125 
    oprot.writeFieldStop()
11126 
    oprot.writeStructEnd()
11127 
 
3431 rajveer 11128 
  def validate(self):
11129 
    return
11130 
 
11131 
 
1976 varun.gupt 11132 
  def __repr__(self):
11133 
    L = ['%s=%r' % (key, value)
11134 
      for key, value in self.__dict__.iteritems()]
11135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11136 
 
11137 
  def __eq__(self, other):
11138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11139 
 
11140 
  def __ne__(self, other):
11141 
    return not (self == other)
11142 
 
11143 
class removeCoupon_args:
11144 
  """
11145 
  Attributes:
11146 
   - cartId
11147 
  """
11148 
 
11149 
  thrift_spec = (
11150 
    None, # 0
11151 
    (1, TType.I64, 'cartId', None, None, ), # 1
11152 
  )
11153 
 
11154 
  def __init__(self, cartId=None,):
11155 
    self.cartId = cartId
11156 
 
11157 
  def read(self, iprot):
11158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11160 
      return
11161 
    iprot.readStructBegin()
11162 
    while True:
11163 
      (fname, ftype, fid) = iprot.readFieldBegin()
11164 
      if ftype == TType.STOP:
11165 
        break
11166 
      if fid == 1:
11167 
        if ftype == TType.I64:
11168 
          self.cartId = iprot.readI64();
11169 
        else:
11170 
          iprot.skip(ftype)
11171 
      else:
11172 
        iprot.skip(ftype)
11173 
      iprot.readFieldEnd()
11174 
    iprot.readStructEnd()
11175 
 
11176 
  def write(self, oprot):
11177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11179 
      return
11180 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11181 
    if self.cartId is not None:
1976 varun.gupt 11182 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11183 
      oprot.writeI64(self.cartId)
11184 
      oprot.writeFieldEnd()
11185 
    oprot.writeFieldStop()
11186 
    oprot.writeStructEnd()
11187 
 
3431 rajveer 11188 
  def validate(self):
11189 
    return
11190 
 
11191 
 
1976 varun.gupt 11192 
  def __repr__(self):
11193 
    L = ['%s=%r' % (key, value)
11194 
      for key, value in self.__dict__.iteritems()]
11195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11196 
 
11197 
  def __eq__(self, other):
11198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11199 
 
11200 
  def __ne__(self, other):
11201 
    return not (self == other)
11202 
 
11203 
class removeCoupon_result:
11204 
  """
11205 
  Attributes:
11206 
   - scx
11207 
  """
11208 
 
11209 
  thrift_spec = (
11210 
    None, # 0
11211 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11212 
  )
11213 
 
11214 
  def __init__(self, scx=None,):
11215 
    self.scx = scx
11216 
 
11217 
  def read(self, iprot):
11218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11220 
      return
11221 
    iprot.readStructBegin()
11222 
    while True:
11223 
      (fname, ftype, fid) = iprot.readFieldBegin()
11224 
      if ftype == TType.STOP:
11225 
        break
11226 
      if fid == 1:
11227 
        if ftype == TType.STRUCT:
11228 
          self.scx = ShoppingCartException()
11229 
          self.scx.read(iprot)
11230 
        else:
11231 
          iprot.skip(ftype)
11232 
      else:
11233 
        iprot.skip(ftype)
11234 
      iprot.readFieldEnd()
11235 
    iprot.readStructEnd()
11236 
 
11237 
  def write(self, oprot):
11238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11240 
      return
11241 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11242 
    if self.scx is not None:
1976 varun.gupt 11243 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11244 
      self.scx.write(oprot)
11245 
      oprot.writeFieldEnd()
11246 
    oprot.writeFieldStop()
11247 
    oprot.writeStructEnd()
11248 
 
3431 rajveer 11249 
  def validate(self):
11250 
    return
11251 
 
11252 
 
1976 varun.gupt 11253 
  def __repr__(self):
11254 
    L = ['%s=%r' % (key, value)
11255 
      for key, value in self.__dict__.iteritems()]
11256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11257 
 
11258 
  def __eq__(self, other):
11259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11260 
 
11261 
  def __ne__(self, other):
11262 
    return not (self == other)
11263 
 
3554 varun.gupt 11264 
class deleteDiscountsFromCart_args:
11265 
  """
11266 
  Attributes:
11267 
   - cartId
11268 
  """
11269 
 
11270 
  thrift_spec = (
11271 
    None, # 0
11272 
    (1, TType.I64, 'cartId', None, None, ), # 1
11273 
  )
11274 
 
11275 
  def __init__(self, cartId=None,):
11276 
    self.cartId = cartId
11277 
 
11278 
  def read(self, iprot):
11279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11281 
      return
11282 
    iprot.readStructBegin()
11283 
    while True:
11284 
      (fname, ftype, fid) = iprot.readFieldBegin()
11285 
      if ftype == TType.STOP:
11286 
        break
11287 
      if fid == 1:
11288 
        if ftype == TType.I64:
11289 
          self.cartId = iprot.readI64();
11290 
        else:
11291 
          iprot.skip(ftype)
11292 
      else:
11293 
        iprot.skip(ftype)
11294 
      iprot.readFieldEnd()
11295 
    iprot.readStructEnd()
11296 
 
11297 
  def write(self, oprot):
11298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11300 
      return
11301 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11302 
    if self.cartId is not None:
11303 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11304 
      oprot.writeI64(self.cartId)
11305 
      oprot.writeFieldEnd()
11306 
    oprot.writeFieldStop()
11307 
    oprot.writeStructEnd()
11308 
 
11309 
  def validate(self):
11310 
    return
11311 
 
11312 
 
11313 
  def __repr__(self):
11314 
    L = ['%s=%r' % (key, value)
11315 
      for key, value in self.__dict__.iteritems()]
11316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11317 
 
11318 
  def __eq__(self, other):
11319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11320 
 
11321 
  def __ne__(self, other):
11322 
    return not (self == other)
11323 
 
11324 
class deleteDiscountsFromCart_result:
11325 
  """
11326 
  Attributes:
11327 
   - scx
11328 
  """
11329 
 
11330 
  thrift_spec = (
11331 
    None, # 0
11332 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11333 
  )
11334 
 
11335 
  def __init__(self, scx=None,):
11336 
    self.scx = scx
11337 
 
11338 
  def read(self, iprot):
11339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11341 
      return
11342 
    iprot.readStructBegin()
11343 
    while True:
11344 
      (fname, ftype, fid) = iprot.readFieldBegin()
11345 
      if ftype == TType.STOP:
11346 
        break
11347 
      if fid == 1:
11348 
        if ftype == TType.STRUCT:
11349 
          self.scx = ShoppingCartException()
11350 
          self.scx.read(iprot)
11351 
        else:
11352 
          iprot.skip(ftype)
11353 
      else:
11354 
        iprot.skip(ftype)
11355 
      iprot.readFieldEnd()
11356 
    iprot.readStructEnd()
11357 
 
11358 
  def write(self, oprot):
11359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11361 
      return
11362 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11363 
    if self.scx is not None:
11364 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11365 
      self.scx.write(oprot)
11366 
      oprot.writeFieldEnd()
11367 
    oprot.writeFieldStop()
11368 
    oprot.writeStructEnd()
11369 
 
11370 
  def validate(self):
11371 
    return
11372 
 
11373 
 
11374 
  def __repr__(self):
11375 
    L = ['%s=%r' % (key, value)
11376 
      for key, value in self.__dict__.iteritems()]
11377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11378 
 
11379 
  def __eq__(self, other):
11380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11381 
 
11382 
  def __ne__(self, other):
11383 
    return not (self == other)
11384 
 
11385 
class saveDiscounts_args:
11386 
  """
11387 
  Attributes:
11388 
   - discounts
11389 
  """
11390 
 
11391 
  thrift_spec = (
11392 
    None, # 0
11393 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11394 
  )
11395 
 
11396 
  def __init__(self, discounts=None,):
11397 
    self.discounts = discounts
11398 
 
11399 
  def read(self, iprot):
11400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11402 
      return
11403 
    iprot.readStructBegin()
11404 
    while True:
11405 
      (fname, ftype, fid) = iprot.readFieldBegin()
11406 
      if ftype == TType.STOP:
11407 
        break
11408 
      if fid == 1:
11409 
        if ftype == TType.LIST:
11410 
          self.discounts = []
11592 amit.gupta 11411 
          (_etype163, _size160) = iprot.readListBegin()
11412 
          for _i164 in xrange(_size160):
11413 
            _elem165 = Discount()
11414 
            _elem165.read(iprot)
11415 
            self.discounts.append(_elem165)
3554 varun.gupt 11416 
          iprot.readListEnd()
11417 
        else:
11418 
          iprot.skip(ftype)
11419 
      else:
11420 
        iprot.skip(ftype)
11421 
      iprot.readFieldEnd()
11422 
    iprot.readStructEnd()
11423 
 
11424 
  def write(self, oprot):
11425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11427 
      return
11428 
    oprot.writeStructBegin('saveDiscounts_args')
11429 
    if self.discounts is not None:
11430 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11431 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11432 
      for iter166 in self.discounts:
11433 
        iter166.write(oprot)
3554 varun.gupt 11434 
      oprot.writeListEnd()
11435 
      oprot.writeFieldEnd()
11436 
    oprot.writeFieldStop()
11437 
    oprot.writeStructEnd()
11438 
 
11439 
  def validate(self):
11440 
    return
11441 
 
11442 
 
11443 
  def __repr__(self):
11444 
    L = ['%s=%r' % (key, value)
11445 
      for key, value in self.__dict__.iteritems()]
11446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11447 
 
11448 
  def __eq__(self, other):
11449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11450 
 
11451 
  def __ne__(self, other):
11452 
    return not (self == other)
11453 
 
11454 
class saveDiscounts_result:
11455 
  """
11456 
  Attributes:
11457 
   - scx
11458 
  """
11459 
 
11460 
  thrift_spec = (
11461 
    None, # 0
11462 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11463 
  )
11464 
 
11465 
  def __init__(self, scx=None,):
11466 
    self.scx = scx
11467 
 
11468 
  def read(self, iprot):
11469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11471 
      return
11472 
    iprot.readStructBegin()
11473 
    while True:
11474 
      (fname, ftype, fid) = iprot.readFieldBegin()
11475 
      if ftype == TType.STOP:
11476 
        break
11477 
      if fid == 1:
11478 
        if ftype == TType.STRUCT:
11479 
          self.scx = ShoppingCartException()
11480 
          self.scx.read(iprot)
11481 
        else:
11482 
          iprot.skip(ftype)
11483 
      else:
11484 
        iprot.skip(ftype)
11485 
      iprot.readFieldEnd()
11486 
    iprot.readStructEnd()
11487 
 
11488 
  def write(self, oprot):
11489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11491 
      return
11492 
    oprot.writeStructBegin('saveDiscounts_result')
11493 
    if self.scx is not None:
11494 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11495 
      self.scx.write(oprot)
11496 
      oprot.writeFieldEnd()
11497 
    oprot.writeFieldStop()
11498 
    oprot.writeStructEnd()
11499 
 
11500 
  def validate(self):
11501 
    return
11502 
 
11503 
 
11504 
  def __repr__(self):
11505 
    L = ['%s=%r' % (key, value)
11506 
      for key, value in self.__dict__.iteritems()]
11507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11508 
 
11509 
  def __eq__(self, other):
11510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11511 
 
11512 
  def __ne__(self, other):
11513 
    return not (self == other)
11514 
 
690 chandransh 11515 
class createOrders_args:
559 chandransh 11516 
  """
11517 
  Attributes:
11518 
   - cartId
2815 vikas 11519 
   - sessionSource
11520 
   - sessionStartTime
3858 vikas 11521 
   - firstSource
11522 
   - firstSourceTime
5326 rajveer 11523 
   - userId
6389 rajveer 11524 
   - schemeId
11526 amit.gupta 11525 
   - orderSource
559 chandransh 11526 
  """
11527 
 
11528 
  thrift_spec = (
11529 
    None, # 0
11530 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11531 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11532 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11533 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11534 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11535 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11536 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11537 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11538 
  )
11539 
 
11526 amit.gupta 11540 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11541 
    self.cartId = cartId
2815 vikas 11542 
    self.sessionSource = sessionSource
11543 
    self.sessionStartTime = sessionStartTime
3858 vikas 11544 
    self.firstSource = firstSource
11545 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11546 
    self.userId = userId
6389 rajveer 11547 
    self.schemeId = schemeId
11526 amit.gupta 11548 
    self.orderSource = orderSource
559 chandransh 11549 
 
11550 
  def read(self, iprot):
11551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11553 
      return
11554 
    iprot.readStructBegin()
11555 
    while True:
11556 
      (fname, ftype, fid) = iprot.readFieldBegin()
11557 
      if ftype == TType.STOP:
11558 
        break
11559 
      if fid == 1:
11560 
        if ftype == TType.I64:
11561 
          self.cartId = iprot.readI64();
11562 
        else:
11563 
          iprot.skip(ftype)
2815 vikas 11564 
      elif fid == 2:
11565 
        if ftype == TType.STRING:
11566 
          self.sessionSource = iprot.readString();
11567 
        else:
11568 
          iprot.skip(ftype)
11569 
      elif fid == 3:
11570 
        if ftype == TType.I64:
11571 
          self.sessionStartTime = iprot.readI64();
11572 
        else:
11573 
          iprot.skip(ftype)
3858 vikas 11574 
      elif fid == 4:
11575 
        if ftype == TType.STRING:
11576 
          self.firstSource = iprot.readString();
11577 
        else:
11578 
          iprot.skip(ftype)
11579 
      elif fid == 5:
11580 
        if ftype == TType.I64:
11581 
          self.firstSourceTime = iprot.readI64();
11582 
        else:
11583 
          iprot.skip(ftype)
5326 rajveer 11584 
      elif fid == 6:
11585 
        if ftype == TType.I64:
11586 
          self.userId = iprot.readI64();
11587 
        else:
11588 
          iprot.skip(ftype)
6389 rajveer 11589 
      elif fid == 7:
11590 
        if ftype == TType.I64:
11591 
          self.schemeId = iprot.readI64();
11592 
        else:
11593 
          iprot.skip(ftype)
11526 amit.gupta 11594 
      elif fid == 8:
11595 
        if ftype == TType.I64:
11596 
          self.orderSource = iprot.readI64();
11597 
        else:
11598 
          iprot.skip(ftype)
559 chandransh 11599 
      else:
11600 
        iprot.skip(ftype)
11601 
      iprot.readFieldEnd()
11602 
    iprot.readStructEnd()
11603 
 
11604 
  def write(self, oprot):
11605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11607 
      return
690 chandransh 11608 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11609 
    if self.cartId is not None:
559 chandransh 11610 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11611 
      oprot.writeI64(self.cartId)
11612 
      oprot.writeFieldEnd()
3431 rajveer 11613 
    if self.sessionSource is not None:
2815 vikas 11614 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11615 
      oprot.writeString(self.sessionSource)
11616 
      oprot.writeFieldEnd()
3431 rajveer 11617 
    if self.sessionStartTime is not None:
2815 vikas 11618 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11619 
      oprot.writeI64(self.sessionStartTime)
11620 
      oprot.writeFieldEnd()
3858 vikas 11621 
    if self.firstSource is not None:
11622 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11623 
      oprot.writeString(self.firstSource)
11624 
      oprot.writeFieldEnd()
11625 
    if self.firstSourceTime is not None:
11626 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11627 
      oprot.writeI64(self.firstSourceTime)
11628 
      oprot.writeFieldEnd()
5326 rajveer 11629 
    if self.userId is not None:
11630 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11631 
      oprot.writeI64(self.userId)
11632 
      oprot.writeFieldEnd()
6389 rajveer 11633 
    if self.schemeId is not None:
11634 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11635 
      oprot.writeI64(self.schemeId)
11636 
      oprot.writeFieldEnd()
11526 amit.gupta 11637 
    if self.orderSource is not None:
11638 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
11639 
      oprot.writeI64(self.orderSource)
11640 
      oprot.writeFieldEnd()
559 chandransh 11641 
    oprot.writeFieldStop()
11642 
    oprot.writeStructEnd()
11643 
 
3431 rajveer 11644 
  def validate(self):
11645 
    return
11646 
 
11647 
 
559 chandransh 11648 
  def __repr__(self):
11649 
    L = ['%s=%r' % (key, value)
11650 
      for key, value in self.__dict__.iteritems()]
11651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11652 
 
11653 
  def __eq__(self, other):
11654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11655 
 
11656 
  def __ne__(self, other):
11657 
    return not (self == other)
11658 
 
690 chandransh 11659 
class createOrders_result:
559 chandransh 11660 
  """
11661 
  Attributes:
94 ashish 11662 
   - success
559 chandransh 11663 
   - scx
94 ashish 11664 
  """
11665 
 
11666 
  thrift_spec = (
575 chandransh 11667 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11668 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11669 
  )
11670 
 
559 chandransh 11671 
  def __init__(self, success=None, scx=None,):
94 ashish 11672 
    self.success = success
559 chandransh 11673 
    self.scx = scx
94 ashish 11674 
 
11675 
  def read(self, iprot):
11676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11678 
      return
11679 
    iprot.readStructBegin()
11680 
    while True:
11681 
      (fname, ftype, fid) = iprot.readFieldBegin()
11682 
      if ftype == TType.STOP:
11683 
        break
11684 
      if fid == 0:
575 chandransh 11685 
        if ftype == TType.I64:
11686 
          self.success = iprot.readI64();
94 ashish 11687 
        else:
11688 
          iprot.skip(ftype)
11689 
      elif fid == 1:
11690 
        if ftype == TType.STRUCT:
559 chandransh 11691 
          self.scx = ShoppingCartException()
11692 
          self.scx.read(iprot)
94 ashish 11693 
        else:
11694 
          iprot.skip(ftype)
11695 
      else:
11696 
        iprot.skip(ftype)
11697 
      iprot.readFieldEnd()
11698 
    iprot.readStructEnd()
11699 
 
11700 
  def write(self, oprot):
11701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11703 
      return
690 chandransh 11704 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11705 
    if self.success is not None:
575 chandransh 11706 
      oprot.writeFieldBegin('success', TType.I64, 0)
11707 
      oprot.writeI64(self.success)
94 ashish 11708 
      oprot.writeFieldEnd()
3431 rajveer 11709 
    if self.scx is not None:
559 chandransh 11710 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11711 
      self.scx.write(oprot)
94 ashish 11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
3431 rajveer 11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
94 ashish 11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
559 chandransh 11731 
class validateCart_args:
94 ashish 11732 
  """
11733 
  Attributes:
559 chandransh 11734 
   - cartId
3557 rajveer 11735 
   - sourceId
94 ashish 11736 
  """
11737 
 
11738 
  thrift_spec = (
11739 
    None, # 0
559 chandransh 11740 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11741 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11742 
  )
11743 
 
3557 rajveer 11744 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11745 
    self.cartId = cartId
3557 rajveer 11746 
    self.sourceId = sourceId
94 ashish 11747 
 
11748 
  def read(self, iprot):
11749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11751 
      return
11752 
    iprot.readStructBegin()
11753 
    while True:
11754 
      (fname, ftype, fid) = iprot.readFieldBegin()
11755 
      if ftype == TType.STOP:
11756 
        break
11757 
      if fid == 1:
11758 
        if ftype == TType.I64:
559 chandransh 11759 
          self.cartId = iprot.readI64();
94 ashish 11760 
        else:
11761 
          iprot.skip(ftype)
3557 rajveer 11762 
      elif fid == 2:
11763 
        if ftype == TType.I64:
11764 
          self.sourceId = iprot.readI64();
11765 
        else:
11766 
          iprot.skip(ftype)
94 ashish 11767 
      else:
11768 
        iprot.skip(ftype)
11769 
      iprot.readFieldEnd()
11770 
    iprot.readStructEnd()
11771 
 
11772 
  def write(self, oprot):
11773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11775 
      return
559 chandransh 11776 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 11777 
    if self.cartId is not None:
559 chandransh 11778 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11779 
      oprot.writeI64(self.cartId)
94 ashish 11780 
      oprot.writeFieldEnd()
3557 rajveer 11781 
    if self.sourceId is not None:
11782 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11783 
      oprot.writeI64(self.sourceId)
11784 
      oprot.writeFieldEnd()
94 ashish 11785 
    oprot.writeFieldStop()
11786 
    oprot.writeStructEnd()
11787 
 
3431 rajveer 11788 
  def validate(self):
11789 
    return
11790 
 
11791 
 
94 ashish 11792 
  def __repr__(self):
11793 
    L = ['%s=%r' % (key, value)
11794 
      for key, value in self.__dict__.iteritems()]
11795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11796 
 
11797 
  def __eq__(self, other):
11798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11799 
 
11800 
  def __ne__(self, other):
11801 
    return not (self == other)
11802 
 
559 chandransh 11803 
class validateCart_result:
94 ashish 11804 
  """
11805 
  Attributes:
11806 
   - success
575 chandransh 11807 
   - scex
94 ashish 11808 
  """
11809 
 
11810 
  thrift_spec = (
6736 amit.gupta 11811 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 11812 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11813 
  )
11814 
 
575 chandransh 11815 
  def __init__(self, success=None, scex=None,):
94 ashish 11816 
    self.success = success
575 chandransh 11817 
    self.scex = scex
94 ashish 11818 
 
11819 
  def read(self, iprot):
11820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11822 
      return
11823 
    iprot.readStructBegin()
11824 
    while True:
11825 
      (fname, ftype, fid) = iprot.readFieldBegin()
11826 
      if ftype == TType.STOP:
11827 
        break
11828 
      if fid == 0:
6736 amit.gupta 11829 
        if ftype == TType.LIST:
11830 
          self.success = []
11592 amit.gupta 11831 
          (_etype170, _size167) = iprot.readListBegin()
11832 
          for _i171 in xrange(_size167):
11833 
            _elem172 = iprot.readString();
11834 
            self.success.append(_elem172)
6736 amit.gupta 11835 
          iprot.readListEnd()
94 ashish 11836 
        else:
11837 
          iprot.skip(ftype)
575 chandransh 11838 
      elif fid == 1:
11839 
        if ftype == TType.STRUCT:
11840 
          self.scex = ShoppingCartException()
11841 
          self.scex.read(iprot)
11842 
        else:
11843 
          iprot.skip(ftype)
94 ashish 11844 
      else:
11845 
        iprot.skip(ftype)
11846 
      iprot.readFieldEnd()
11847 
    iprot.readStructEnd()
11848 
 
11849 
  def write(self, oprot):
11850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11852 
      return
559 chandransh 11853 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 11854 
    if self.success is not None:
6736 amit.gupta 11855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11856 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 11857 
      for iter173 in self.success:
11858 
        oprot.writeString(iter173)
6736 amit.gupta 11859 
      oprot.writeListEnd()
94 ashish 11860 
      oprot.writeFieldEnd()
3431 rajveer 11861 
    if self.scex is not None:
575 chandransh 11862 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11863 
      self.scex.write(oprot)
11864 
      oprot.writeFieldEnd()
559 chandransh 11865 
    oprot.writeFieldStop()
11866 
    oprot.writeStructEnd()
11867 
 
3431 rajveer 11868 
  def validate(self):
11869 
    return
11870 
 
11871 
 
559 chandransh 11872 
  def __repr__(self):
11873 
    L = ['%s=%r' % (key, value)
11874 
      for key, value in self.__dict__.iteritems()]
11875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11876 
 
11877 
  def __eq__(self, other):
11878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11879 
 
11880 
  def __ne__(self, other):
11881 
    return not (self == other)
11882 
 
11980 amit.gupta 11883 
class validateCartWithDealerCoupon_args:
11884 
  """
11885 
  Attributes:
11886 
   - cartId
11887 
   - sourceId
11888 
   - dealCoupon
11889 
  """
11890 
 
11891 
  thrift_spec = (
11892 
    None, # 0
11893 
    (1, TType.I64, 'cartId', None, None, ), # 1
11894 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11895 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
11896 
  )
11897 
 
11898 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
11899 
    self.cartId = cartId
11900 
    self.sourceId = sourceId
11901 
    self.dealCoupon = dealCoupon
11902 
 
11903 
  def read(self, iprot):
11904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11906 
      return
11907 
    iprot.readStructBegin()
11908 
    while True:
11909 
      (fname, ftype, fid) = iprot.readFieldBegin()
11910 
      if ftype == TType.STOP:
11911 
        break
11912 
      if fid == 1:
11913 
        if ftype == TType.I64:
11914 
          self.cartId = iprot.readI64();
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      elif fid == 2:
11918 
        if ftype == TType.I64:
11919 
          self.sourceId = iprot.readI64();
11920 
        else:
11921 
          iprot.skip(ftype)
11922 
      elif fid == 3:
11923 
        if ftype == TType.STRING:
11924 
          self.dealCoupon = iprot.readString();
11925 
        else:
11926 
          iprot.skip(ftype)
11927 
      else:
11928 
        iprot.skip(ftype)
11929 
      iprot.readFieldEnd()
11930 
    iprot.readStructEnd()
11931 
 
11932 
  def write(self, oprot):
11933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11935 
      return
11936 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
11937 
    if self.cartId is not None:
11938 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11939 
      oprot.writeI64(self.cartId)
11940 
      oprot.writeFieldEnd()
11941 
    if self.sourceId is not None:
11942 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11943 
      oprot.writeI64(self.sourceId)
11944 
      oprot.writeFieldEnd()
11945 
    if self.dealCoupon is not None:
11946 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
11947 
      oprot.writeString(self.dealCoupon)
11948 
      oprot.writeFieldEnd()
11949 
    oprot.writeFieldStop()
11950 
    oprot.writeStructEnd()
11951 
 
11952 
  def validate(self):
11953 
    return
11954 
 
11955 
 
11956 
  def __repr__(self):
11957 
    L = ['%s=%r' % (key, value)
11958 
      for key, value in self.__dict__.iteritems()]
11959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11960 
 
11961 
  def __eq__(self, other):
11962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11963 
 
11964 
  def __ne__(self, other):
11965 
    return not (self == other)
11966 
 
11967 
class validateCartWithDealerCoupon_result:
11968 
  """
11969 
  Attributes:
11970 
   - success
11971 
   - scex
11972 
  """
11973 
 
11974 
  thrift_spec = (
11975 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11976 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11977 
  )
11978 
 
11979 
  def __init__(self, success=None, scex=None,):
11980 
    self.success = success
11981 
    self.scex = scex
11982 
 
11983 
  def read(self, iprot):
11984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11986 
      return
11987 
    iprot.readStructBegin()
11988 
    while True:
11989 
      (fname, ftype, fid) = iprot.readFieldBegin()
11990 
      if ftype == TType.STOP:
11991 
        break
11992 
      if fid == 0:
11993 
        if ftype == TType.LIST:
11994 
          self.success = []
11995 
          (_etype177, _size174) = iprot.readListBegin()
11996 
          for _i178 in xrange(_size174):
11997 
            _elem179 = iprot.readString();
11998 
            self.success.append(_elem179)
11999 
          iprot.readListEnd()
12000 
        else:
12001 
          iprot.skip(ftype)
12002 
      elif fid == 1:
12003 
        if ftype == TType.STRUCT:
12004 
          self.scex = ShoppingCartException()
12005 
          self.scex.read(iprot)
12006 
        else:
12007 
          iprot.skip(ftype)
12008 
      else:
12009 
        iprot.skip(ftype)
12010 
      iprot.readFieldEnd()
12011 
    iprot.readStructEnd()
12012 
 
12013 
  def write(self, oprot):
12014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12016 
      return
12017 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12018 
    if self.success is not None:
12019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12020 
      oprot.writeListBegin(TType.STRING, len(self.success))
12021 
      for iter180 in self.success:
12022 
        oprot.writeString(iter180)
12023 
      oprot.writeListEnd()
12024 
      oprot.writeFieldEnd()
12025 
    if self.scex is not None:
12026 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12027 
      self.scex.write(oprot)
12028 
      oprot.writeFieldEnd()
12029 
    oprot.writeFieldStop()
12030 
    oprot.writeStructEnd()
12031 
 
12032 
  def validate(self):
12033 
    return
12034 
 
12035 
 
12036 
  def __repr__(self):
12037 
    L = ['%s=%r' % (key, value)
12038 
      for key, value in self.__dict__.iteritems()]
12039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12040 
 
12041 
  def __eq__(self, other):
12042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12043 
 
12044 
  def __ne__(self, other):
12045 
    return not (self == other)
12046 
 
690 chandransh 12047 
class mergeCart_args:
575 chandransh 12048 
  """
12049 
  Attributes:
690 chandransh 12050 
   - fromCartId
12051 
   - toCartId
12052 
  """
12053 
 
12054 
  thrift_spec = (
12055 
    None, # 0
12056 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12057 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12058 
  )
12059 
 
12060 
  def __init__(self, fromCartId=None, toCartId=None,):
12061 
    self.fromCartId = fromCartId
12062 
    self.toCartId = toCartId
12063 
 
12064 
  def read(self, iprot):
12065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12067 
      return
12068 
    iprot.readStructBegin()
12069 
    while True:
12070 
      (fname, ftype, fid) = iprot.readFieldBegin()
12071 
      if ftype == TType.STOP:
12072 
        break
12073 
      if fid == 1:
12074 
        if ftype == TType.I64:
12075 
          self.fromCartId = iprot.readI64();
12076 
        else:
12077 
          iprot.skip(ftype)
12078 
      elif fid == 2:
12079 
        if ftype == TType.I64:
12080 
          self.toCartId = iprot.readI64();
12081 
        else:
12082 
          iprot.skip(ftype)
12083 
      else:
12084 
        iprot.skip(ftype)
12085 
      iprot.readFieldEnd()
12086 
    iprot.readStructEnd()
12087 
 
12088 
  def write(self, oprot):
12089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12091 
      return
12092 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12093 
    if self.fromCartId is not None:
690 chandransh 12094 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12095 
      oprot.writeI64(self.fromCartId)
12096 
      oprot.writeFieldEnd()
3431 rajveer 12097 
    if self.toCartId is not None:
690 chandransh 12098 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12099 
      oprot.writeI64(self.toCartId)
12100 
      oprot.writeFieldEnd()
12101 
    oprot.writeFieldStop()
12102 
    oprot.writeStructEnd()
12103 
 
3431 rajveer 12104 
  def validate(self):
12105 
    return
12106 
 
12107 
 
690 chandransh 12108 
  def __repr__(self):
12109 
    L = ['%s=%r' % (key, value)
12110 
      for key, value in self.__dict__.iteritems()]
12111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12112 
 
12113 
  def __eq__(self, other):
12114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12115 
 
12116 
  def __ne__(self, other):
12117 
    return not (self == other)
12118 
 
12119 
class mergeCart_result:
12120 
 
12121 
  thrift_spec = (
12122 
  )
12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      else:
12134 
        iprot.skip(ftype)
12135 
      iprot.readFieldEnd()
12136 
    iprot.readStructEnd()
12137 
 
12138 
  def write(self, oprot):
12139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12141 
      return
12142 
    oprot.writeStructBegin('mergeCart_result')
12143 
    oprot.writeFieldStop()
12144 
    oprot.writeStructEnd()
12145 
 
3431 rajveer 12146 
  def validate(self):
12147 
    return
12148 
 
12149 
 
690 chandransh 12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
12161 
class checkOut_args:
12162 
  """
12163 
  Attributes:
575 chandransh 12164 
   - cartId
12165 
  """
12166 
 
12167 
  thrift_spec = (
12168 
    None, # 0
12169 
    (1, TType.I64, 'cartId', None, None, ), # 1
12170 
  )
12171 
 
12172 
  def __init__(self, cartId=None,):
12173 
    self.cartId = cartId
12174 
 
12175 
  def read(self, iprot):
12176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12178 
      return
12179 
    iprot.readStructBegin()
12180 
    while True:
12181 
      (fname, ftype, fid) = iprot.readFieldBegin()
12182 
      if ftype == TType.STOP:
12183 
        break
12184 
      if fid == 1:
12185 
        if ftype == TType.I64:
12186 
          self.cartId = iprot.readI64();
12187 
        else:
12188 
          iprot.skip(ftype)
12189 
      else:
12190 
        iprot.skip(ftype)
12191 
      iprot.readFieldEnd()
12192 
    iprot.readStructEnd()
12193 
 
12194 
  def write(self, oprot):
12195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12197 
      return
690 chandransh 12198 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12199 
    if self.cartId is not None:
575 chandransh 12200 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12201 
      oprot.writeI64(self.cartId)
12202 
      oprot.writeFieldEnd()
12203 
    oprot.writeFieldStop()
12204 
    oprot.writeStructEnd()
12205 
 
3431 rajveer 12206 
  def validate(self):
12207 
    return
12208 
 
12209 
 
575 chandransh 12210 
  def __repr__(self):
12211 
    L = ['%s=%r' % (key, value)
12212 
      for key, value in self.__dict__.iteritems()]
12213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12214 
 
12215 
  def __eq__(self, other):
12216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12217 
 
12218 
  def __ne__(self, other):
12219 
    return not (self == other)
12220 
 
690 chandransh 12221 
class checkOut_result:
575 chandransh 12222 
  """
12223 
  Attributes:
12224 
   - success
12225 
   - scex
12226 
  """
12227 
 
12228 
  thrift_spec = (
12229 
    (0, TType.BOOL, 'success', None, None, ), # 0
12230 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12231 
  )
12232 
 
12233 
  def __init__(self, success=None, scex=None,):
12234 
    self.success = success
12235 
    self.scex = scex
12236 
 
12237 
  def read(self, iprot):
12238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12240 
      return
12241 
    iprot.readStructBegin()
12242 
    while True:
12243 
      (fname, ftype, fid) = iprot.readFieldBegin()
12244 
      if ftype == TType.STOP:
12245 
        break
12246 
      if fid == 0:
12247 
        if ftype == TType.BOOL:
12248 
          self.success = iprot.readBool();
12249 
        else:
12250 
          iprot.skip(ftype)
12251 
      elif fid == 1:
12252 
        if ftype == TType.STRUCT:
12253 
          self.scex = ShoppingCartException()
12254 
          self.scex.read(iprot)
12255 
        else:
12256 
          iprot.skip(ftype)
12257 
      else:
12258 
        iprot.skip(ftype)
12259 
      iprot.readFieldEnd()
12260 
    iprot.readStructEnd()
12261 
 
12262 
  def write(self, oprot):
12263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12265 
      return
690 chandransh 12266 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12267 
    if self.success is not None:
575 chandransh 12268 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12269 
      oprot.writeBool(self.success)
12270 
      oprot.writeFieldEnd()
3431 rajveer 12271 
    if self.scex is not None:
575 chandransh 12272 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12273 
      self.scex.write(oprot)
12274 
      oprot.writeFieldEnd()
12275 
    oprot.writeFieldStop()
12276 
    oprot.writeStructEnd()
12277 
 
3431 rajveer 12278 
  def validate(self):
12279 
    return
12280 
 
12281 
 
575 chandransh 12282 
  def __repr__(self):
12283 
    L = ['%s=%r' % (key, value)
12284 
      for key, value in self.__dict__.iteritems()]
12285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12286 
 
12287 
  def __eq__(self, other):
12288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12289 
 
12290 
  def __ne__(self, other):
12291 
    return not (self == other)
12292 
 
690 chandransh 12293 
class resetCart_args:
559 chandransh 12294 
  """
12295 
  Attributes:
690 chandransh 12296 
   - cartId
12297 
   - items
559 chandransh 12298 
  """
12299 
 
12300 
  thrift_spec = (
12301 
    None, # 0
690 chandransh 12302 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12303 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12304 
  )
12305 
 
690 chandransh 12306 
  def __init__(self, cartId=None, items=None,):
12307 
    self.cartId = cartId
12308 
    self.items = items
559 chandransh 12309 
 
12310 
  def read(self, iprot):
12311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12313 
      return
12314 
    iprot.readStructBegin()
12315 
    while True:
12316 
      (fname, ftype, fid) = iprot.readFieldBegin()
12317 
      if ftype == TType.STOP:
12318 
        break
12319 
      if fid == 1:
12320 
        if ftype == TType.I64:
690 chandransh 12321 
          self.cartId = iprot.readI64();
559 chandransh 12322 
        else:
12323 
          iprot.skip(ftype)
12324 
      elif fid == 2:
690 chandransh 12325 
        if ftype == TType.MAP:
12326 
          self.items = {}
11980 amit.gupta 12327 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12328 
          for _i185 in xrange(_size181):
12329 
            _key186 = iprot.readI64();
12330 
            _val187 = iprot.readDouble();
12331 
            self.items[_key186] = _val187
690 chandransh 12332 
          iprot.readMapEnd()
559 chandransh 12333 
        else:
12334 
          iprot.skip(ftype)
12335 
      else:
12336 
        iprot.skip(ftype)
12337 
      iprot.readFieldEnd()
12338 
    iprot.readStructEnd()
12339 
 
12340 
  def write(self, oprot):
12341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12343 
      return
690 chandransh 12344 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12345 
    if self.cartId is not None:
690 chandransh 12346 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12347 
      oprot.writeI64(self.cartId)
94 ashish 12348 
      oprot.writeFieldEnd()
3431 rajveer 12349 
    if self.items is not None:
690 chandransh 12350 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12351 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12352 
      for kiter188,viter189 in self.items.items():
12353 
        oprot.writeI64(kiter188)
12354 
        oprot.writeDouble(viter189)
690 chandransh 12355 
      oprot.writeMapEnd()
559 chandransh 12356 
      oprot.writeFieldEnd()
94 ashish 12357 
    oprot.writeFieldStop()
12358 
    oprot.writeStructEnd()
12359 
 
3431 rajveer 12360 
  def validate(self):
12361 
    return
12362 
 
12363 
 
94 ashish 12364 
  def __repr__(self):
12365 
    L = ['%s=%r' % (key, value)
12366 
      for key, value in self.__dict__.iteritems()]
12367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12368 
 
12369 
  def __eq__(self, other):
12370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12371 
 
12372 
  def __ne__(self, other):
12373 
    return not (self == other)
12374 
 
690 chandransh 12375 
class resetCart_result:
12376 
  """
12377 
  Attributes:
12378 
   - success
12379 
   - scex
12380 
  """
559 chandransh 12381 
 
12382 
  thrift_spec = (
690 chandransh 12383 
    (0, TType.BOOL, 'success', None, None, ), # 0
12384 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12385 
  )
12386 
 
690 chandransh 12387 
  def __init__(self, success=None, scex=None,):
12388 
    self.success = success
12389 
    self.scex = scex
12390 
 
559 chandransh 12391 
  def read(self, iprot):
12392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12394 
      return
12395 
    iprot.readStructBegin()
12396 
    while True:
12397 
      (fname, ftype, fid) = iprot.readFieldBegin()
12398 
      if ftype == TType.STOP:
12399 
        break
690 chandransh 12400 
      if fid == 0:
12401 
        if ftype == TType.BOOL:
12402 
          self.success = iprot.readBool();
12403 
        else:
12404 
          iprot.skip(ftype)
12405 
      elif fid == 1:
12406 
        if ftype == TType.STRUCT:
12407 
          self.scex = ShoppingCartException()
12408 
          self.scex.read(iprot)
12409 
        else:
12410 
          iprot.skip(ftype)
559 chandransh 12411 
      else:
12412 
        iprot.skip(ftype)
12413 
      iprot.readFieldEnd()
12414 
    iprot.readStructEnd()
12415 
 
12416 
  def write(self, oprot):
12417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12419 
      return
690 chandransh 12420 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12421 
    if self.success is not None:
690 chandransh 12422 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12423 
      oprot.writeBool(self.success)
12424 
      oprot.writeFieldEnd()
3431 rajveer 12425 
    if self.scex is not None:
690 chandransh 12426 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12427 
      self.scex.write(oprot)
12428 
      oprot.writeFieldEnd()
559 chandransh 12429 
    oprot.writeFieldStop()
12430 
    oprot.writeStructEnd()
12431 
 
3431 rajveer 12432 
  def validate(self):
12433 
    return
12434 
 
12435 
 
559 chandransh 12436 
  def __repr__(self):
12437 
    L = ['%s=%r' % (key, value)
12438 
      for key, value in self.__dict__.iteritems()]
12439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12440 
 
12441 
  def __eq__(self, other):
12442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12443 
 
12444 
  def __ne__(self, other):
12445 
    return not (self == other)
12446 
 
2981 rajveer 12447 
class getUserCount_args:
94 ashish 12448 
  """
12449 
  Attributes:
2981 rajveer 12450 
   - userType
559 chandransh 12451 
  """
12452 
 
12453 
  thrift_spec = (
12454 
    None, # 0
2981 rajveer 12455 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12456 
  )
12457 
 
2981 rajveer 12458 
  def __init__(self, userType=None,):
12459 
    self.userType = userType
559 chandransh 12460 
 
12461 
  def read(self, iprot):
12462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12464 
      return
12465 
    iprot.readStructBegin()
12466 
    while True:
12467 
      (fname, ftype, fid) = iprot.readFieldBegin()
12468 
      if ftype == TType.STOP:
12469 
        break
12470 
      if fid == 1:
2981 rajveer 12471 
        if ftype == TType.I32:
12472 
          self.userType = iprot.readI32();
559 chandransh 12473 
        else:
12474 
          iprot.skip(ftype)
12475 
      else:
12476 
        iprot.skip(ftype)
12477 
      iprot.readFieldEnd()
12478 
    iprot.readStructEnd()
12479 
 
12480 
  def write(self, oprot):
12481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12483 
      return
2981 rajveer 12484 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12485 
    if self.userType is not None:
2981 rajveer 12486 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12487 
      oprot.writeI32(self.userType)
559 chandransh 12488 
      oprot.writeFieldEnd()
12489 
    oprot.writeFieldStop()
12490 
    oprot.writeStructEnd()
12491 
 
3431 rajveer 12492 
  def validate(self):
12493 
    return
12494 
 
12495 
 
559 chandransh 12496 
  def __repr__(self):
12497 
    L = ['%s=%r' % (key, value)
12498 
      for key, value in self.__dict__.iteritems()]
12499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12500 
 
12501 
  def __eq__(self, other):
12502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12503 
 
12504 
  def __ne__(self, other):
12505 
    return not (self == other)
12506 
 
2981 rajveer 12507 
class getUserCount_result:
94 ashish 12508 
  """
12509 
  Attributes:
12510 
   - success
12511 
  """
12512 
 
12513 
  thrift_spec = (
2981 rajveer 12514 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12515 
  )
12516 
 
2981 rajveer 12517 
  def __init__(self, success=None,):
94 ashish 12518 
    self.success = success
12519 
 
12520 
  def read(self, iprot):
12521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12523 
      return
12524 
    iprot.readStructBegin()
12525 
    while True:
12526 
      (fname, ftype, fid) = iprot.readFieldBegin()
12527 
      if ftype == TType.STOP:
12528 
        break
12529 
      if fid == 0:
2981 rajveer 12530 
        if ftype == TType.I64:
12531 
          self.success = iprot.readI64();
94 ashish 12532 
        else:
12533 
          iprot.skip(ftype)
12534 
      else:
12535 
        iprot.skip(ftype)
12536 
      iprot.readFieldEnd()
12537 
    iprot.readStructEnd()
12538 
 
12539 
  def write(self, oprot):
12540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12542 
      return
2981 rajveer 12543 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12544 
    if self.success is not None:
2981 rajveer 12545 
      oprot.writeFieldBegin('success', TType.I64, 0)
12546 
      oprot.writeI64(self.success)
94 ashish 12547 
      oprot.writeFieldEnd()
12548 
    oprot.writeFieldStop()
12549 
    oprot.writeStructEnd()
12550 
 
3431 rajveer 12551 
  def validate(self):
12552 
    return
12553 
 
12554 
 
94 ashish 12555 
  def __repr__(self):
12556 
    L = ['%s=%r' % (key, value)
12557 
      for key, value in self.__dict__.iteritems()]
12558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12559 
 
12560 
  def __eq__(self, other):
12561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12562 
 
12563 
  def __ne__(self, other):
12564 
    return not (self == other)
12565 
 
2981 rajveer 12566 
class getAllUsers_args:
94 ashish 12567 
  """
12568 
  Attributes:
2981 rajveer 12569 
   - userType
12570 
   - startDate
12571 
   - endDate
94 ashish 12572 
  """
12573 
 
12574 
  thrift_spec = (
12575 
    None, # 0
2981 rajveer 12576 
    (1, TType.I32, 'userType', None, None, ), # 1
12577 
    (2, TType.I64, 'startDate', None, None, ), # 2
12578 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12579 
  )
12580 
 
2981 rajveer 12581 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12582 
    self.userType = userType
12583 
    self.startDate = startDate
12584 
    self.endDate = endDate
94 ashish 12585 
 
12586 
  def read(self, iprot):
12587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12589 
      return
12590 
    iprot.readStructBegin()
12591 
    while True:
12592 
      (fname, ftype, fid) = iprot.readFieldBegin()
12593 
      if ftype == TType.STOP:
12594 
        break
12595 
      if fid == 1:
2981 rajveer 12596 
        if ftype == TType.I32:
12597 
          self.userType = iprot.readI32();
94 ashish 12598 
        else:
12599 
          iprot.skip(ftype)
12600 
      elif fid == 2:
559 chandransh 12601 
        if ftype == TType.I64:
2981 rajveer 12602 
          self.startDate = iprot.readI64();
94 ashish 12603 
        else:
12604 
          iprot.skip(ftype)
2981 rajveer 12605 
      elif fid == 3:
12606 
        if ftype == TType.I64:
12607 
          self.endDate = iprot.readI64();
12608 
        else:
12609 
          iprot.skip(ftype)
94 ashish 12610 
      else:
12611 
        iprot.skip(ftype)
12612 
      iprot.readFieldEnd()
12613 
    iprot.readStructEnd()
12614 
 
12615 
  def write(self, oprot):
12616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12618 
      return
2981 rajveer 12619 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12620 
    if self.userType is not None:
2981 rajveer 12621 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12622 
      oprot.writeI32(self.userType)
94 ashish 12623 
      oprot.writeFieldEnd()
3431 rajveer 12624 
    if self.startDate is not None:
2981 rajveer 12625 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12626 
      oprot.writeI64(self.startDate)
94 ashish 12627 
      oprot.writeFieldEnd()
3431 rajveer 12628 
    if self.endDate is not None:
2981 rajveer 12629 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12630 
      oprot.writeI64(self.endDate)
12631 
      oprot.writeFieldEnd()
94 ashish 12632 
    oprot.writeFieldStop()
12633 
    oprot.writeStructEnd()
12634 
 
3431 rajveer 12635 
  def validate(self):
12636 
    return
12637 
 
12638 
 
94 ashish 12639 
  def __repr__(self):
12640 
    L = ['%s=%r' % (key, value)
12641 
      for key, value in self.__dict__.iteritems()]
12642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12643 
 
12644 
  def __eq__(self, other):
12645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12646 
 
12647 
  def __ne__(self, other):
12648 
    return not (self == other)
12649 
 
2981 rajveer 12650 
class getAllUsers_result:
94 ashish 12651 
  """
12652 
  Attributes:
12653 
   - success
12654 
  """
12655 
 
12656 
  thrift_spec = (
2981 rajveer 12657 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12658 
  )
12659 
 
2981 rajveer 12660 
  def __init__(self, success=None,):
94 ashish 12661 
    self.success = success
12662 
 
12663 
  def read(self, iprot):
12664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12666 
      return
12667 
    iprot.readStructBegin()
12668 
    while True:
12669 
      (fname, ftype, fid) = iprot.readFieldBegin()
12670 
      if ftype == TType.STOP:
12671 
        break
12672 
      if fid == 0:
2981 rajveer 12673 
        if ftype == TType.LIST:
12674 
          self.success = []
11980 amit.gupta 12675 
          (_etype193, _size190) = iprot.readListBegin()
12676 
          for _i194 in xrange(_size190):
12677 
            _elem195 = User()
12678 
            _elem195.read(iprot)
12679 
            self.success.append(_elem195)
2981 rajveer 12680 
          iprot.readListEnd()
94 ashish 12681 
        else:
12682 
          iprot.skip(ftype)
12683 
      else:
12684 
        iprot.skip(ftype)
12685 
      iprot.readFieldEnd()
12686 
    iprot.readStructEnd()
12687 
 
12688 
  def write(self, oprot):
12689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12691 
      return
2981 rajveer 12692 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12693 
    if self.success is not None:
2981 rajveer 12694 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12695 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 12696 
      for iter196 in self.success:
12697 
        iter196.write(oprot)
2981 rajveer 12698 
      oprot.writeListEnd()
94 ashish 12699 
      oprot.writeFieldEnd()
12700 
    oprot.writeFieldStop()
12701 
    oprot.writeStructEnd()
12702 
 
3431 rajveer 12703 
  def validate(self):
12704 
    return
12705 
 
12706 
 
94 ashish 12707 
  def __repr__(self):
12708 
    L = ['%s=%r' % (key, value)
12709 
      for key, value in self.__dict__.iteritems()]
12710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12711 
 
12712 
  def __eq__(self, other):
12713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12714 
 
12715 
  def __ne__(self, other):
12716 
    return not (self == other)
12717 
 
2981 rajveer 12718 
class getMyResearchItems_args:
559 chandransh 12719 
  """
12720 
  Attributes:
772 rajveer 12721 
   - userId
559 chandransh 12722 
  """
12723 
 
12724 
  thrift_spec = (
12725 
    None, # 0
772 rajveer 12726 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12727 
  )
12728 
 
772 rajveer 12729 
  def __init__(self, userId=None,):
12730 
    self.userId = userId
559 chandransh 12731 
 
12732 
  def read(self, iprot):
12733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12735 
      return
12736 
    iprot.readStructBegin()
12737 
    while True:
12738 
      (fname, ftype, fid) = iprot.readFieldBegin()
12739 
      if ftype == TType.STOP:
12740 
        break
12741 
      if fid == 1:
12742 
        if ftype == TType.I64:
772 rajveer 12743 
          self.userId = iprot.readI64();
559 chandransh 12744 
        else:
12745 
          iprot.skip(ftype)
12746 
      else:
12747 
        iprot.skip(ftype)
12748 
      iprot.readFieldEnd()
12749 
    iprot.readStructEnd()
12750 
 
12751 
  def write(self, oprot):
12752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12754 
      return
2981 rajveer 12755 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 12756 
    if self.userId is not None:
772 rajveer 12757 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12758 
      oprot.writeI64(self.userId)
559 chandransh 12759 
      oprot.writeFieldEnd()
12760 
    oprot.writeFieldStop()
12761 
    oprot.writeStructEnd()
12762 
 
3431 rajveer 12763 
  def validate(self):
12764 
    return
12765 
 
12766 
 
559 chandransh 12767 
  def __repr__(self):
12768 
    L = ['%s=%r' % (key, value)
12769 
      for key, value in self.__dict__.iteritems()]
12770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12771 
 
12772 
  def __eq__(self, other):
12773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12774 
 
12775 
  def __ne__(self, other):
12776 
    return not (self == other)
12777 
 
2981 rajveer 12778 
class getMyResearchItems_result:
559 chandransh 12779 
  """
12780 
  Attributes:
130 ashish 12781 
   - success
559 chandransh 12782 
   - scx
130 ashish 12783 
  """
12784 
 
12785 
  thrift_spec = (
2981 rajveer 12786 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12787 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12788 
  )
12789 
 
559 chandransh 12790 
  def __init__(self, success=None, scx=None,):
130 ashish 12791 
    self.success = success
559 chandransh 12792 
    self.scx = scx
130 ashish 12793 
 
12794 
  def read(self, iprot):
12795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12797 
      return
12798 
    iprot.readStructBegin()
12799 
    while True:
12800 
      (fname, ftype, fid) = iprot.readFieldBegin()
12801 
      if ftype == TType.STOP:
12802 
        break
12803 
      if fid == 0:
2981 rajveer 12804 
        if ftype == TType.LIST:
12805 
          self.success = []
11980 amit.gupta 12806 
          (_etype200, _size197) = iprot.readListBegin()
12807 
          for _i201 in xrange(_size197):
12808 
            _elem202 = iprot.readI64();
12809 
            self.success.append(_elem202)
2981 rajveer 12810 
          iprot.readListEnd()
130 ashish 12811 
        else:
12812 
          iprot.skip(ftype)
12813 
      elif fid == 1:
12814 
        if ftype == TType.STRUCT:
559 chandransh 12815 
          self.scx = WidgetException()
12816 
          self.scx.read(iprot)
130 ashish 12817 
        else:
12818 
          iprot.skip(ftype)
12819 
      else:
12820 
        iprot.skip(ftype)
12821 
      iprot.readFieldEnd()
12822 
    iprot.readStructEnd()
12823 
 
12824 
  def write(self, oprot):
12825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12827 
      return
2981 rajveer 12828 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 12829 
    if self.success is not None:
2981 rajveer 12830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12831 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 12832 
      for iter203 in self.success:
12833 
        oprot.writeI64(iter203)
2981 rajveer 12834 
      oprot.writeListEnd()
130 ashish 12835 
      oprot.writeFieldEnd()
3431 rajveer 12836 
    if self.scx is not None:
559 chandransh 12837 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12838 
      self.scx.write(oprot)
130 ashish 12839 
      oprot.writeFieldEnd()
12840 
    oprot.writeFieldStop()
12841 
    oprot.writeStructEnd()
12842 
 
3431 rajveer 12843 
  def validate(self):
12844 
    return
12845 
 
12846 
 
130 ashish 12847 
  def __repr__(self):
12848 
    L = ['%s=%r' % (key, value)
12849 
      for key, value in self.__dict__.iteritems()]
12850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12851 
 
12852 
  def __eq__(self, other):
12853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12854 
 
12855 
  def __ne__(self, other):
12856 
    return not (self == other)
12857 
 
2981 rajveer 12858 
class updateMyResearch_args:
130 ashish 12859 
  """
12860 
  Attributes:
2981 rajveer 12861 
   - userId
12862 
   - itemId
130 ashish 12863 
  """
12864 
 
12865 
  thrift_spec = (
12866 
    None, # 0
2981 rajveer 12867 
    (1, TType.I64, 'userId', None, None, ), # 1
12868 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12869 
  )
12870 
 
2981 rajveer 12871 
  def __init__(self, userId=None, itemId=None,):
12872 
    self.userId = userId
12873 
    self.itemId = itemId
130 ashish 12874 
 
12875 
  def read(self, iprot):
12876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12878 
      return
12879 
    iprot.readStructBegin()
12880 
    while True:
12881 
      (fname, ftype, fid) = iprot.readFieldBegin()
12882 
      if ftype == TType.STOP:
12883 
        break
12884 
      if fid == 1:
559 chandransh 12885 
        if ftype == TType.I64:
2981 rajveer 12886 
          self.userId = iprot.readI64();
130 ashish 12887 
        else:
12888 
          iprot.skip(ftype)
12889 
      elif fid == 2:
559 chandransh 12890 
        if ftype == TType.I64:
2981 rajveer 12891 
          self.itemId = iprot.readI64();
559 chandransh 12892 
        else:
12893 
          iprot.skip(ftype)
130 ashish 12894 
      else:
12895 
        iprot.skip(ftype)
12896 
      iprot.readFieldEnd()
12897 
    iprot.readStructEnd()
12898 
 
12899 
  def write(self, oprot):
12900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12902 
      return
2981 rajveer 12903 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 12904 
    if self.userId is not None:
2981 rajveer 12905 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12906 
      oprot.writeI64(self.userId)
130 ashish 12907 
      oprot.writeFieldEnd()
3431 rajveer 12908 
    if self.itemId is not None:
2981 rajveer 12909 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12910 
      oprot.writeI64(self.itemId)
130 ashish 12911 
      oprot.writeFieldEnd()
12912 
    oprot.writeFieldStop()
12913 
    oprot.writeStructEnd()
12914 
 
3431 rajveer 12915 
  def validate(self):
12916 
    return
12917 
 
12918 
 
130 ashish 12919 
  def __repr__(self):
12920 
    L = ['%s=%r' % (key, value)
12921 
      for key, value in self.__dict__.iteritems()]
12922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12923 
 
12924 
  def __eq__(self, other):
12925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12926 
 
12927 
  def __ne__(self, other):
12928 
    return not (self == other)
12929 
 
2981 rajveer 12930 
class updateMyResearch_result:
12931 
  """
12932 
  Attributes:
12933 
   - success
12934 
   - scx
12935 
  """
559 chandransh 12936 
 
12937 
  thrift_spec = (
2981 rajveer 12938 
    (0, TType.BOOL, 'success', None, None, ), # 0
12939 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12940 
  )
12941 
 
2981 rajveer 12942 
  def __init__(self, success=None, scx=None,):
12943 
    self.success = success
12944 
    self.scx = scx
12945 
 
559 chandransh 12946 
  def read(self, iprot):
12947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12949 
      return
12950 
    iprot.readStructBegin()
12951 
    while True:
12952 
      (fname, ftype, fid) = iprot.readFieldBegin()
12953 
      if ftype == TType.STOP:
12954 
        break
2981 rajveer 12955 
      if fid == 0:
12956 
        if ftype == TType.BOOL:
12957 
          self.success = iprot.readBool();
12958 
        else:
12959 
          iprot.skip(ftype)
12960 
      elif fid == 1:
12961 
        if ftype == TType.STRUCT:
12962 
          self.scx = WidgetException()
12963 
          self.scx.read(iprot)
12964 
        else:
12965 
          iprot.skip(ftype)
559 chandransh 12966 
      else:
12967 
        iprot.skip(ftype)
12968 
      iprot.readFieldEnd()
12969 
    iprot.readStructEnd()
12970 
 
12971 
  def write(self, oprot):
12972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12974 
      return
2981 rajveer 12975 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 12976 
    if self.success is not None:
2981 rajveer 12977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12978 
      oprot.writeBool(self.success)
12979 
      oprot.writeFieldEnd()
3431 rajveer 12980 
    if self.scx is not None:
2981 rajveer 12981 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12982 
      self.scx.write(oprot)
12983 
      oprot.writeFieldEnd()
559 chandransh 12984 
    oprot.writeFieldStop()
12985 
    oprot.writeStructEnd()
12986 
 
3431 rajveer 12987 
  def validate(self):
12988 
    return
12989 
 
12990 
 
559 chandransh 12991 
  def __repr__(self):
12992 
    L = ['%s=%r' % (key, value)
12993 
      for key, value in self.__dict__.iteritems()]
12994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12995 
 
12996 
  def __eq__(self, other):
12997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12998 
 
12999 
  def __ne__(self, other):
13000 
    return not (self == other)
13001 
 
2981 rajveer 13002 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13003 
  """
13004 
  Attributes:
2981 rajveer 13005 
   - userId
13006 
   - itemId
1596 ankur.sing 13007 
  """
559 chandransh 13008 
 
1596 ankur.sing 13009 
  thrift_spec = (
13010 
    None, # 0
2981 rajveer 13011 
    (1, TType.I64, 'userId', None, None, ), # 1
13012 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13013 
  )
13014 
 
2981 rajveer 13015 
  def __init__(self, userId=None, itemId=None,):
13016 
    self.userId = userId
13017 
    self.itemId = itemId
1596 ankur.sing 13018 
 
13019 
  def read(self, iprot):
13020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13022 
      return
13023 
    iprot.readStructBegin()
13024 
    while True:
13025 
      (fname, ftype, fid) = iprot.readFieldBegin()
13026 
      if ftype == TType.STOP:
13027 
        break
13028 
      if fid == 1:
2981 rajveer 13029 
        if ftype == TType.I64:
13030 
          self.userId = iprot.readI64();
1596 ankur.sing 13031 
        else:
13032 
          iprot.skip(ftype)
2981 rajveer 13033 
      elif fid == 2:
13034 
        if ftype == TType.I64:
13035 
          self.itemId = iprot.readI64();
13036 
        else:
13037 
          iprot.skip(ftype)
1596 ankur.sing 13038 
      else:
13039 
        iprot.skip(ftype)
13040 
      iprot.readFieldEnd()
13041 
    iprot.readStructEnd()
13042 
 
13043 
  def write(self, oprot):
13044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13046 
      return
2981 rajveer 13047 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13048 
    if self.userId is not None:
2981 rajveer 13049 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13050 
      oprot.writeI64(self.userId)
1596 ankur.sing 13051 
      oprot.writeFieldEnd()
3431 rajveer 13052 
    if self.itemId is not None:
2981 rajveer 13053 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13054 
      oprot.writeI64(self.itemId)
13055 
      oprot.writeFieldEnd()
1596 ankur.sing 13056 
    oprot.writeFieldStop()
13057 
    oprot.writeStructEnd()
13058 
 
3431 rajveer 13059 
  def validate(self):
13060 
    return
13061 
 
13062 
 
1596 ankur.sing 13063 
  def __repr__(self):
13064 
    L = ['%s=%r' % (key, value)
13065 
      for key, value in self.__dict__.iteritems()]
13066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13067 
 
13068 
  def __eq__(self, other):
13069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13070 
 
13071 
  def __ne__(self, other):
13072 
    return not (self == other)
13073 
 
2981 rajveer 13074 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13075 
  """
13076 
  Attributes:
2981 rajveer 13077 
   - scx
1596 ankur.sing 13078 
  """
13079 
 
13080 
  thrift_spec = (
2981 rajveer 13081 
    None, # 0
13082 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13083 
  )
13084 
 
2981 rajveer 13085 
  def __init__(self, scx=None,):
13086 
    self.scx = scx
1596 ankur.sing 13087 
 
13088 
  def read(self, iprot):
13089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13091 
      return
13092 
    iprot.readStructBegin()
13093 
    while True:
13094 
      (fname, ftype, fid) = iprot.readFieldBegin()
13095 
      if ftype == TType.STOP:
13096 
        break
2981 rajveer 13097 
      if fid == 1:
13098 
        if ftype == TType.STRUCT:
13099 
          self.scx = WidgetException()
13100 
          self.scx.read(iprot)
1596 ankur.sing 13101 
        else:
13102 
          iprot.skip(ftype)
13103 
      else:
13104 
        iprot.skip(ftype)
13105 
      iprot.readFieldEnd()
13106 
    iprot.readStructEnd()
13107 
 
13108 
  def write(self, oprot):
13109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13111 
      return
2981 rajveer 13112 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13113 
    if self.scx is not None:
2981 rajveer 13114 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13115 
      self.scx.write(oprot)
1596 ankur.sing 13116 
      oprot.writeFieldEnd()
13117 
    oprot.writeFieldStop()
13118 
    oprot.writeStructEnd()
13119 
 
3431 rajveer 13120 
  def validate(self):
13121 
    return
13122 
 
13123 
 
1596 ankur.sing 13124 
  def __repr__(self):
13125 
    L = ['%s=%r' % (key, value)
13126 
      for key, value in self.__dict__.iteritems()]
13127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13128 
 
13129 
  def __eq__(self, other):
13130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13131 
 
13132 
  def __ne__(self, other):
13133 
    return not (self == other)
13134 
 
2981 rajveer 13135 
class getBrowseHistoryItems_args:
1673 ankur.sing 13136 
  """
13137 
  Attributes:
2981 rajveer 13138 
   - userId
1673 ankur.sing 13139 
  """
1596 ankur.sing 13140 
 
1673 ankur.sing 13141 
  thrift_spec = (
13142 
    None, # 0
2981 rajveer 13143 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13144 
  )
13145 
 
2981 rajveer 13146 
  def __init__(self, userId=None,):
13147 
    self.userId = userId
1673 ankur.sing 13148 
 
13149 
  def read(self, iprot):
13150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13152 
      return
13153 
    iprot.readStructBegin()
13154 
    while True:
13155 
      (fname, ftype, fid) = iprot.readFieldBegin()
13156 
      if ftype == TType.STOP:
13157 
        break
13158 
      if fid == 1:
1891 ankur.sing 13159 
        if ftype == TType.I64:
2981 rajveer 13160 
          self.userId = iprot.readI64();
1891 ankur.sing 13161 
        else:
13162 
          iprot.skip(ftype)
1673 ankur.sing 13163 
      else:
13164 
        iprot.skip(ftype)
13165 
      iprot.readFieldEnd()
13166 
    iprot.readStructEnd()
13167 
 
13168 
  def write(self, oprot):
13169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13171 
      return
2981 rajveer 13172 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13173 
    if self.userId is not None:
2981 rajveer 13174 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13175 
      oprot.writeI64(self.userId)
1673 ankur.sing 13176 
      oprot.writeFieldEnd()
13177 
    oprot.writeFieldStop()
13178 
    oprot.writeStructEnd()
13179 
 
3431 rajveer 13180 
  def validate(self):
13181 
    return
13182 
 
13183 
 
1673 ankur.sing 13184 
  def __repr__(self):
13185 
    L = ['%s=%r' % (key, value)
13186 
      for key, value in self.__dict__.iteritems()]
13187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13188 
 
13189 
  def __eq__(self, other):
13190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13191 
 
13192 
  def __ne__(self, other):
13193 
    return not (self == other)
13194 
 
2981 rajveer 13195 
class getBrowseHistoryItems_result:
1673 ankur.sing 13196 
  """
13197 
  Attributes:
13198 
   - success
2981 rajveer 13199 
   - scx
1673 ankur.sing 13200 
  """
13201 
 
13202 
  thrift_spec = (
2981 rajveer 13203 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13204 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13205 
  )
13206 
 
2981 rajveer 13207 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13208 
    self.success = success
2981 rajveer 13209 
    self.scx = scx
1673 ankur.sing 13210 
 
13211 
  def read(self, iprot):
13212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13214 
      return
13215 
    iprot.readStructBegin()
13216 
    while True:
13217 
      (fname, ftype, fid) = iprot.readFieldBegin()
13218 
      if ftype == TType.STOP:
13219 
        break
13220 
      if fid == 0:
13221 
        if ftype == TType.LIST:
13222 
          self.success = []
11980 amit.gupta 13223 
          (_etype207, _size204) = iprot.readListBegin()
13224 
          for _i208 in xrange(_size204):
13225 
            _elem209 = iprot.readI64();
13226 
            self.success.append(_elem209)
1673 ankur.sing 13227 
          iprot.readListEnd()
13228 
        else:
13229 
          iprot.skip(ftype)
2981 rajveer 13230 
      elif fid == 1:
13231 
        if ftype == TType.STRUCT:
13232 
          self.scx = WidgetException()
13233 
          self.scx.read(iprot)
13234 
        else:
13235 
          iprot.skip(ftype)
1673 ankur.sing 13236 
      else:
13237 
        iprot.skip(ftype)
13238 
      iprot.readFieldEnd()
13239 
    iprot.readStructEnd()
13240 
 
13241 
  def write(self, oprot):
13242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13244 
      return
2981 rajveer 13245 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13246 
    if self.success is not None:
1673 ankur.sing 13247 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13248 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13249 
      for iter210 in self.success:
13250 
        oprot.writeI64(iter210)
1673 ankur.sing 13251 
      oprot.writeListEnd()
13252 
      oprot.writeFieldEnd()
3431 rajveer 13253 
    if self.scx is not None:
2981 rajveer 13254 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13255 
      self.scx.write(oprot)
2642 varun.gupt 13256 
      oprot.writeFieldEnd()
13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
3431 rajveer 13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
2642 varun.gupt 13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
2981 rajveer 13275 
class updateBrowseHistory_args:
2642 varun.gupt 13276 
  """
13277 
  Attributes:
2981 rajveer 13278 
   - userId
13279 
   - itemId
2642 varun.gupt 13280 
  """
13281 
 
13282 
  thrift_spec = (
13283 
    None, # 0
2981 rajveer 13284 
    (1, TType.I64, 'userId', None, None, ), # 1
13285 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13286 
  )
13287 
 
2981 rajveer 13288 
  def __init__(self, userId=None, itemId=None,):
13289 
    self.userId = userId
13290 
    self.itemId = itemId
2642 varun.gupt 13291 
 
13292 
  def read(self, iprot):
13293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13295 
      return
13296 
    iprot.readStructBegin()
13297 
    while True:
13298 
      (fname, ftype, fid) = iprot.readFieldBegin()
13299 
      if ftype == TType.STOP:
13300 
        break
13301 
      if fid == 1:
13302 
        if ftype == TType.I64:
2981 rajveer 13303 
          self.userId = iprot.readI64();
2642 varun.gupt 13304 
        else:
13305 
          iprot.skip(ftype)
13306 
      elif fid == 2:
13307 
        if ftype == TType.I64:
2981 rajveer 13308 
          self.itemId = iprot.readI64();
2642 varun.gupt 13309 
        else:
13310 
          iprot.skip(ftype)
13311 
      else:
13312 
        iprot.skip(ftype)
13313 
      iprot.readFieldEnd()
13314 
    iprot.readStructEnd()
13315 
 
13316 
  def write(self, oprot):
13317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13319 
      return
2981 rajveer 13320 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13321 
    if self.userId is not None:
2981 rajveer 13322 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13323 
      oprot.writeI64(self.userId)
2642 varun.gupt 13324 
      oprot.writeFieldEnd()
3431 rajveer 13325 
    if self.itemId is not None:
2981 rajveer 13326 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13327 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13328 
      oprot.writeFieldEnd()
13329 
    oprot.writeFieldStop()
13330 
    oprot.writeStructEnd()
13331 
 
3431 rajveer 13332 
  def validate(self):
13333 
    return
13334 
 
13335 
 
2642 varun.gupt 13336 
  def __repr__(self):
13337 
    L = ['%s=%r' % (key, value)
13338 
      for key, value in self.__dict__.iteritems()]
13339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13340 
 
13341 
  def __eq__(self, other):
13342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13343 
 
13344 
  def __ne__(self, other):
13345 
    return not (self == other)
13346 
 
2981 rajveer 13347 
class updateBrowseHistory_result:
2642 varun.gupt 13348 
 
13349 
  thrift_spec = (
13350 
  )
13351 
 
13352 
  def read(self, iprot):
13353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13355 
      return
13356 
    iprot.readStructBegin()
13357 
    while True:
13358 
      (fname, ftype, fid) = iprot.readFieldBegin()
13359 
      if ftype == TType.STOP:
13360 
        break
13361 
      else:
13362 
        iprot.skip(ftype)
13363 
      iprot.readFieldEnd()
13364 
    iprot.readStructEnd()
13365 
 
13366 
  def write(self, oprot):
13367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13369 
      return
2981 rajveer 13370 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13371 
    oprot.writeFieldStop()
13372 
    oprot.writeStructEnd()
13373 
 
3431 rajveer 13374 
  def validate(self):
13375 
    return
13376 
 
13377 
 
2642 varun.gupt 13378 
  def __repr__(self):
13379 
    L = ['%s=%r' % (key, value)
13380 
      for key, value in self.__dict__.iteritems()]
13381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13382 
 
13383 
  def __eq__(self, other):
13384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13385 
 
13386 
  def __ne__(self, other):
13387 
    return not (self == other)
13388 
 
3385 varun.gupt 13389 
class getCartsWithCouponCount_args:
13390 
  """
13391 
  Attributes:
13392 
   - couponCode
13393 
  """
2642 varun.gupt 13394 
 
3385 varun.gupt 13395 
  thrift_spec = (
13396 
    None, # 0
13397 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13398 
  )
13399 
 
13400 
  def __init__(self, couponCode=None,):
13401 
    self.couponCode = couponCode
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 == 1:
13413 
        if ftype == TType.STRING:
13414 
          self.couponCode = iprot.readString();
13415 
        else:
13416 
          iprot.skip(ftype)
13417 
      else:
13418 
        iprot.skip(ftype)
13419 
      iprot.readFieldEnd()
13420 
    iprot.readStructEnd()
13421 
 
13422 
  def write(self, oprot):
13423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13425 
      return
13426 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13427 
    if self.couponCode is not None:
3385 varun.gupt 13428 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13429 
      oprot.writeString(self.couponCode)
13430 
      oprot.writeFieldEnd()
13431 
    oprot.writeFieldStop()
13432 
    oprot.writeStructEnd()
13433 
 
3431 rajveer 13434 
  def validate(self):
13435 
    return
13436 
 
13437 
 
3385 varun.gupt 13438 
  def __repr__(self):
13439 
    L = ['%s=%r' % (key, value)
13440 
      for key, value in self.__dict__.iteritems()]
13441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13442 
 
13443 
  def __eq__(self, other):
13444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13445 
 
13446 
  def __ne__(self, other):
13447 
    return not (self == other)
13448 
 
13449 
class getCartsWithCouponCount_result:
13450 
  """
13451 
  Attributes:
13452 
   - success
13453 
  """
13454 
 
13455 
  thrift_spec = (
13456 
    (0, TType.I64, 'success', None, None, ), # 0
13457 
  )
13458 
 
13459 
  def __init__(self, success=None,):
13460 
    self.success = success
13461 
 
13462 
  def read(self, iprot):
13463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13465 
      return
13466 
    iprot.readStructBegin()
13467 
    while True:
13468 
      (fname, ftype, fid) = iprot.readFieldBegin()
13469 
      if ftype == TType.STOP:
13470 
        break
13471 
      if fid == 0:
13472 
        if ftype == TType.I64:
13473 
          self.success = iprot.readI64();
13474 
        else:
13475 
          iprot.skip(ftype)
13476 
      else:
13477 
        iprot.skip(ftype)
13478 
      iprot.readFieldEnd()
13479 
    iprot.readStructEnd()
13480 
 
13481 
  def write(self, oprot):
13482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13484 
      return
13485 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13486 
    if self.success is not None:
3385 varun.gupt 13487 
      oprot.writeFieldBegin('success', TType.I64, 0)
13488 
      oprot.writeI64(self.success)
13489 
      oprot.writeFieldEnd()
13490 
    oprot.writeFieldStop()
13491 
    oprot.writeStructEnd()
13492 
 
3431 rajveer 13493 
  def validate(self):
13494 
    return
13495 
 
13496 
 
3385 varun.gupt 13497 
  def __repr__(self):
13498 
    L = ['%s=%r' % (key, value)
13499 
      for key, value in self.__dict__.iteritems()]
13500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13501 
 
13502 
  def __eq__(self, other):
13503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13504 
 
13505 
  def __ne__(self, other):
13506 
    return not (self == other)
3499 mandeep.dh 13507 
 
13508 
class increaseTrustLevel_args:
13509 
  """
13510 
  Attributes:
13511 
   - userId
13512 
   - trustLevelDelta
13513 
  """
13514 
 
13515 
  thrift_spec = (
13516 
    None, # 0
13517 
    (1, TType.I64, 'userId', None, None, ), # 1
13518 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13519 
  )
13520 
 
13521 
  def __init__(self, userId=None, trustLevelDelta=None,):
13522 
    self.userId = userId
13523 
    self.trustLevelDelta = trustLevelDelta
13524 
 
13525 
  def read(self, iprot):
13526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13528 
      return
13529 
    iprot.readStructBegin()
13530 
    while True:
13531 
      (fname, ftype, fid) = iprot.readFieldBegin()
13532 
      if ftype == TType.STOP:
13533 
        break
13534 
      if fid == 1:
13535 
        if ftype == TType.I64:
13536 
          self.userId = iprot.readI64();
13537 
        else:
13538 
          iprot.skip(ftype)
13539 
      elif fid == 2:
13540 
        if ftype == TType.DOUBLE:
13541 
          self.trustLevelDelta = iprot.readDouble();
13542 
        else:
13543 
          iprot.skip(ftype)
13544 
      else:
13545 
        iprot.skip(ftype)
13546 
      iprot.readFieldEnd()
13547 
    iprot.readStructEnd()
13548 
 
13549 
  def write(self, oprot):
13550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13552 
      return
13553 
    oprot.writeStructBegin('increaseTrustLevel_args')
13554 
    if self.userId is not None:
13555 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13556 
      oprot.writeI64(self.userId)
13557 
      oprot.writeFieldEnd()
13558 
    if self.trustLevelDelta is not None:
13559 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13560 
      oprot.writeDouble(self.trustLevelDelta)
13561 
      oprot.writeFieldEnd()
13562 
    oprot.writeFieldStop()
13563 
    oprot.writeStructEnd()
13564 
 
13565 
  def validate(self):
13566 
    return
13567 
 
13568 
 
13569 
  def __repr__(self):
13570 
    L = ['%s=%r' % (key, value)
13571 
      for key, value in self.__dict__.iteritems()]
13572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13573 
 
13574 
  def __eq__(self, other):
13575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13576 
 
13577 
  def __ne__(self, other):
13578 
    return not (self == other)
4668 varun.gupt 13579 
 
5407 amar.kumar 13580 
class getTrustLevel_args:
13581 
  """
13582 
  Attributes:
13583 
   - userId
13584 
  """
13585 
 
13586 
  thrift_spec = (
13587 
    None, # 0
13588 
    (1, TType.I64, 'userId', None, None, ), # 1
13589 
  )
13590 
 
13591 
  def __init__(self, userId=None,):
13592 
    self.userId = userId
13593 
 
13594 
  def read(self, iprot):
13595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13597 
      return
13598 
    iprot.readStructBegin()
13599 
    while True:
13600 
      (fname, ftype, fid) = iprot.readFieldBegin()
13601 
      if ftype == TType.STOP:
13602 
        break
13603 
      if fid == 1:
13604 
        if ftype == TType.I64:
13605 
          self.userId = iprot.readI64();
13606 
        else:
13607 
          iprot.skip(ftype)
13608 
      else:
13609 
        iprot.skip(ftype)
13610 
      iprot.readFieldEnd()
13611 
    iprot.readStructEnd()
13612 
 
13613 
  def write(self, oprot):
13614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13616 
      return
13617 
    oprot.writeStructBegin('getTrustLevel_args')
13618 
    if self.userId is not None:
13619 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13620 
      oprot.writeI64(self.userId)
13621 
      oprot.writeFieldEnd()
13622 
    oprot.writeFieldStop()
13623 
    oprot.writeStructEnd()
13624 
 
13625 
  def validate(self):
13626 
    return
13627 
 
13628 
 
13629 
  def __repr__(self):
13630 
    L = ['%s=%r' % (key, value)
13631 
      for key, value in self.__dict__.iteritems()]
13632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13633 
 
13634 
  def __eq__(self, other):
13635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13636 
 
13637 
  def __ne__(self, other):
13638 
    return not (self == other)
13639 
 
13640 
class getTrustLevel_result:
13641 
  """
13642 
  Attributes:
13643 
   - success
13644 
  """
13645 
 
13646 
  thrift_spec = (
13647 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13648 
  )
13649 
 
13650 
  def __init__(self, success=None,):
13651 
    self.success = success
13652 
 
13653 
  def read(self, iprot):
13654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13656 
      return
13657 
    iprot.readStructBegin()
13658 
    while True:
13659 
      (fname, ftype, fid) = iprot.readFieldBegin()
13660 
      if ftype == TType.STOP:
13661 
        break
13662 
      if fid == 0:
13663 
        if ftype == TType.DOUBLE:
13664 
          self.success = iprot.readDouble();
13665 
        else:
13666 
          iprot.skip(ftype)
13667 
      else:
13668 
        iprot.skip(ftype)
13669 
      iprot.readFieldEnd()
13670 
    iprot.readStructEnd()
13671 
 
13672 
  def write(self, oprot):
13673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13675 
      return
13676 
    oprot.writeStructBegin('getTrustLevel_result')
13677 
    if self.success is not None:
13678 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13679 
      oprot.writeDouble(self.success)
13680 
      oprot.writeFieldEnd()
13681 
    oprot.writeFieldStop()
13682 
    oprot.writeStructEnd()
13683 
 
13684 
  def validate(self):
13685 
    return
13686 
 
13687 
 
13688 
  def __repr__(self):
13689 
    L = ['%s=%r' % (key, value)
13690 
      for key, value in self.__dict__.iteritems()]
13691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13692 
 
13693 
  def __eq__(self, other):
13694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13695 
 
13696 
  def __ne__(self, other):
13697 
    return not (self == other)
13698 
 
4668 varun.gupt 13699 
class showCODOption_args:
13700 
  """
13701 
  Attributes:
13702 
   - cartId
13703 
   - sourceId
13704 
   - pincode
13705 
  """
13706 
 
13707 
  thrift_spec = (
13708 
    None, # 0
13709 
    (1, TType.I64, 'cartId', None, None, ), # 1
13710 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13711 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13712 
  )
13713 
 
13714 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13715 
    self.cartId = cartId
13716 
    self.sourceId = sourceId
13717 
    self.pincode = pincode
13718 
 
13719 
  def read(self, iprot):
13720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13722 
      return
13723 
    iprot.readStructBegin()
13724 
    while True:
13725 
      (fname, ftype, fid) = iprot.readFieldBegin()
13726 
      if ftype == TType.STOP:
13727 
        break
13728 
      if fid == 1:
13729 
        if ftype == TType.I64:
13730 
          self.cartId = iprot.readI64();
13731 
        else:
13732 
          iprot.skip(ftype)
13733 
      elif fid == 2:
13734 
        if ftype == TType.I64:
13735 
          self.sourceId = iprot.readI64();
13736 
        else:
13737 
          iprot.skip(ftype)
13738 
      elif fid == 3:
13739 
        if ftype == TType.STRING:
13740 
          self.pincode = iprot.readString();
13741 
        else:
13742 
          iprot.skip(ftype)
13743 
      else:
13744 
        iprot.skip(ftype)
13745 
      iprot.readFieldEnd()
13746 
    iprot.readStructEnd()
13747 
 
13748 
  def write(self, oprot):
13749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13751 
      return
13752 
    oprot.writeStructBegin('showCODOption_args')
13753 
    if self.cartId is not None:
13754 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13755 
      oprot.writeI64(self.cartId)
13756 
      oprot.writeFieldEnd()
13757 
    if self.sourceId is not None:
13758 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13759 
      oprot.writeI64(self.sourceId)
13760 
      oprot.writeFieldEnd()
13761 
    if self.pincode is not None:
13762 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
13763 
      oprot.writeString(self.pincode)
13764 
      oprot.writeFieldEnd()
13765 
    oprot.writeFieldStop()
13766 
    oprot.writeStructEnd()
13767 
 
13768 
  def validate(self):
13769 
    return
13770 
 
13771 
 
13772 
  def __repr__(self):
13773 
    L = ['%s=%r' % (key, value)
13774 
      for key, value in self.__dict__.iteritems()]
13775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13776 
 
13777 
  def __eq__(self, other):
13778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13779 
 
13780 
  def __ne__(self, other):
13781 
    return not (self == other)
13782 
 
13783 
class showCODOption_result:
13784 
  """
13785 
  Attributes:
13786 
   - success
13787 
  """
13788 
 
13789 
  thrift_spec = (
13790 
    (0, TType.BOOL, 'success', None, None, ), # 0
13791 
  )
13792 
 
13793 
  def __init__(self, success=None,):
13794 
    self.success = success
13795 
 
13796 
  def read(self, iprot):
13797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13799 
      return
13800 
    iprot.readStructBegin()
13801 
    while True:
13802 
      (fname, ftype, fid) = iprot.readFieldBegin()
13803 
      if ftype == TType.STOP:
13804 
        break
13805 
      if fid == 0:
13806 
        if ftype == TType.BOOL:
13807 
          self.success = iprot.readBool();
13808 
        else:
13809 
          iprot.skip(ftype)
13810 
      else:
13811 
        iprot.skip(ftype)
13812 
      iprot.readFieldEnd()
13813 
    iprot.readStructEnd()
13814 
 
13815 
  def write(self, oprot):
13816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13818 
      return
13819 
    oprot.writeStructBegin('showCODOption_result')
13820 
    if self.success is not None:
13821 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13822 
      oprot.writeBool(self.success)
13823 
      oprot.writeFieldEnd()
13824 
    oprot.writeFieldStop()
13825 
    oprot.writeStructEnd()
13826 
 
13827 
  def validate(self):
13828 
    return
13829 
 
13830 
 
13831 
  def __repr__(self):
13832 
    L = ['%s=%r' % (key, value)
13833 
      for key, value in self.__dict__.iteritems()]
13834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13835 
 
13836 
  def __eq__(self, other):
13837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13838 
 
13839 
  def __ne__(self, other):
13840 
    return not (self == other)
5623 anupam.sin 13841 
 
13842 
class getUserEmails_args:
13843 
  """
13844 
  Attributes:
13845 
   - startDate
13846 
   - endDate
13847 
  """
13848 
 
13849 
  thrift_spec = (
13850 
    None, # 0
13851 
    (1, TType.I64, 'startDate', None, None, ), # 1
13852 
    (2, TType.I64, 'endDate', None, None, ), # 2
13853 
  )
13854 
 
13855 
  def __init__(self, startDate=None, endDate=None,):
13856 
    self.startDate = startDate
13857 
    self.endDate = endDate
13858 
 
13859 
  def read(self, iprot):
13860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13862 
      return
13863 
    iprot.readStructBegin()
13864 
    while True:
13865 
      (fname, ftype, fid) = iprot.readFieldBegin()
13866 
      if ftype == TType.STOP:
13867 
        break
13868 
      if fid == 1:
13869 
        if ftype == TType.I64:
13870 
          self.startDate = iprot.readI64();
13871 
        else:
13872 
          iprot.skip(ftype)
13873 
      elif fid == 2:
13874 
        if ftype == TType.I64:
13875 
          self.endDate = iprot.readI64();
13876 
        else:
13877 
          iprot.skip(ftype)
13878 
      else:
13879 
        iprot.skip(ftype)
13880 
      iprot.readFieldEnd()
13881 
    iprot.readStructEnd()
13882 
 
13883 
  def write(self, oprot):
13884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13886 
      return
13887 
    oprot.writeStructBegin('getUserEmails_args')
13888 
    if self.startDate is not None:
13889 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
13890 
      oprot.writeI64(self.startDate)
13891 
      oprot.writeFieldEnd()
13892 
    if self.endDate is not None:
13893 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
13894 
      oprot.writeI64(self.endDate)
13895 
      oprot.writeFieldEnd()
13896 
    oprot.writeFieldStop()
13897 
    oprot.writeStructEnd()
13898 
 
13899 
  def validate(self):
13900 
    return
13901 
 
13902 
 
13903 
  def __repr__(self):
13904 
    L = ['%s=%r' % (key, value)
13905 
      for key, value in self.__dict__.iteritems()]
13906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13907 
 
13908 
  def __eq__(self, other):
13909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13910 
 
13911 
  def __ne__(self, other):
13912 
    return not (self == other)
13913 
 
13914 
class getUserEmails_result:
13915 
  """
13916 
  Attributes:
13917 
   - success
13918 
  """
13919 
 
13920 
  thrift_spec = (
13921 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13922 
  )
13923 
 
13924 
  def __init__(self, success=None,):
13925 
    self.success = success
13926 
 
13927 
  def read(self, iprot):
13928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13930 
      return
13931 
    iprot.readStructBegin()
13932 
    while True:
13933 
      (fname, ftype, fid) = iprot.readFieldBegin()
13934 
      if ftype == TType.STOP:
13935 
        break
13936 
      if fid == 0:
13937 
        if ftype == TType.LIST:
13938 
          self.success = []
11980 amit.gupta 13939 
          (_etype214, _size211) = iprot.readListBegin()
13940 
          for _i215 in xrange(_size211):
13941 
            _elem216 = iprot.readString();
13942 
            self.success.append(_elem216)
5623 anupam.sin 13943 
          iprot.readListEnd()
13944 
        else:
13945 
          iprot.skip(ftype)
13946 
      else:
13947 
        iprot.skip(ftype)
13948 
      iprot.readFieldEnd()
13949 
    iprot.readStructEnd()
13950 
 
13951 
  def write(self, oprot):
13952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13954 
      return
13955 
    oprot.writeStructBegin('getUserEmails_result')
13956 
    if self.success is not None:
13957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13958 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 13959 
      for iter217 in self.success:
13960 
        oprot.writeString(iter217)
5623 anupam.sin 13961 
      oprot.writeListEnd()
13962 
      oprot.writeFieldEnd()
13963 
    oprot.writeFieldStop()
13964 
    oprot.writeStructEnd()
13965 
 
13966 
  def validate(self):
13967 
    return
13968 
 
13969 
 
13970 
  def __repr__(self):
13971 
    L = ['%s=%r' % (key, value)
13972 
      for key, value in self.__dict__.iteritems()]
13973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13974 
 
13975 
  def __eq__(self, other):
13976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13977 
 
13978 
  def __ne__(self, other):
13979 
    return not (self == other)
6821 amar.kumar 13980 
 
6903 anupam.sin 13981 
class insureItem_args:
13982 
  """
13983 
  Attributes:
13984 
   - itemId
13985 
   - cartId
13986 
   - toInsure
9299 kshitij.so 13987 
   - insurerType
6903 anupam.sin 13988 
  """
13989 
 
13990 
  thrift_spec = (
13991 
    None, # 0
13992 
    (1, TType.I64, 'itemId', None, None, ), # 1
13993 
    (2, TType.I64, 'cartId', None, None, ), # 2
13994 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 13995 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 13996 
  )
13997 
 
9299 kshitij.so 13998 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 13999 
    self.itemId = itemId
14000 
    self.cartId = cartId
14001 
    self.toInsure = toInsure
9299 kshitij.so 14002 
    self.insurerType = insurerType
6903 anupam.sin 14003 
 
14004 
  def read(self, iprot):
14005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14007 
      return
14008 
    iprot.readStructBegin()
14009 
    while True:
14010 
      (fname, ftype, fid) = iprot.readFieldBegin()
14011 
      if ftype == TType.STOP:
14012 
        break
14013 
      if fid == 1:
14014 
        if ftype == TType.I64:
14015 
          self.itemId = iprot.readI64();
14016 
        else:
14017 
          iprot.skip(ftype)
14018 
      elif fid == 2:
14019 
        if ftype == TType.I64:
14020 
          self.cartId = iprot.readI64();
14021 
        else:
14022 
          iprot.skip(ftype)
14023 
      elif fid == 3:
14024 
        if ftype == TType.BOOL:
14025 
          self.toInsure = iprot.readBool();
14026 
        else:
14027 
          iprot.skip(ftype)
9299 kshitij.so 14028 
      elif fid == 4:
14029 
        if ftype == TType.I32:
14030 
          self.insurerType = iprot.readI32();
14031 
        else:
14032 
          iprot.skip(ftype)
6903 anupam.sin 14033 
      else:
14034 
        iprot.skip(ftype)
14035 
      iprot.readFieldEnd()
14036 
    iprot.readStructEnd()
14037 
 
14038 
  def write(self, oprot):
14039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14041 
      return
14042 
    oprot.writeStructBegin('insureItem_args')
14043 
    if self.itemId is not None:
14044 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14045 
      oprot.writeI64(self.itemId)
14046 
      oprot.writeFieldEnd()
14047 
    if self.cartId is not None:
14048 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14049 
      oprot.writeI64(self.cartId)
14050 
      oprot.writeFieldEnd()
14051 
    if self.toInsure is not None:
14052 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14053 
      oprot.writeBool(self.toInsure)
14054 
      oprot.writeFieldEnd()
9299 kshitij.so 14055 
    if self.insurerType is not None:
14056 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14057 
      oprot.writeI32(self.insurerType)
14058 
      oprot.writeFieldEnd()
6903 anupam.sin 14059 
    oprot.writeFieldStop()
14060 
    oprot.writeStructEnd()
14061 
 
14062 
  def validate(self):
14063 
    return
14064 
 
14065 
 
14066 
  def __repr__(self):
14067 
    L = ['%s=%r' % (key, value)
14068 
      for key, value in self.__dict__.iteritems()]
14069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14070 
 
14071 
  def __eq__(self, other):
14072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14073 
 
14074 
  def __ne__(self, other):
14075 
    return not (self == other)
14076 
 
14077 
class insureItem_result:
14078 
  """
14079 
  Attributes:
14080 
   - success
14081 
  """
14082 
 
14083 
  thrift_spec = (
14084 
    (0, TType.BOOL, 'success', None, None, ), # 0
14085 
  )
14086 
 
14087 
  def __init__(self, success=None,):
14088 
    self.success = success
14089 
 
14090 
  def read(self, iprot):
14091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14093 
      return
14094 
    iprot.readStructBegin()
14095 
    while True:
14096 
      (fname, ftype, fid) = iprot.readFieldBegin()
14097 
      if ftype == TType.STOP:
14098 
        break
14099 
      if fid == 0:
14100 
        if ftype == TType.BOOL:
14101 
          self.success = iprot.readBool();
14102 
        else:
14103 
          iprot.skip(ftype)
14104 
      else:
14105 
        iprot.skip(ftype)
14106 
      iprot.readFieldEnd()
14107 
    iprot.readStructEnd()
14108 
 
14109 
  def write(self, oprot):
14110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14112 
      return
14113 
    oprot.writeStructBegin('insureItem_result')
14114 
    if self.success is not None:
14115 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14116 
      oprot.writeBool(self.success)
14117 
      oprot.writeFieldEnd()
14118 
    oprot.writeFieldStop()
14119 
    oprot.writeStructEnd()
14120 
 
14121 
  def validate(self):
14122 
    return
14123 
 
14124 
 
14125 
  def __repr__(self):
14126 
    L = ['%s=%r' % (key, value)
14127 
      for key, value in self.__dict__.iteritems()]
14128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14129 
 
14130 
  def __eq__(self, other):
14131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14132 
 
14133 
  def __ne__(self, other):
14134 
    return not (self == other)
14135 
 
14136 
class cancelInsurance_args:
14137 
  """
14138 
  Attributes:
14139 
   - cartId
14140 
  """
14141 
 
14142 
  thrift_spec = (
14143 
    None, # 0
14144 
    (1, TType.I64, 'cartId', None, None, ), # 1
14145 
  )
14146 
 
14147 
  def __init__(self, cartId=None,):
14148 
    self.cartId = cartId
14149 
 
14150 
  def read(self, iprot):
14151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14153 
      return
14154 
    iprot.readStructBegin()
14155 
    while True:
14156 
      (fname, ftype, fid) = iprot.readFieldBegin()
14157 
      if ftype == TType.STOP:
14158 
        break
14159 
      if fid == 1:
14160 
        if ftype == TType.I64:
14161 
          self.cartId = iprot.readI64();
14162 
        else:
14163 
          iprot.skip(ftype)
14164 
      else:
14165 
        iprot.skip(ftype)
14166 
      iprot.readFieldEnd()
14167 
    iprot.readStructEnd()
14168 
 
14169 
  def write(self, oprot):
14170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14172 
      return
14173 
    oprot.writeStructBegin('cancelInsurance_args')
14174 
    if self.cartId is not None:
14175 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14176 
      oprot.writeI64(self.cartId)
14177 
      oprot.writeFieldEnd()
14178 
    oprot.writeFieldStop()
14179 
    oprot.writeStructEnd()
14180 
 
14181 
  def validate(self):
14182 
    return
14183 
 
14184 
 
14185 
  def __repr__(self):
14186 
    L = ['%s=%r' % (key, value)
14187 
      for key, value in self.__dict__.iteritems()]
14188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14189 
 
14190 
  def __eq__(self, other):
14191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14192 
 
14193 
  def __ne__(self, other):
14194 
    return not (self == other)
14195 
 
14196 
class cancelInsurance_result:
14197 
  """
14198 
  Attributes:
14199 
   - success
14200 
  """
14201 
 
14202 
  thrift_spec = (
14203 
    (0, TType.BOOL, 'success', None, None, ), # 0
14204 
  )
14205 
 
14206 
  def __init__(self, success=None,):
14207 
    self.success = success
14208 
 
14209 
  def read(self, iprot):
14210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14212 
      return
14213 
    iprot.readStructBegin()
14214 
    while True:
14215 
      (fname, ftype, fid) = iprot.readFieldBegin()
14216 
      if ftype == TType.STOP:
14217 
        break
14218 
      if fid == 0:
14219 
        if ftype == TType.BOOL:
14220 
          self.success = iprot.readBool();
14221 
        else:
14222 
          iprot.skip(ftype)
14223 
      else:
14224 
        iprot.skip(ftype)
14225 
      iprot.readFieldEnd()
14226 
    iprot.readStructEnd()
14227 
 
14228 
  def write(self, oprot):
14229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14231 
      return
14232 
    oprot.writeStructBegin('cancelInsurance_result')
14233 
    if self.success is not None:
14234 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14235 
      oprot.writeBool(self.success)
14236 
      oprot.writeFieldEnd()
14237 
    oprot.writeFieldStop()
14238 
    oprot.writeStructEnd()
14239 
 
14240 
  def validate(self):
14241 
    return
14242 
 
14243 
 
14244 
  def __repr__(self):
14245 
    L = ['%s=%r' % (key, value)
14246 
      for key, value in self.__dict__.iteritems()]
14247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14248 
 
14249 
  def __eq__(self, other):
14250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14251 
 
14252 
  def __ne__(self, other):
14253 
    return not (self == other)
14254 
 
14255 
class storeInsuranceSpecificDetails_args:
14256 
  """
14257 
  Attributes:
14258 
   - addressId
14259 
   - dob
14260 
   - guardianName
14261 
  """
14262 
 
14263 
  thrift_spec = (
14264 
    None, # 0
14265 
    (1, TType.I64, 'addressId', None, None, ), # 1
14266 
    (2, TType.STRING, 'dob', None, None, ), # 2
14267 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14268 
  )
14269 
 
14270 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14271 
    self.addressId = addressId
14272 
    self.dob = dob
14273 
    self.guardianName = guardianName
14274 
 
14275 
  def read(self, iprot):
14276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14278 
      return
14279 
    iprot.readStructBegin()
14280 
    while True:
14281 
      (fname, ftype, fid) = iprot.readFieldBegin()
14282 
      if ftype == TType.STOP:
14283 
        break
14284 
      if fid == 1:
14285 
        if ftype == TType.I64:
14286 
          self.addressId = iprot.readI64();
14287 
        else:
14288 
          iprot.skip(ftype)
14289 
      elif fid == 2:
14290 
        if ftype == TType.STRING:
14291 
          self.dob = iprot.readString();
14292 
        else:
14293 
          iprot.skip(ftype)
14294 
      elif fid == 3:
14295 
        if ftype == TType.STRING:
14296 
          self.guardianName = iprot.readString();
14297 
        else:
14298 
          iprot.skip(ftype)
14299 
      else:
14300 
        iprot.skip(ftype)
14301 
      iprot.readFieldEnd()
14302 
    iprot.readStructEnd()
14303 
 
14304 
  def write(self, oprot):
14305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14307 
      return
14308 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14309 
    if self.addressId is not None:
14310 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14311 
      oprot.writeI64(self.addressId)
14312 
      oprot.writeFieldEnd()
14313 
    if self.dob is not None:
14314 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14315 
      oprot.writeString(self.dob)
14316 
      oprot.writeFieldEnd()
14317 
    if self.guardianName is not None:
14318 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14319 
      oprot.writeString(self.guardianName)
14320 
      oprot.writeFieldEnd()
14321 
    oprot.writeFieldStop()
14322 
    oprot.writeStructEnd()
14323 
 
14324 
  def validate(self):
14325 
    return
14326 
 
14327 
 
14328 
  def __repr__(self):
14329 
    L = ['%s=%r' % (key, value)
14330 
      for key, value in self.__dict__.iteritems()]
14331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14332 
 
14333 
  def __eq__(self, other):
14334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14335 
 
14336 
  def __ne__(self, other):
14337 
    return not (self == other)
14338 
 
14339 
class storeInsuranceSpecificDetails_result:
14340 
  """
14341 
  Attributes:
14342 
   - success
14343 
  """
14344 
 
14345 
  thrift_spec = (
14346 
    (0, TType.BOOL, 'success', None, None, ), # 0
14347 
  )
14348 
 
14349 
  def __init__(self, success=None,):
14350 
    self.success = success
14351 
 
14352 
  def read(self, iprot):
14353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14355 
      return
14356 
    iprot.readStructBegin()
14357 
    while True:
14358 
      (fname, ftype, fid) = iprot.readFieldBegin()
14359 
      if ftype == TType.STOP:
14360 
        break
14361 
      if fid == 0:
14362 
        if ftype == TType.BOOL:
14363 
          self.success = iprot.readBool();
14364 
        else:
14365 
          iprot.skip(ftype)
14366 
      else:
14367 
        iprot.skip(ftype)
14368 
      iprot.readFieldEnd()
14369 
    iprot.readStructEnd()
14370 
 
14371 
  def write(self, oprot):
14372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14374 
      return
14375 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14376 
    if self.success is not None:
14377 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14378 
      oprot.writeBool(self.success)
14379 
      oprot.writeFieldEnd()
14380 
    oprot.writeFieldStop()
14381 
    oprot.writeStructEnd()
14382 
 
14383 
  def validate(self):
14384 
    return
14385 
 
14386 
 
14387 
  def __repr__(self):
14388 
    L = ['%s=%r' % (key, value)
14389 
      for key, value in self.__dict__.iteritems()]
14390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14391 
 
14392 
  def __eq__(self, other):
14393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14394 
 
14395 
  def __ne__(self, other):
14396 
    return not (self == other)
14397 
 
14398 
class isInsuranceDetailPresent_args:
14399 
  """
14400 
  Attributes:
14401 
   - addressId
14402 
  """
14403 
 
14404 
  thrift_spec = (
14405 
    None, # 0
14406 
    (1, TType.I64, 'addressId', None, None, ), # 1
14407 
  )
14408 
 
14409 
  def __init__(self, addressId=None,):
14410 
    self.addressId = addressId
14411 
 
14412 
  def read(self, iprot):
14413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14415 
      return
14416 
    iprot.readStructBegin()
14417 
    while True:
14418 
      (fname, ftype, fid) = iprot.readFieldBegin()
14419 
      if ftype == TType.STOP:
14420 
        break
14421 
      if fid == 1:
14422 
        if ftype == TType.I64:
14423 
          self.addressId = iprot.readI64();
14424 
        else:
14425 
          iprot.skip(ftype)
14426 
      else:
14427 
        iprot.skip(ftype)
14428 
      iprot.readFieldEnd()
14429 
    iprot.readStructEnd()
14430 
 
14431 
  def write(self, oprot):
14432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14434 
      return
14435 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14436 
    if self.addressId is not None:
14437 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14438 
      oprot.writeI64(self.addressId)
14439 
      oprot.writeFieldEnd()
14440 
    oprot.writeFieldStop()
14441 
    oprot.writeStructEnd()
14442 
 
14443 
  def validate(self):
14444 
    return
14445 
 
14446 
 
14447 
  def __repr__(self):
14448 
    L = ['%s=%r' % (key, value)
14449 
      for key, value in self.__dict__.iteritems()]
14450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14451 
 
14452 
  def __eq__(self, other):
14453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14454 
 
14455 
  def __ne__(self, other):
14456 
    return not (self == other)
14457 
 
14458 
class isInsuranceDetailPresent_result:
14459 
  """
14460 
  Attributes:
14461 
   - success
14462 
  """
14463 
 
14464 
  thrift_spec = (
14465 
    (0, TType.BOOL, 'success', None, None, ), # 0
14466 
  )
14467 
 
14468 
  def __init__(self, success=None,):
14469 
    self.success = success
14470 
 
14471 
  def read(self, iprot):
14472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14474 
      return
14475 
    iprot.readStructBegin()
14476 
    while True:
14477 
      (fname, ftype, fid) = iprot.readFieldBegin()
14478 
      if ftype == TType.STOP:
14479 
        break
14480 
      if fid == 0:
14481 
        if ftype == TType.BOOL:
14482 
          self.success = iprot.readBool();
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      else:
14486 
        iprot.skip(ftype)
14487 
      iprot.readFieldEnd()
14488 
    iprot.readStructEnd()
14489 
 
14490 
  def write(self, oprot):
14491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14493 
      return
14494 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14495 
    if self.success is not None:
14496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14497 
      oprot.writeBool(self.success)
14498 
      oprot.writeFieldEnd()
14499 
    oprot.writeFieldStop()
14500 
    oprot.writeStructEnd()
14501 
 
14502 
  def validate(self):
14503 
    return
14504 
 
14505 
 
14506 
  def __repr__(self):
14507 
    L = ['%s=%r' % (key, value)
14508 
      for key, value in self.__dict__.iteritems()]
14509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14510 
 
14511 
  def __eq__(self, other):
14512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14513 
 
14514 
  def __ne__(self, other):
14515 
    return not (self == other)
14516 
 
9791 rajveer 14517 
class getProductsAddedToCart_args:
6821 amar.kumar 14518 
  """
14519 
  Attributes:
14520 
   - startDate
14521 
   - endDate
14522 
  """
14523 
 
14524 
  thrift_spec = (
14525 
    None, # 0
9791 rajveer 14526 
    (1, TType.I64, 'startDate', None, None, ), # 1
14527 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14528 
  )
14529 
 
9791 rajveer 14530 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14531 
    self.startDate = startDate
14532 
    self.endDate = endDate
14533 
 
14534 
  def read(self, iprot):
14535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14537 
      return
14538 
    iprot.readStructBegin()
14539 
    while True:
14540 
      (fname, ftype, fid) = iprot.readFieldBegin()
14541 
      if ftype == TType.STOP:
14542 
        break
14543 
      if fid == 1:
14544 
        if ftype == TType.I64:
9791 rajveer 14545 
          self.startDate = iprot.readI64();
6821 amar.kumar 14546 
        else:
14547 
          iprot.skip(ftype)
14548 
      elif fid == 2:
14549 
        if ftype == TType.I64:
14550 
          self.endDate = iprot.readI64();
14551 
        else:
14552 
          iprot.skip(ftype)
14553 
      else:
14554 
        iprot.skip(ftype)
14555 
      iprot.readFieldEnd()
14556 
    iprot.readStructEnd()
14557 
 
14558 
  def write(self, oprot):
14559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14561 
      return
9791 rajveer 14562 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14563 
    if self.startDate is not None:
9791 rajveer 14564 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14565 
      oprot.writeI64(self.startDate)
14566 
      oprot.writeFieldEnd()
14567 
    if self.endDate is not None:
9791 rajveer 14568 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14569 
      oprot.writeI64(self.endDate)
14570 
      oprot.writeFieldEnd()
14571 
    oprot.writeFieldStop()
14572 
    oprot.writeStructEnd()
14573 
 
14574 
  def validate(self):
14575 
    return
14576 
 
14577 
 
14578 
  def __repr__(self):
14579 
    L = ['%s=%r' % (key, value)
14580 
      for key, value in self.__dict__.iteritems()]
14581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14582 
 
14583 
  def __eq__(self, other):
14584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14585 
 
14586 
  def __ne__(self, other):
14587 
    return not (self == other)
14588 
 
9791 rajveer 14589 
class getProductsAddedToCart_result:
6821 amar.kumar 14590 
  """
14591 
  Attributes:
14592 
   - success
14593 
  """
14594 
 
14595 
  thrift_spec = (
9791 rajveer 14596 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14597 
  )
14598 
 
14599 
  def __init__(self, success=None,):
14600 
    self.success = success
14601 
 
14602 
  def read(self, iprot):
14603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14605 
      return
14606 
    iprot.readStructBegin()
14607 
    while True:
14608 
      (fname, ftype, fid) = iprot.readFieldBegin()
14609 
      if ftype == TType.STOP:
14610 
        break
14611 
      if fid == 0:
9791 rajveer 14612 
        if ftype == TType.LIST:
14613 
          self.success = []
11980 amit.gupta 14614 
          (_etype221, _size218) = iprot.readListBegin()
14615 
          for _i222 in xrange(_size218):
14616 
            _elem223 = iprot.readI64();
14617 
            self.success.append(_elem223)
9791 rajveer 14618 
          iprot.readListEnd()
6821 amar.kumar 14619 
        else:
14620 
          iprot.skip(ftype)
14621 
      else:
14622 
        iprot.skip(ftype)
14623 
      iprot.readFieldEnd()
14624 
    iprot.readStructEnd()
14625 
 
14626 
  def write(self, oprot):
14627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14629 
      return
9791 rajveer 14630 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14631 
    if self.success is not None:
9791 rajveer 14632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14633 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14634 
      for iter224 in self.success:
14635 
        oprot.writeI64(iter224)
9791 rajveer 14636 
      oprot.writeListEnd()
6821 amar.kumar 14637 
      oprot.writeFieldEnd()
14638 
    oprot.writeFieldStop()
14639 
    oprot.writeStructEnd()
14640 
 
14641 
  def validate(self):
14642 
    return
14643 
 
14644 
 
14645 
  def __repr__(self):
14646 
    L = ['%s=%r' % (key, value)
14647 
      for key, value in self.__dict__.iteritems()]
14648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14649 
 
14650 
  def __eq__(self, other):
14651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14652 
 
14653 
  def __ne__(self, other):
14654 
    return not (self == other)
11592 amit.gupta 14655 
 
14656 
class validateCartPlus_args:
14657 
  """
14658 
  Attributes:
14659 
   - cartId
14660 
   - sourceId
11980 amit.gupta 14661 
   - dealerCoupon
11592 amit.gupta 14662 
  """
14663 
 
14664 
  thrift_spec = (
14665 
    None, # 0
14666 
    (1, TType.I64, 'cartId', None, None, ), # 1
14667 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 14668 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 14669 
  )
14670 
 
11980 amit.gupta 14671 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 14672 
    self.cartId = cartId
14673 
    self.sourceId = sourceId
11980 amit.gupta 14674 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 14675 
 
14676 
  def read(self, iprot):
14677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14679 
      return
14680 
    iprot.readStructBegin()
14681 
    while True:
14682 
      (fname, ftype, fid) = iprot.readFieldBegin()
14683 
      if ftype == TType.STOP:
14684 
        break
14685 
      if fid == 1:
14686 
        if ftype == TType.I64:
14687 
          self.cartId = iprot.readI64();
14688 
        else:
14689 
          iprot.skip(ftype)
14690 
      elif fid == 2:
14691 
        if ftype == TType.I64:
14692 
          self.sourceId = iprot.readI64();
14693 
        else:
14694 
          iprot.skip(ftype)
11980 amit.gupta 14695 
      elif fid == 3:
14696 
        if ftype == TType.STRING:
14697 
          self.dealerCoupon = iprot.readString();
14698 
        else:
14699 
          iprot.skip(ftype)
11592 amit.gupta 14700 
      else:
14701 
        iprot.skip(ftype)
14702 
      iprot.readFieldEnd()
14703 
    iprot.readStructEnd()
14704 
 
14705 
  def write(self, oprot):
14706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14708 
      return
14709 
    oprot.writeStructBegin('validateCartPlus_args')
14710 
    if self.cartId is not None:
14711 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14712 
      oprot.writeI64(self.cartId)
14713 
      oprot.writeFieldEnd()
14714 
    if self.sourceId is not None:
14715 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14716 
      oprot.writeI64(self.sourceId)
14717 
      oprot.writeFieldEnd()
11980 amit.gupta 14718 
    if self.dealerCoupon is not None:
14719 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
14720 
      oprot.writeString(self.dealerCoupon)
14721 
      oprot.writeFieldEnd()
11592 amit.gupta 14722 
    oprot.writeFieldStop()
14723 
    oprot.writeStructEnd()
14724 
 
14725 
  def validate(self):
14726 
    return
14727 
 
14728 
 
14729 
  def __repr__(self):
14730 
    L = ['%s=%r' % (key, value)
14731 
      for key, value in self.__dict__.iteritems()]
14732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14733 
 
14734 
  def __eq__(self, other):
14735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14736 
 
14737 
  def __ne__(self, other):
14738 
    return not (self == other)
14739 
 
14740 
class validateCartPlus_result:
14741 
  """
14742 
  Attributes:
14743 
   - success
14744 
   - scex
14745 
  """
14746 
 
14747 
  thrift_spec = (
14748 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
14749 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
14750 
  )
14751 
 
14752 
  def __init__(self, success=None, scex=None,):
14753 
    self.success = success
14754 
    self.scex = scex
14755 
 
14756 
  def read(self, iprot):
14757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14759 
      return
14760 
    iprot.readStructBegin()
14761 
    while True:
14762 
      (fname, ftype, fid) = iprot.readFieldBegin()
14763 
      if ftype == TType.STOP:
14764 
        break
14765 
      if fid == 0:
14766 
        if ftype == TType.STRUCT:
14767 
          self.success = CartPlus()
14768 
          self.success.read(iprot)
14769 
        else:
14770 
          iprot.skip(ftype)
14771 
      elif fid == 1:
14772 
        if ftype == TType.STRUCT:
14773 
          self.scex = ShoppingCartException()
14774 
          self.scex.read(iprot)
14775 
        else:
14776 
          iprot.skip(ftype)
14777 
      else:
14778 
        iprot.skip(ftype)
14779 
      iprot.readFieldEnd()
14780 
    iprot.readStructEnd()
14781 
 
14782 
  def write(self, oprot):
14783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14785 
      return
14786 
    oprot.writeStructBegin('validateCartPlus_result')
14787 
    if self.success is not None:
14788 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14789 
      self.success.write(oprot)
14790 
      oprot.writeFieldEnd()
14791 
    if self.scex is not None:
14792 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
14793 
      self.scex.write(oprot)
14794 
      oprot.writeFieldEnd()
14795 
    oprot.writeFieldStop()
14796 
    oprot.writeStructEnd()
14797 
 
14798 
  def validate(self):
14799 
    return
14800 
 
14801 
 
14802 
  def __repr__(self):
14803 
    L = ['%s=%r' % (key, value)
14804 
      for key, value in self.__dict__.iteritems()]
14805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14806 
 
14807 
  def __eq__(self, other):
14808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14809 
 
14810 
  def __ne__(self, other):
14811 
    return not (self == other)
11679 vikram.rag 14812 
 
14813 
class isPrivateDealUser_args:
14814 
  """
14815 
  Attributes:
14816 
   - userId
14817 
  """
14818 
 
14819 
  thrift_spec = (
14820 
    None, # 0
14821 
    (1, TType.I64, 'userId', None, None, ), # 1
14822 
  )
14823 
 
14824 
  def __init__(self, userId=None,):
14825 
    self.userId = userId
14826 
 
14827 
  def read(self, iprot):
14828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14830 
      return
14831 
    iprot.readStructBegin()
14832 
    while True:
14833 
      (fname, ftype, fid) = iprot.readFieldBegin()
14834 
      if ftype == TType.STOP:
14835 
        break
14836 
      if fid == 1:
14837 
        if ftype == TType.I64:
14838 
          self.userId = iprot.readI64();
14839 
        else:
14840 
          iprot.skip(ftype)
14841 
      else:
14842 
        iprot.skip(ftype)
14843 
      iprot.readFieldEnd()
14844 
    iprot.readStructEnd()
14845 
 
14846 
  def write(self, oprot):
14847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14849 
      return
14850 
    oprot.writeStructBegin('isPrivateDealUser_args')
14851 
    if self.userId is not None:
14852 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14853 
      oprot.writeI64(self.userId)
14854 
      oprot.writeFieldEnd()
14855 
    oprot.writeFieldStop()
14856 
    oprot.writeStructEnd()
14857 
 
14858 
  def validate(self):
14859 
    return
14860 
 
14861 
 
14862 
  def __repr__(self):
14863 
    L = ['%s=%r' % (key, value)
14864 
      for key, value in self.__dict__.iteritems()]
14865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14866 
 
14867 
  def __eq__(self, other):
14868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14869 
 
14870 
  def __ne__(self, other):
14871 
    return not (self == other)
14872 
 
14873 
class isPrivateDealUser_result:
14874 
  """
14875 
  Attributes:
14876 
   - success
14877 
  """
14878 
 
14879 
  thrift_spec = (
14880 
    (0, TType.BOOL, 'success', None, None, ), # 0
14881 
  )
14882 
 
14883 
  def __init__(self, success=None,):
14884 
    self.success = success
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
14895 
      if fid == 0:
14896 
        if ftype == TType.BOOL:
14897 
          self.success = iprot.readBool();
14898 
        else:
14899 
          iprot.skip(ftype)
14900 
      else:
14901 
        iprot.skip(ftype)
14902 
      iprot.readFieldEnd()
14903 
    iprot.readStructEnd()
14904 
 
14905 
  def write(self, oprot):
14906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14908 
      return
14909 
    oprot.writeStructBegin('isPrivateDealUser_result')
14910 
    if self.success is not None:
14911 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14912 
      oprot.writeBool(self.success)
14913 
      oprot.writeFieldEnd()
14914 
    oprot.writeFieldStop()
14915 
    oprot.writeStructEnd()
14916 
 
14917 
  def validate(self):
14918 
    return
14919 
 
14920 
 
14921 
  def __repr__(self):
14922 
    L = ['%s=%r' % (key, value)
14923 
      for key, value in self.__dict__.iteritems()]
14924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14925 
 
14926 
  def __eq__(self, other):
14927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14928 
 
14929 
  def __ne__(self, other):
14930 
    return not (self == other)
11890 kshitij.so 14931 
 
14932 
class addPrivateDealUser_args:
14933 
  """
14934 
  Attributes:
14935 
   - userId
14936 
  """
14937 
 
14938 
  thrift_spec = (
14939 
    None, # 0
14940 
    (1, TType.I64, 'userId', None, None, ), # 1
14941 
  )
14942 
 
14943 
  def __init__(self, userId=None,):
14944 
    self.userId = userId
14945 
 
14946 
  def read(self, iprot):
14947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14949 
      return
14950 
    iprot.readStructBegin()
14951 
    while True:
14952 
      (fname, ftype, fid) = iprot.readFieldBegin()
14953 
      if ftype == TType.STOP:
14954 
        break
14955 
      if fid == 1:
14956 
        if ftype == TType.I64:
14957 
          self.userId = iprot.readI64();
14958 
        else:
14959 
          iprot.skip(ftype)
14960 
      else:
14961 
        iprot.skip(ftype)
14962 
      iprot.readFieldEnd()
14963 
    iprot.readStructEnd()
14964 
 
14965 
  def write(self, oprot):
14966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14968 
      return
14969 
    oprot.writeStructBegin('addPrivateDealUser_args')
14970 
    if self.userId is not None:
14971 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14972 
      oprot.writeI64(self.userId)
14973 
      oprot.writeFieldEnd()
14974 
    oprot.writeFieldStop()
14975 
    oprot.writeStructEnd()
14976 
 
14977 
  def validate(self):
14978 
    return
14979 
 
14980 
 
14981 
  def __repr__(self):
14982 
    L = ['%s=%r' % (key, value)
14983 
      for key, value in self.__dict__.iteritems()]
14984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14985 
 
14986 
  def __eq__(self, other):
14987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14988 
 
14989 
  def __ne__(self, other):
14990 
    return not (self == other)
14991 
 
14992 
class addPrivateDealUser_result:
14993 
  """
14994 
  Attributes:
14995 
   - success
14996 
  """
14997 
 
14998 
  thrift_spec = (
14999 
    (0, TType.BOOL, 'success', None, None, ), # 0
15000 
  )
15001 
 
15002 
  def __init__(self, success=None,):
15003 
    self.success = success
15004 
 
15005 
  def read(self, iprot):
15006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15008 
      return
15009 
    iprot.readStructBegin()
15010 
    while True:
15011 
      (fname, ftype, fid) = iprot.readFieldBegin()
15012 
      if ftype == TType.STOP:
15013 
        break
15014 
      if fid == 0:
15015 
        if ftype == TType.BOOL:
15016 
          self.success = iprot.readBool();
15017 
        else:
15018 
          iprot.skip(ftype)
15019 
      else:
15020 
        iprot.skip(ftype)
15021 
      iprot.readFieldEnd()
15022 
    iprot.readStructEnd()
15023 
 
15024 
  def write(self, oprot):
15025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15027 
      return
15028 
    oprot.writeStructBegin('addPrivateDealUser_result')
15029 
    if self.success is not None:
15030 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15031 
      oprot.writeBool(self.success)
15032 
      oprot.writeFieldEnd()
15033 
    oprot.writeFieldStop()
15034 
    oprot.writeStructEnd()
15035 
 
15036 
  def validate(self):
15037 
    return
15038 
 
15039 
 
15040 
  def __repr__(self):
15041 
    L = ['%s=%r' % (key, value)
15042 
      for key, value in self.__dict__.iteritems()]
15043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15044 
 
15045 
  def __eq__(self, other):
15046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15047 
 
15048 
  def __ne__(self, other):
15049 
    return not (self == other)
15050 
 
15051 
class changePrivateDealUserStatus_args:
15052 
  """
15053 
  Attributes:
15054 
   - userId
15055 
   - isActive
15056 
  """
15057 
 
15058 
  thrift_spec = (
15059 
    None, # 0
15060 
    (1, TType.I64, 'userId', None, None, ), # 1
15061 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15062 
  )
15063 
 
15064 
  def __init__(self, userId=None, isActive=None,):
15065 
    self.userId = userId
15066 
    self.isActive = isActive
15067 
 
15068 
  def read(self, iprot):
15069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15071 
      return
15072 
    iprot.readStructBegin()
15073 
    while True:
15074 
      (fname, ftype, fid) = iprot.readFieldBegin()
15075 
      if ftype == TType.STOP:
15076 
        break
15077 
      if fid == 1:
15078 
        if ftype == TType.I64:
15079 
          self.userId = iprot.readI64();
15080 
        else:
15081 
          iprot.skip(ftype)
15082 
      elif fid == 2:
15083 
        if ftype == TType.BOOL:
15084 
          self.isActive = iprot.readBool();
15085 
        else:
15086 
          iprot.skip(ftype)
15087 
      else:
15088 
        iprot.skip(ftype)
15089 
      iprot.readFieldEnd()
15090 
    iprot.readStructEnd()
15091 
 
15092 
  def write(self, oprot):
15093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15095 
      return
15096 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15097 
    if self.userId is not None:
15098 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15099 
      oprot.writeI64(self.userId)
15100 
      oprot.writeFieldEnd()
15101 
    if self.isActive is not None:
15102 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15103 
      oprot.writeBool(self.isActive)
15104 
      oprot.writeFieldEnd()
15105 
    oprot.writeFieldStop()
15106 
    oprot.writeStructEnd()
15107 
 
15108 
  def validate(self):
15109 
    return
15110 
 
15111 
 
15112 
  def __repr__(self):
15113 
    L = ['%s=%r' % (key, value)
15114 
      for key, value in self.__dict__.iteritems()]
15115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15116 
 
15117 
  def __eq__(self, other):
15118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15119 
 
15120 
  def __ne__(self, other):
15121 
    return not (self == other)
15122 
 
15123 
class changePrivateDealUserStatus_result:
15124 
  """
15125 
  Attributes:
15126 
   - success
15127 
  """
15128 
 
15129 
  thrift_spec = (
15130 
    (0, TType.BOOL, 'success', None, None, ), # 0
15131 
  )
15132 
 
15133 
  def __init__(self, success=None,):
15134 
    self.success = success
15135 
 
15136 
  def read(self, iprot):
15137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15139 
      return
15140 
    iprot.readStructBegin()
15141 
    while True:
15142 
      (fname, ftype, fid) = iprot.readFieldBegin()
15143 
      if ftype == TType.STOP:
15144 
        break
15145 
      if fid == 0:
15146 
        if ftype == TType.BOOL:
15147 
          self.success = iprot.readBool();
15148 
        else:
15149 
          iprot.skip(ftype)
15150 
      else:
15151 
        iprot.skip(ftype)
15152 
      iprot.readFieldEnd()
15153 
    iprot.readStructEnd()
15154 
 
15155 
  def write(self, oprot):
15156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15158 
      return
15159 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15160 
    if self.success is not None:
15161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15162 
      oprot.writeBool(self.success)
15163 
      oprot.writeFieldEnd()
15164 
    oprot.writeFieldStop()
15165 
    oprot.writeStructEnd()
15166 
 
15167 
  def validate(self):
15168 
    return
15169 
 
15170 
 
15171 
  def __repr__(self):
15172 
    L = ['%s=%r' % (key, value)
15173 
      for key, value in self.__dict__.iteritems()]
15174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15175 
 
15176 
  def __eq__(self, other):
15177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15178 
 
15179 
  def __ne__(self, other):
15180 
    return not (self == other)
15181 
 
15182 
class getPrivateDealUser_args:
15183 
  """
15184 
  Attributes:
15185 
   - userId
15186 
  """
15187 
 
15188 
  thrift_spec = (
15189 
    None, # 0
15190 
    (1, TType.I64, 'userId', None, None, ), # 1
15191 
  )
15192 
 
15193 
  def __init__(self, userId=None,):
15194 
    self.userId = userId
15195 
 
15196 
  def read(self, iprot):
15197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15199 
      return
15200 
    iprot.readStructBegin()
15201 
    while True:
15202 
      (fname, ftype, fid) = iprot.readFieldBegin()
15203 
      if ftype == TType.STOP:
15204 
        break
15205 
      if fid == 1:
15206 
        if ftype == TType.I64:
15207 
          self.userId = iprot.readI64();
15208 
        else:
15209 
          iprot.skip(ftype)
15210 
      else:
15211 
        iprot.skip(ftype)
15212 
      iprot.readFieldEnd()
15213 
    iprot.readStructEnd()
15214 
 
15215 
  def write(self, oprot):
15216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15218 
      return
15219 
    oprot.writeStructBegin('getPrivateDealUser_args')
15220 
    if self.userId is not None:
15221 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15222 
      oprot.writeI64(self.userId)
15223 
      oprot.writeFieldEnd()
15224 
    oprot.writeFieldStop()
15225 
    oprot.writeStructEnd()
15226 
 
15227 
  def validate(self):
15228 
    return
15229 
 
15230 
 
15231 
  def __repr__(self):
15232 
    L = ['%s=%r' % (key, value)
15233 
      for key, value in self.__dict__.iteritems()]
15234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15235 
 
15236 
  def __eq__(self, other):
15237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15238 
 
15239 
  def __ne__(self, other):
15240 
    return not (self == other)
15241 
 
15242 
class getPrivateDealUser_result:
15243 
  """
15244 
  Attributes:
15245 
   - success
15246 
  """
15247 
 
15248 
  thrift_spec = (
15249 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15250 
  )
15251 
 
15252 
  def __init__(self, success=None,):
15253 
    self.success = success
15254 
 
15255 
  def read(self, iprot):
15256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15258 
      return
15259 
    iprot.readStructBegin()
15260 
    while True:
15261 
      (fname, ftype, fid) = iprot.readFieldBegin()
15262 
      if ftype == TType.STOP:
15263 
        break
15264 
      if fid == 0:
15265 
        if ftype == TType.STRUCT:
15266 
          self.success = PrivateDealUser()
15267 
          self.success.read(iprot)
15268 
        else:
15269 
          iprot.skip(ftype)
15270 
      else:
15271 
        iprot.skip(ftype)
15272 
      iprot.readFieldEnd()
15273 
    iprot.readStructEnd()
15274 
 
15275 
  def write(self, oprot):
15276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15278 
      return
15279 
    oprot.writeStructBegin('getPrivateDealUser_result')
15280 
    if self.success is not None:
15281 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15282 
      self.success.write(oprot)
15283 
      oprot.writeFieldEnd()
15284 
    oprot.writeFieldStop()
15285 
    oprot.writeStructEnd()
15286 
 
15287 
  def validate(self):
15288 
    return
15289 
 
15290 
 
15291 
  def __repr__(self):
15292 
    L = ['%s=%r' % (key, value)
15293 
      for key, value in self.__dict__.iteritems()]
15294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15295 
 
15296 
  def __eq__(self, other):
15297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15298 
 
15299 
  def __ne__(self, other):
15300 
    return not (self == other)