Subversion Repositories SmartDukaan

Rev

Rev 11592 | Rev 11890 | 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 
 
690 chandransh 438 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 439 
    """
690 chandransh 440 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 441 
 
575 chandransh 442 
    Parameters:
690 chandransh 443 
     - fromCartId
444 
     - toCartId
445 
    """
446 
    pass
447 
 
448 
  def checkOut(self, cartId):
449 
    """
450 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 451 
 
690 chandransh 452 
    Parameters:
575 chandransh 453 
     - cartId
454 
    """
455 
    pass
456 
 
690 chandransh 457 
  def resetCart(self, cartId, items):
559 chandransh 458 
    """
690 chandransh 459 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
460 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 461 
 
559 chandransh 462 
    Parameters:
690 chandransh 463 
     - cartId
464 
     - items
559 chandransh 465 
    """
466 
    pass
467 
 
2981 rajveer 468 
  def getUserCount(self, userType):
559 chandransh 469 
    """
2981 rajveer 470 
    Returns number of registered users.
471 
    If userType = null, then it returns count of all users, including anonymous
472 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
473 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 474 
 
559 chandransh 475 
    Parameters:
2981 rajveer 476 
     - userType
559 chandransh 477 
    """
478 
    pass
479 
 
2981 rajveer 480 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 481 
    """
2981 rajveer 482 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
483 
    If any of startDate or endDate is -1, then that filter is ignored.
484 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 485 
 
486 
 
559 chandransh 487 
    Parameters:
2981 rajveer 488 
     - userType
489 
     - startDate
490 
     - endDate
559 chandransh 491 
    """
492 
    pass
493 
 
2981 rajveer 494 
  def getMyResearchItems(self, userId):
559 chandransh 495 
    """
2981 rajveer 496 
    Returns list of item ids in myresearch for the user
3431 rajveer 497 
 
559 chandransh 498 
    Parameters:
499 
     - userId
500 
    """
501 
    pass
502 
 
2981 rajveer 503 
  def updateMyResearch(self, userId, itemId):
559 chandransh 504 
    """
2981 rajveer 505 
    add item to my research for a user
3431 rajveer 506 
 
559 chandransh 507 
    Parameters:
2981 rajveer 508 
     - userId
509 
     - itemId
559 chandransh 510 
    """
511 
    pass
512 
 
2981 rajveer 513 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 514 
    """
2981 rajveer 515 
    delete item from my research for a user
3431 rajveer 516 
 
1596 ankur.sing 517 
    Parameters:
2981 rajveer 518 
     - userId
519 
     - itemId
1596 ankur.sing 520 
    """
521 
    pass
559 chandransh 522 
 
2981 rajveer 523 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 524 
    """
2981 rajveer 525 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 526 
 
1673 ankur.sing 527 
    Parameters:
2981 rajveer 528 
     - userId
1673 ankur.sing 529 
    """
530 
    pass
1596 ankur.sing 531 
 
2981 rajveer 532 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 533 
    """
2981 rajveer 534 
    add item to browse history for a user
3431 rajveer 535 
 
2642 varun.gupt 536 
    Parameters:
2981 rajveer 537 
     - userId
538 
     - itemId
2642 varun.gupt 539 
    """
540 
    pass
1673 ankur.sing 541 
 
3385 varun.gupt 542 
  def getCartsWithCouponCount(self, couponCode):
543 
    """
544 
    Returns count of Carts with given coupon applied
3431 rajveer 545 
 
3385 varun.gupt 546 
    Parameters:
547 
     - couponCode
548 
    """
549 
    pass
2642 varun.gupt 550 
 
3499 mandeep.dh 551 
  def increaseTrustLevel(self, userId, trustLevelDelta):
552 
    """
553 
    Updates COD trust level of a user
3385 varun.gupt 554 
 
3499 mandeep.dh 555 
    Parameters:
556 
     - userId
557 
     - trustLevelDelta
558 
    """
559 
    pass
560 
 
5407 amar.kumar 561 
  def getTrustLevel(self, userId):
562 
    """
563 
    Get trust level of a user
564 
 
565 
    Parameters:
566 
     - userId
567 
    """
568 
    pass
569 
 
4668 varun.gupt 570 
  def showCODOption(self, cartId, sourceId, pincode):
571 
    """
572 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 573 
 
4668 varun.gupt 574 
    Parameters:
575 
     - cartId
576 
     - sourceId
577 
     - pincode
578 
    """
579 
    pass
580 
 
5623 anupam.sin 581 
  def getUserEmails(self, startDate, endDate):
582 
    """
583 
    Get email addresses for users activated within a given date range
4668 varun.gupt 584 
 
5623 anupam.sin 585 
    Parameters:
586 
     - startDate
587 
     - endDate
588 
    """
589 
    pass
590 
 
9299 kshitij.so 591 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 592 
    """
593 
    Mark a cart lineitem as insured. Returns true/false.
594 
 
595 
    Parameters:
596 
     - itemId
597 
     - cartId
598 
     - toInsure
9299 kshitij.so 599 
     - insurerType
6903 anupam.sin 600 
    """
601 
    pass
602 
 
603 
  def cancelInsurance(self, cartId):
604 
    """
605 
    Cancel insurance for all items in the cart
606 
 
607 
    Parameters:
608 
     - cartId
609 
    """
610 
    pass
611 
 
612 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
613 
    """
614 
    Stores insurance specific details like date of birth and guardianName
615 
 
616 
    Parameters:
617 
     - addressId
618 
     - dob
619 
     - guardianName
620 
    """
621 
    pass
622 
 
623 
  def isInsuranceDetailPresent(self, addressId):
624 
    """
625 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
626 
 
627 
    Parameters:
628 
     - addressId
629 
    """
630 
    pass
631 
 
9791 rajveer 632 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 633 
    """
9791 rajveer 634 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 635 
 
6821 amar.kumar 636 
    Parameters:
637 
     - startDate
638 
     - endDate
639 
    """
640 
    pass
641 
 
11592 amit.gupta 642 
  def validateCartPlus(self, cartId, sourceId):
643 
    """
644 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 645 
 
11592 amit.gupta 646 
    Parameters:
647 
     - cartId
648 
     - sourceId
649 
    """
650 
    pass
651 
 
11679 vikram.rag 652 
  def isPrivateDealUser(self, userId):
653 
    """
654 
    Parameters:
655 
     - userId
656 
    """
657 
    pass
11592 amit.gupta 658 
 
11679 vikram.rag 659 
 
3376 rajveer 660 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 661 
  """
662 
  service
663 
  """
664 
  def __init__(self, iprot, oprot=None):
3376 rajveer 665 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 666 
 
559 chandransh 667 
  def createAnonymousUser(self, jsessionId):
94 ashish 668 
    """
669 
    Parameters:
559 chandransh 670 
     - jsessionId
94 ashish 671 
    """
559 chandransh 672 
    self.send_createAnonymousUser(jsessionId)
673 
    return self.recv_createAnonymousUser()
94 ashish 674 
 
559 chandransh 675 
  def send_createAnonymousUser(self, jsessionId):
676 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
677 
    args = createAnonymousUser_args()
678 
    args.jsessionId = jsessionId
94 ashish 679 
    args.write(self._oprot)
680 
    self._oprot.writeMessageEnd()
681 
    self._oprot.trans.flush()
682 
 
559 chandransh 683 
  def recv_createAnonymousUser(self, ):
94 ashish 684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
685 
    if mtype == TMessageType.EXCEPTION:
686 
      x = TApplicationException()
687 
      x.read(self._iprot)
688 
      self._iprot.readMessageEnd()
689 
      raise x
559 chandransh 690 
    result = createAnonymousUser_result()
94 ashish 691 
    result.read(self._iprot)
692 
    self._iprot.readMessageEnd()
3431 rajveer 693 
    if result.success is not None:
94 ashish 694 
      return result.success
3431 rajveer 695 
    if result.ucex is not None:
559 chandransh 696 
      raise result.ucex
697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 698 
 
559 chandransh 699 
  def getUserById(self, userId):
94 ashish 700 
    """
701 
    Parameters:
702 
     - userId
703 
    """
559 chandransh 704 
    self.send_getUserById(userId)
705 
    return self.recv_getUserById()
94 ashish 706 
 
559 chandransh 707 
  def send_getUserById(self, userId):
708 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
709 
    args = getUserById_args()
94 ashish 710 
    args.userId = userId
711 
    args.write(self._oprot)
712 
    self._oprot.writeMessageEnd()
713 
    self._oprot.trans.flush()
714 
 
559 chandransh 715 
  def recv_getUserById(self, ):
94 ashish 716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
717 
    if mtype == TMessageType.EXCEPTION:
718 
      x = TApplicationException()
719 
      x.read(self._iprot)
720 
      self._iprot.readMessageEnd()
721 
      raise x
559 chandransh 722 
    result = getUserById_result()
94 ashish 723 
    result.read(self._iprot)
724 
    self._iprot.readMessageEnd()
3431 rajveer 725 
    if result.success is not None:
94 ashish 726 
      return result.success
3431 rajveer 727 
    if result.ucex is not None:
559 chandransh 728 
      raise result.ucex
729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 730 
 
5326 rajveer 731 
  def getUserByCartId(self, cartId):
732 
    """
733 
    Parameters:
734 
     - cartId
735 
    """
736 
    self.send_getUserByCartId(cartId)
737 
    return self.recv_getUserByCartId()
738 
 
739 
  def send_getUserByCartId(self, cartId):
740 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
741 
    args = getUserByCartId_args()
742 
    args.cartId = cartId
743 
    args.write(self._oprot)
744 
    self._oprot.writeMessageEnd()
745 
    self._oprot.trans.flush()
746 
 
747 
  def recv_getUserByCartId(self, ):
748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
749 
    if mtype == TMessageType.EXCEPTION:
750 
      x = TApplicationException()
751 
      x.read(self._iprot)
752 
      self._iprot.readMessageEnd()
753 
      raise x
754 
    result = getUserByCartId_result()
755 
    result.read(self._iprot)
756 
    self._iprot.readMessageEnd()
757 
    if result.success is not None:
758 
      return result.success
759 
    if result.ucex is not None:
760 
      raise result.ucex
761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
762 
 
1491 vikas 763 
  def getUserByEmail(self, email):
764 
    """
765 
    Parameters:
766 
     - email
767 
    """
768 
    self.send_getUserByEmail(email)
769 
    return self.recv_getUserByEmail()
770 
 
771 
  def send_getUserByEmail(self, email):
772 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
773 
    args = getUserByEmail_args()
774 
    args.email = email
775 
    args.write(self._oprot)
776 
    self._oprot.writeMessageEnd()
777 
    self._oprot.trans.flush()
778 
 
779 
  def recv_getUserByEmail(self, ):
780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
781 
    if mtype == TMessageType.EXCEPTION:
782 
      x = TApplicationException()
783 
      x.read(self._iprot)
784 
      self._iprot.readMessageEnd()
785 
      raise x
786 
    result = getUserByEmail_result()
787 
    result.read(self._iprot)
788 
    self._iprot.readMessageEnd()
3431 rajveer 789 
    if result.success is not None:
1491 vikas 790 
      return result.success
3431 rajveer 791 
    if result.ucex is not None:
1491 vikas 792 
      raise result.ucex
793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
794 
 
3032 mandeep.dh 795 
  def getUserByMobileNumber(self, mobileNumber):
796 
    """
797 
    Parameters:
798 
     - mobileNumber
799 
    """
800 
    self.send_getUserByMobileNumber(mobileNumber)
801 
    return self.recv_getUserByMobileNumber()
802 
 
803 
  def send_getUserByMobileNumber(self, mobileNumber):
804 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
805 
    args = getUserByMobileNumber_args()
806 
    args.mobileNumber = mobileNumber
807 
    args.write(self._oprot)
808 
    self._oprot.writeMessageEnd()
809 
    self._oprot.trans.flush()
810 
 
811 
  def recv_getUserByMobileNumber(self, ):
812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
813 
    if mtype == TMessageType.EXCEPTION:
814 
      x = TApplicationException()
815 
      x.read(self._iprot)
816 
      self._iprot.readMessageEnd()
817 
      raise x
818 
    result = getUserByMobileNumber_result()
819 
    result.read(self._iprot)
820 
    self._iprot.readMessageEnd()
3431 rajveer 821 
    if result.success is not None:
3032 mandeep.dh 822 
      return result.success
3431 rajveer 823 
    if result.ucex is not None:
3032 mandeep.dh 824 
      raise result.ucex
825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
826 
 
559 chandransh 827 
  def createUser(self, user):
94 ashish 828 
    """
829 
    Parameters:
559 chandransh 830 
     - user
94 ashish 831 
    """
559 chandransh 832 
    self.send_createUser(user)
833 
    return self.recv_createUser()
94 ashish 834 
 
559 chandransh 835 
  def send_createUser(self, user):
836 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
837 
    args = createUser_args()
838 
    args.user = user
94 ashish 839 
    args.write(self._oprot)
840 
    self._oprot.writeMessageEnd()
841 
    self._oprot.trans.flush()
842 
 
559 chandransh 843 
  def recv_createUser(self, ):
94 ashish 844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
845 
    if mtype == TMessageType.EXCEPTION:
846 
      x = TApplicationException()
847 
      x.read(self._iprot)
848 
      self._iprot.readMessageEnd()
849 
      raise x
559 chandransh 850 
    result = createUser_result()
94 ashish 851 
    result.read(self._iprot)
852 
    self._iprot.readMessageEnd()
3431 rajveer 853 
    if result.success is not None:
94 ashish 854 
      return result.success
3431 rajveer 855 
    if result.ucex is not None:
559 chandransh 856 
      raise result.ucex
857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 858 
 
559 chandransh 859 
  def updateUser(self, user):
94 ashish 860 
    """
861 
    Parameters:
559 chandransh 862 
     - user
94 ashish 863 
    """
559 chandransh 864 
    self.send_updateUser(user)
865 
    return self.recv_updateUser()
94 ashish 866 
 
559 chandransh 867 
  def send_updateUser(self, user):
868 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
869 
    args = updateUser_args()
870 
    args.user = user
94 ashish 871 
    args.write(self._oprot)
872 
    self._oprot.writeMessageEnd()
873 
    self._oprot.trans.flush()
874 
 
559 chandransh 875 
  def recv_updateUser(self, ):
94 ashish 876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
877 
    if mtype == TMessageType.EXCEPTION:
878 
      x = TApplicationException()
879 
      x.read(self._iprot)
880 
      self._iprot.readMessageEnd()
881 
      raise x
559 chandransh 882 
    result = updateUser_result()
94 ashish 883 
    result.read(self._iprot)
884 
    self._iprot.readMessageEnd()
3431 rajveer 885 
    if result.success is not None:
94 ashish 886 
      return result.success
3431 rajveer 887 
    if result.ucex is not None:
559 chandransh 888 
      raise result.ucex
889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 890 
 
559 chandransh 891 
  def authenticateUser(self, email, password):
94 ashish 892 
    """
893 
    Parameters:
894 
     - email
895 
     - password
896 
    """
559 chandransh 897 
    self.send_authenticateUser(email, password)
122 ashish 898 
    return self.recv_authenticateUser()
899 
 
559 chandransh 900 
  def send_authenticateUser(self, email, password):
122 ashish 901 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
902 
    args = authenticateUser_args()
559 chandransh 903 
    args.email = email
122 ashish 904 
    args.password = password
905 
    args.write(self._oprot)
906 
    self._oprot.writeMessageEnd()
907 
    self._oprot.trans.flush()
908 
 
909 
  def recv_authenticateUser(self, ):
910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
911 
    if mtype == TMessageType.EXCEPTION:
912 
      x = TApplicationException()
913 
      x.read(self._iprot)
914 
      self._iprot.readMessageEnd()
915 
      raise x
916 
    result = authenticateUser_result()
917 
    result.read(self._iprot)
918 
    self._iprot.readMessageEnd()
3431 rajveer 919 
    if result.success is not None:
122 ashish 920 
      return result.success
3431 rajveer 921 
    if result.auex is not None:
559 chandransh 922 
      raise result.auex
122 ashish 923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
924 
 
94 ashish 925 
  def userExists(self, email):
926 
    """
927 
    Parameters:
928 
     - email
929 
    """
930 
    self.send_userExists(email)
931 
    return self.recv_userExists()
932 
 
933 
  def send_userExists(self, email):
934 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
935 
    args = userExists_args()
936 
    args.email = email
937 
    args.write(self._oprot)
938 
    self._oprot.writeMessageEnd()
939 
    self._oprot.trans.flush()
940 
 
941 
  def recv_userExists(self, ):
942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
943 
    if mtype == TMessageType.EXCEPTION:
944 
      x = TApplicationException()
945 
      x.read(self._iprot)
946 
      self._iprot.readMessageEnd()
947 
      raise x
948 
    result = userExists_result()
949 
    result.read(self._iprot)
950 
    self._iprot.readMessageEnd()
3431 rajveer 951 
    if result.success is not None:
94 ashish 952 
      return result.success
3431 rajveer 953 
    if result.ucx is not None:
94 ashish 954 
      raise result.ucx
955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
956 
 
567 rajveer 957 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 958 
    """
959 
    Parameters:
960 
     - userId
961 
     - address
513 rajveer 962 
     - setDefault
94 ashish 963 
    """
567 rajveer 964 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 965 
    return self.recv_addAddressForUser()
966 
 
567 rajveer 967 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 968 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
969 
    args = addAddressForUser_args()
559 chandransh 970 
    args.userId = userId
94 ashish 971 
    args.address = address
513 rajveer 972 
    args.setDefault = setDefault
94 ashish 973 
    args.write(self._oprot)
974 
    self._oprot.writeMessageEnd()
975 
    self._oprot.trans.flush()
976 
 
977 
  def recv_addAddressForUser(self, ):
978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
979 
    if mtype == TMessageType.EXCEPTION:
980 
      x = TApplicationException()
981 
      x.read(self._iprot)
982 
      self._iprot.readMessageEnd()
983 
      raise x
984 
    result = addAddressForUser_result()
985 
    result.read(self._iprot)
986 
    self._iprot.readMessageEnd()
3431 rajveer 987 
    if result.success is not None:
94 ashish 988 
      return result.success
3431 rajveer 989 
    if result.ucx is not None:
94 ashish 990 
      raise result.ucx
991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
992 
 
993 
  def removeAddressForUser(self, userid, addressId):
994 
    """
995 
    Parameters:
996 
     - userid
997 
     - addressId
998 
    """
999 
    self.send_removeAddressForUser(userid, addressId)
1000 
    return self.recv_removeAddressForUser()
1001 
 
1002 
  def send_removeAddressForUser(self, userid, addressId):
1003 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1004 
    args = removeAddressForUser_args()
1005 
    args.userid = userid
1006 
    args.addressId = addressId
1007 
    args.write(self._oprot)
1008 
    self._oprot.writeMessageEnd()
1009 
    self._oprot.trans.flush()
1010 
 
1011 
  def recv_removeAddressForUser(self, ):
1012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1013 
    if mtype == TMessageType.EXCEPTION:
1014 
      x = TApplicationException()
1015 
      x.read(self._iprot)
1016 
      self._iprot.readMessageEnd()
1017 
      raise x
1018 
    result = removeAddressForUser_result()
1019 
    result.read(self._iprot)
1020 
    self._iprot.readMessageEnd()
3431 rajveer 1021 
    if result.success is not None:
94 ashish 1022 
      return result.success
3431 rajveer 1023 
    if result.ucx is not None:
94 ashish 1024 
      raise result.ucx
1025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1026 
 
1027 
  def setUserAsLoggedIn(self, userId, timestamp):
1028 
    """
1029 
    Parameters:
1030 
     - userId
1031 
     - timestamp
1032 
    """
1033 
    self.send_setUserAsLoggedIn(userId, timestamp)
1034 
    return self.recv_setUserAsLoggedIn()
1035 
 
1036 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1037 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1038 
    args = setUserAsLoggedIn_args()
1039 
    args.userId = userId
1040 
    args.timestamp = timestamp
1041 
    args.write(self._oprot)
1042 
    self._oprot.writeMessageEnd()
1043 
    self._oprot.trans.flush()
1044 
 
1045 
  def recv_setUserAsLoggedIn(self, ):
1046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1047 
    if mtype == TMessageType.EXCEPTION:
1048 
      x = TApplicationException()
1049 
      x.read(self._iprot)
1050 
      self._iprot.readMessageEnd()
1051 
      raise x
1052 
    result = setUserAsLoggedIn_result()
1053 
    result.read(self._iprot)
1054 
    self._iprot.readMessageEnd()
3431 rajveer 1055 
    if result.success is not None:
94 ashish 1056 
      return result.success
3431 rajveer 1057 
    if result.ucx is not None:
94 ashish 1058 
      raise result.ucx
1059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1060 
 
1061 
  def setUserAsLoggedOut(self, userid, timestamp):
1062 
    """
1063 
    Parameters:
1064 
     - userid
1065 
     - timestamp
1066 
    """
1067 
    self.send_setUserAsLoggedOut(userid, timestamp)
1068 
    return self.recv_setUserAsLoggedOut()
1069 
 
1070 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1071 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1072 
    args = setUserAsLoggedOut_args()
1073 
    args.userid = userid
1074 
    args.timestamp = timestamp
1075 
    args.write(self._oprot)
1076 
    self._oprot.writeMessageEnd()
1077 
    self._oprot.trans.flush()
1078 
 
1079 
  def recv_setUserAsLoggedOut(self, ):
1080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1081 
    if mtype == TMessageType.EXCEPTION:
1082 
      x = TApplicationException()
1083 
      x.read(self._iprot)
1084 
      self._iprot.readMessageEnd()
1085 
      raise x
1086 
    result = setUserAsLoggedOut_result()
1087 
    result.read(self._iprot)
1088 
    self._iprot.readMessageEnd()
3431 rajveer 1089 
    if result.success is not None:
94 ashish 1090 
      return result.success
3431 rajveer 1091 
    if result.ucx is not None:
94 ashish 1092 
      raise result.ucx
1093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1094 
 
504 rajveer 1095 
  def setDefaultAddress(self, userid, addressId):
1096 
    """
1097 
    Parameters:
1098 
     - userid
1099 
     - addressId
1100 
    """
1101 
    self.send_setDefaultAddress(userid, addressId)
1102 
    return self.recv_setDefaultAddress()
1103 
 
1104 
  def send_setDefaultAddress(self, userid, addressId):
1105 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1106 
    args = setDefaultAddress_args()
1107 
    args.userid = userid
1108 
    args.addressId = addressId
1109 
    args.write(self._oprot)
1110 
    self._oprot.writeMessageEnd()
1111 
    self._oprot.trans.flush()
1112 
 
1113 
  def recv_setDefaultAddress(self, ):
1114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1115 
    if mtype == TMessageType.EXCEPTION:
1116 
      x = TApplicationException()
1117 
      x.read(self._iprot)
1118 
      self._iprot.readMessageEnd()
1119 
      raise x
1120 
    result = setDefaultAddress_result()
1121 
    result.read(self._iprot)
1122 
    self._iprot.readMessageEnd()
3431 rajveer 1123 
    if result.success is not None:
504 rajveer 1124 
      return result.success
3431 rajveer 1125 
    if result.ucx is not None:
504 rajveer 1126 
      raise result.ucx
1127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1128 
 
594 rajveer 1129 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1130 
    """
1131 
    Parameters:
1132 
     - userid
594 rajveer 1133 
     - oldPassword
1134 
     - newPassword
94 ashish 1135 
    """
594 rajveer 1136 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1137 
    return self.recv_updatePassword()
1138 
 
594 rajveer 1139 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1140 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1141 
    args = updatePassword_args()
1142 
    args.userid = userid
594 rajveer 1143 
    args.oldPassword = oldPassword
1144 
    args.newPassword = newPassword
94 ashish 1145 
    args.write(self._oprot)
1146 
    self._oprot.writeMessageEnd()
1147 
    self._oprot.trans.flush()
1148 
 
1149 
  def recv_updatePassword(self, ):
1150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1151 
    if mtype == TMessageType.EXCEPTION:
1152 
      x = TApplicationException()
1153 
      x.read(self._iprot)
1154 
      self._iprot.readMessageEnd()
1155 
      raise x
1156 
    result = updatePassword_result()
1157 
    result.read(self._iprot)
1158 
    self._iprot.readMessageEnd()
3431 rajveer 1159 
    if result.success is not None:
94 ashish 1160 
      return result.success
3431 rajveer 1161 
    if result.ucx is not None:
94 ashish 1162 
      raise result.ucx
1163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1164 
 
884 rajveer 1165 
  def forgotPassword(self, email, newPassword):
581 rajveer 1166 
    """
1167 
    Parameters:
1168 
     - email
884 rajveer 1169 
     - newPassword
581 rajveer 1170 
    """
884 rajveer 1171 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1172 
    return self.recv_forgotPassword()
1173 
 
884 rajveer 1174 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1175 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1176 
    args = forgotPassword_args()
1177 
    args.email = email
884 rajveer 1178 
    args.newPassword = newPassword
581 rajveer 1179 
    args.write(self._oprot)
1180 
    self._oprot.writeMessageEnd()
1181 
    self._oprot.trans.flush()
1182 
 
1183 
  def recv_forgotPassword(self, ):
1184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1185 
    if mtype == TMessageType.EXCEPTION:
1186 
      x = TApplicationException()
1187 
      x.read(self._iprot)
1188 
      self._iprot.readMessageEnd()
1189 
      raise x
1190 
    result = forgotPassword_result()
1191 
    result.read(self._iprot)
1192 
    self._iprot.readMessageEnd()
3431 rajveer 1193 
    if result.success is not None:
581 rajveer 1194 
      return result.success
3431 rajveer 1195 
    if result.ucx is not None:
581 rajveer 1196 
      raise result.ucx
1197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1198 
 
594 rajveer 1199 
  def getAllAddressesForUser(self, userId):
1200 
    """
1201 
    Parameters:
1202 
     - userId
1203 
    """
1204 
    self.send_getAllAddressesForUser(userId)
1205 
    return self.recv_getAllAddressesForUser()
1206 
 
1207 
  def send_getAllAddressesForUser(self, userId):
1208 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1209 
    args = getAllAddressesForUser_args()
1210 
    args.userId = userId
1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
1215 
  def recv_getAllAddressesForUser(self, ):
1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
1222 
    result = getAllAddressesForUser_result()
1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
3431 rajveer 1225 
    if result.success is not None:
594 rajveer 1226 
      return result.success
3431 rajveer 1227 
    if result.ucx is not None:
594 rajveer 1228 
      raise result.ucx
1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1230 
 
1894 vikas 1231 
  def getAddressById(self, addressId):
1232 
    """
1233 
    Parameters:
1234 
     - addressId
1235 
    """
1236 
    self.send_getAddressById(addressId)
1237 
    return self.recv_getAddressById()
1238 
 
1239 
  def send_getAddressById(self, addressId):
1240 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1241 
    args = getAddressById_args()
1242 
    args.addressId = addressId
1243 
    args.write(self._oprot)
1244 
    self._oprot.writeMessageEnd()
1245 
    self._oprot.trans.flush()
1246 
 
1247 
  def recv_getAddressById(self, ):
1248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1249 
    if mtype == TMessageType.EXCEPTION:
1250 
      x = TApplicationException()
1251 
      x.read(self._iprot)
1252 
      self._iprot.readMessageEnd()
1253 
      raise x
1254 
    result = getAddressById_result()
1255 
    result.read(self._iprot)
1256 
    self._iprot.readMessageEnd()
3431 rajveer 1257 
    if result.success is not None:
1894 vikas 1258 
      return result.success
3431 rajveer 1259 
    if result.ucx is not None:
1894 vikas 1260 
      raise result.ucx
1261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1262 
 
594 rajveer 1263 
  def getDefaultAddressId(self, userId):
1264 
    """
1265 
    Parameters:
1266 
     - userId
1267 
    """
1268 
    self.send_getDefaultAddressId(userId)
1269 
    return self.recv_getDefaultAddressId()
1270 
 
1271 
  def send_getDefaultAddressId(self, userId):
1272 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1273 
    args = getDefaultAddressId_args()
1274 
    args.userId = userId
1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
1279 
  def recv_getDefaultAddressId(self, ):
1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
1286 
    result = getDefaultAddressId_result()
1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
3431 rajveer 1289 
    if result.success is not None:
594 rajveer 1290 
      return result.success
3431 rajveer 1291 
    if result.ucx is not None:
594 rajveer 1292 
      raise result.ucx
1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1294 
 
785 rajveer 1295 
  def getDefaultPincode(self, userId):
1296 
    """
1297 
    Parameters:
1298 
     - userId
1299 
    """
1300 
    self.send_getDefaultPincode(userId)
1301 
    return self.recv_getDefaultPincode()
1302 
 
1303 
  def send_getDefaultPincode(self, userId):
1304 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1305 
    args = getDefaultPincode_args()
1306 
    args.userId = userId
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_getDefaultPincode(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = getDefaultPincode_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
3431 rajveer 1321 
    if result.success is not None:
785 rajveer 1322 
      return result.success
3431 rajveer 1323 
    if result.ucx is not None:
785 rajveer 1324 
      raise result.ucx
1325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1326 
 
1274 varun.gupt 1327 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1328 
    """
1329 
    Parameters:
1330 
     - userId
1331 
     - replyTo
1332 
     - communicationType
1333 
     - orderId
1334 
     - airwaybillNo
1335 
     - productName
1336 
     - subject
1337 
     - message
1338 
    """
1339 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1340 
    return self.recv_saveUserCommunication()
1341 
 
1342 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1343 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1344 
    args = saveUserCommunication_args()
1345 
    args.userId = userId
1346 
    args.replyTo = replyTo
1347 
    args.communicationType = communicationType
1348 
    args.orderId = orderId
1349 
    args.airwaybillNo = airwaybillNo
1350 
    args.productName = productName
1351 
    args.subject = subject
1352 
    args.message = message
1353 
    args.write(self._oprot)
1354 
    self._oprot.writeMessageEnd()
1355 
    self._oprot.trans.flush()
1356 
 
1357 
  def recv_saveUserCommunication(self, ):
1358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1359 
    if mtype == TMessageType.EXCEPTION:
1360 
      x = TApplicationException()
1361 
      x.read(self._iprot)
1362 
      self._iprot.readMessageEnd()
1363 
      raise x
1364 
    result = saveUserCommunication_result()
1365 
    result.read(self._iprot)
1366 
    self._iprot.readMessageEnd()
3431 rajveer 1367 
    if result.success is not None:
1274 varun.gupt 1368 
      return result.success
3431 rajveer 1369 
    if result.ucx is not None:
1274 varun.gupt 1370 
      raise result.ucx
1371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1372 
 
1590 varun.gupt 1373 
  def getUserCommunicationById(self, id):
1374 
    """
1375 
    Parameters:
1376 
     - id
1377 
    """
1378 
    self.send_getUserCommunicationById(id)
1379 
    return self.recv_getUserCommunicationById()
1380 
 
1381 
  def send_getUserCommunicationById(self, id):
1382 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1383 
    args = getUserCommunicationById_args()
1384 
    args.id = id
1385 
    args.write(self._oprot)
1386 
    self._oprot.writeMessageEnd()
1387 
    self._oprot.trans.flush()
1388 
 
1389 
  def recv_getUserCommunicationById(self, ):
1390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1391 
    if mtype == TMessageType.EXCEPTION:
1392 
      x = TApplicationException()
1393 
      x.read(self._iprot)
1394 
      self._iprot.readMessageEnd()
1395 
      raise x
1396 
    result = getUserCommunicationById_result()
1397 
    result.read(self._iprot)
1398 
    self._iprot.readMessageEnd()
3431 rajveer 1399 
    if result.success is not None:
1590 varun.gupt 1400 
      return result.success
3431 rajveer 1401 
    if result.ucx is not None:
1590 varun.gupt 1402 
      raise result.ucx
1403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1404 
 
1405 
  def getUserCommunicationByUser(self, userId):
1406 
    """
1407 
    Parameters:
1408 
     - userId
1409 
    """
1410 
    self.send_getUserCommunicationByUser(userId)
1411 
    return self.recv_getUserCommunicationByUser()
1412 
 
1413 
  def send_getUserCommunicationByUser(self, userId):
1414 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1415 
    args = getUserCommunicationByUser_args()
1416 
    args.userId = userId
1417 
    args.write(self._oprot)
1418 
    self._oprot.writeMessageEnd()
1419 
    self._oprot.trans.flush()
1420 
 
1421 
  def recv_getUserCommunicationByUser(self, ):
1422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1423 
    if mtype == TMessageType.EXCEPTION:
1424 
      x = TApplicationException()
1425 
      x.read(self._iprot)
1426 
      self._iprot.readMessageEnd()
1427 
      raise x
1428 
    result = getUserCommunicationByUser_result()
1429 
    result.read(self._iprot)
1430 
    self._iprot.readMessageEnd()
3431 rajveer 1431 
    if result.success is not None:
1590 varun.gupt 1432 
      return result.success
3431 rajveer 1433 
    if result.ucx is not None:
1590 varun.gupt 1434 
      raise result.ucx
1435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1436 
 
1437 
  def getAllUserCommunications(self, ):
1438 
    self.send_getAllUserCommunications()
1439 
    return self.recv_getAllUserCommunications()
1440 
 
1441 
  def send_getAllUserCommunications(self, ):
1442 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1443 
    args = getAllUserCommunications_args()
1444 
    args.write(self._oprot)
1445 
    self._oprot.writeMessageEnd()
1446 
    self._oprot.trans.flush()
1447 
 
1448 
  def recv_getAllUserCommunications(self, ):
1449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1450 
    if mtype == TMessageType.EXCEPTION:
1451 
      x = TApplicationException()
1452 
      x.read(self._iprot)
1453 
      self._iprot.readMessageEnd()
1454 
      raise x
1455 
    result = getAllUserCommunications_result()
1456 
    result.read(self._iprot)
1457 
    self._iprot.readMessageEnd()
3431 rajveer 1458 
    if result.success is not None:
1590 varun.gupt 1459 
      return result.success
3431 rajveer 1460 
    if result.ucx is not None:
1590 varun.gupt 1461 
      raise result.ucx
1462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1463 
 
5407 amar.kumar 1464 
  def removeUserCommunication(self, id):
1465 
    """
1466 
    Parameters:
1467 
     - id
1468 
    """
1469 
    self.send_removeUserCommunication(id)
1470 
    self.recv_removeUserCommunication()
1471 
 
1472 
  def send_removeUserCommunication(self, id):
1473 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1474 
    args = removeUserCommunication_args()
1475 
    args.id = id
1476 
    args.write(self._oprot)
1477 
    self._oprot.writeMessageEnd()
1478 
    self._oprot.trans.flush()
1479 
 
1480 
  def recv_removeUserCommunication(self, ):
1481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1482 
    if mtype == TMessageType.EXCEPTION:
1483 
      x = TApplicationException()
1484 
      x.read(self._iprot)
1485 
      self._iprot.readMessageEnd()
1486 
      raise x
1487 
    result = removeUserCommunication_result()
1488 
    result.read(self._iprot)
1489 
    self._iprot.readMessageEnd()
1490 
    if result.ucx is not None:
1491 
      raise result.ucx
1492 
    return
1493 
 
1859 vikas 1494 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1495 
    """
1496 
    Parameters:
1497 
     - name
1859 vikas 1498 
     - addedOn
1845 vikas 1499 
    """
1859 vikas 1500 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1501 
    return self.recv_createMasterAffiliate()
1502 
 
1859 vikas 1503 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1504 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1505 
    args = createMasterAffiliate_args()
1506 
    args.name = name
1859 vikas 1507 
    args.addedOn = addedOn
1845 vikas 1508 
    args.write(self._oprot)
1509 
    self._oprot.writeMessageEnd()
1510 
    self._oprot.trans.flush()
1511 
 
1512 
  def recv_createMasterAffiliate(self, ):
1513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1514 
    if mtype == TMessageType.EXCEPTION:
1515 
      x = TApplicationException()
1516 
      x.read(self._iprot)
1517 
      self._iprot.readMessageEnd()
1518 
      raise x
1519 
    result = createMasterAffiliate_result()
1520 
    result.read(self._iprot)
1521 
    self._iprot.readMessageEnd()
3431 rajveer 1522 
    if result.success is not None:
1845 vikas 1523 
      return result.success
3431 rajveer 1524 
    if result.utx is not None:
1845 vikas 1525 
      raise result.utx
1526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1527 
 
1899 vikas 1528 
  def getAllMasterAffiliates(self, ):
1529 
    self.send_getAllMasterAffiliates()
1530 
    return self.recv_getAllMasterAffiliates()
1531 
 
1532 
  def send_getAllMasterAffiliates(self, ):
1533 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1534 
    args = getAllMasterAffiliates_args()
1535 
    args.write(self._oprot)
1536 
    self._oprot.writeMessageEnd()
1537 
    self._oprot.trans.flush()
1538 
 
1539 
  def recv_getAllMasterAffiliates(self, ):
1540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1541 
    if mtype == TMessageType.EXCEPTION:
1542 
      x = TApplicationException()
1543 
      x.read(self._iprot)
1544 
      self._iprot.readMessageEnd()
1545 
      raise x
1546 
    result = getAllMasterAffiliates_result()
1547 
    result.read(self._iprot)
1548 
    self._iprot.readMessageEnd()
3431 rajveer 1549 
    if result.success is not None:
1899 vikas 1550 
      return result.success
3431 rajveer 1551 
    if result.utx is not None:
1899 vikas 1552 
      raise result.utx
1553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1554 
 
1845 vikas 1555 
  def getMasterAffiliateById(self, id):
1556 
    """
1557 
    Parameters:
1558 
     - id
1559 
    """
1560 
    self.send_getMasterAffiliateById(id)
1561 
    return self.recv_getMasterAffiliateById()
1562 
 
1563 
  def send_getMasterAffiliateById(self, id):
1564 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1565 
    args = getMasterAffiliateById_args()
1566 
    args.id = id
1567 
    args.write(self._oprot)
1568 
    self._oprot.writeMessageEnd()
1569 
    self._oprot.trans.flush()
1570 
 
1571 
  def recv_getMasterAffiliateById(self, ):
1572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1573 
    if mtype == TMessageType.EXCEPTION:
1574 
      x = TApplicationException()
1575 
      x.read(self._iprot)
1576 
      self._iprot.readMessageEnd()
1577 
      raise x
1578 
    result = getMasterAffiliateById_result()
1579 
    result.read(self._iprot)
1580 
    self._iprot.readMessageEnd()
3431 rajveer 1581 
    if result.success is not None:
1845 vikas 1582 
      return result.success
3431 rajveer 1583 
    if result.utx is not None:
1845 vikas 1584 
      raise result.utx
1585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1586 
 
1587 
  def getMasterAffiliateByName(self, name):
1588 
    """
1589 
    Parameters:
1590 
     - name
1591 
    """
1592 
    self.send_getMasterAffiliateByName(name)
1593 
    return self.recv_getMasterAffiliateByName()
1594 
 
1595 
  def send_getMasterAffiliateByName(self, name):
1596 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1597 
    args = getMasterAffiliateByName_args()
1598 
    args.name = name
1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_getMasterAffiliateByName(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = getMasterAffiliateByName_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
3431 rajveer 1613 
    if result.success is not None:
1845 vikas 1614 
      return result.success
3431 rajveer 1615 
    if result.utx is not None:
1845 vikas 1616 
      raise result.utx
1617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1618 
 
1859 vikas 1619 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1620 
    """
1621 
    Parameters:
1622 
     - name
1623 
     - url
1624 
     - masterAffiliateId
1859 vikas 1625 
     - addedOn
1845 vikas 1626 
    """
1859 vikas 1627 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1628 
    return self.recv_createAffiliate()
1629 
 
1859 vikas 1630 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1631 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1632 
    args = createAffiliate_args()
1633 
    args.name = name
1634 
    args.url = url
1635 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1636 
    args.addedOn = addedOn
1845 vikas 1637 
    args.write(self._oprot)
1638 
    self._oprot.writeMessageEnd()
1639 
    self._oprot.trans.flush()
1640 
 
1641 
  def recv_createAffiliate(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 = createAffiliate_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, "createAffiliate failed: unknown result");
1656 
 
1657 
  def getAffiliateById(self, id):
1658 
    """
1659 
    Parameters:
1660 
     - id
1661 
    """
1662 
    self.send_getAffiliateById(id)
1663 
    return self.recv_getAffiliateById()
1664 
 
1665 
  def send_getAffiliateById(self, id):
1666 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1667 
    args = getAffiliateById_args()
1668 
    args.id = id
1669 
    args.write(self._oprot)
1670 
    self._oprot.writeMessageEnd()
1671 
    self._oprot.trans.flush()
1672 
 
1673 
  def recv_getAffiliateById(self, ):
1674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1675 
    if mtype == TMessageType.EXCEPTION:
1676 
      x = TApplicationException()
1677 
      x.read(self._iprot)
1678 
      self._iprot.readMessageEnd()
1679 
      raise x
1680 
    result = getAffiliateById_result()
1681 
    result.read(self._iprot)
1682 
    self._iprot.readMessageEnd()
3431 rajveer 1683 
    if result.success is not None:
1845 vikas 1684 
      return result.success
3431 rajveer 1685 
    if result.utx is not None:
1845 vikas 1686 
      raise result.utx
1687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1688 
 
1689 
  def getAffiliateByName(self, name):
1690 
    """
1691 
    Parameters:
1692 
     - name
1693 
    """
1694 
    self.send_getAffiliateByName(name)
1695 
    return self.recv_getAffiliateByName()
1696 
 
1697 
  def send_getAffiliateByName(self, name):
1698 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1699 
    args = getAffiliateByName_args()
1700 
    args.name = name
1701 
    args.write(self._oprot)
1702 
    self._oprot.writeMessageEnd()
1703 
    self._oprot.trans.flush()
1704 
 
1705 
  def recv_getAffiliateByName(self, ):
1706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1707 
    if mtype == TMessageType.EXCEPTION:
1708 
      x = TApplicationException()
1709 
      x.read(self._iprot)
1710 
      self._iprot.readMessageEnd()
1711 
      raise x
1712 
    result = getAffiliateByName_result()
1713 
    result.read(self._iprot)
1714 
    self._iprot.readMessageEnd()
3431 rajveer 1715 
    if result.success is not None:
1845 vikas 1716 
      return result.success
3431 rajveer 1717 
    if result.utx is not None:
1845 vikas 1718 
      raise result.utx
1719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1720 
 
1996 vikas 1721 
  def getTrackerById(self, id):
1845 vikas 1722 
    """
1723 
    Parameters:
1724 
     - id
1725 
    """
1996 vikas 1726 
    self.send_getTrackerById(id)
1845 vikas 1727 
    return self.recv_getTrackerById()
1728 
 
1996 vikas 1729 
  def send_getTrackerById(self, id):
1845 vikas 1730 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1731 
    args = getTrackerById_args()
1996 vikas 1732 
    args.id = id
1845 vikas 1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getTrackerById(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getTrackerById_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
1845 vikas 1748 
      return result.success
3431 rajveer 1749 
    if result.utx is not None:
1845 vikas 1750 
      raise result.utx
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1752 
 
1996 vikas 1753 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1754 
    """
1755 
    Parameters:
1996 vikas 1756 
     - id
1845 vikas 1757 
    """
1996 vikas 1758 
    self.send_getAffiliatesByMasterAffiliate(id)
1759 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1760 
 
1996 vikas 1761 
  def send_getAffiliatesByMasterAffiliate(self, id):
1762 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1763 
    args = getAffiliatesByMasterAffiliate_args()
1764 
    args.id = id
1845 vikas 1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1996 vikas 1769 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1996 vikas 1776 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
3431 rajveer 1779 
    if result.success is not None:
1845 vikas 1780 
      return result.success
3431 rajveer 1781 
    if result.utx is not None:
1845 vikas 1782 
      raise result.utx
1996 vikas 1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1784 
 
1996 vikas 1785 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1786 
    """
1787 
    Parameters:
1996 vikas 1788 
     - affiliateId
1845 vikas 1789 
     - userId
1790 
     - event
1791 
     - url
1792 
     - data
1859 vikas 1793 
     - addedOn
1845 vikas 1794 
    """
1996 vikas 1795 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1796 
    return self.recv_addTrackLog()
1797 
 
1996 vikas 1798 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1799 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1800 
    args = addTrackLog_args()
1996 vikas 1801 
    args.affiliateId = affiliateId
1845 vikas 1802 
    args.userId = userId
1803 
    args.event = event
1804 
    args.url = url
1805 
    args.data = data
1859 vikas 1806 
    args.addedOn = addedOn
1845 vikas 1807 
    args.write(self._oprot)
1808 
    self._oprot.writeMessageEnd()
1809 
    self._oprot.trans.flush()
1810 
 
1811 
  def recv_addTrackLog(self, ):
1812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1813 
    if mtype == TMessageType.EXCEPTION:
1814 
      x = TApplicationException()
1815 
      x.read(self._iprot)
1816 
      self._iprot.readMessageEnd()
1817 
      raise x
1818 
    result = addTrackLog_result()
1819 
    result.read(self._iprot)
1820 
    self._iprot.readMessageEnd()
3431 rajveer 1821 
    if result.success is not None:
1845 vikas 1822 
      return result.success
3431 rajveer 1823 
    if result.utx is not None:
1845 vikas 1824 
      raise result.utx
1825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1826 
 
1827 
  def getTrackLogById(self, id):
1828 
    """
1829 
    Parameters:
1830 
     - id
1831 
    """
1832 
    self.send_getTrackLogById(id)
1833 
    return self.recv_getTrackLogById()
1834 
 
1835 
  def send_getTrackLogById(self, id):
1836 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1837 
    args = getTrackLogById_args()
1838 
    args.id = id
1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
1843 
  def recv_getTrackLogById(self, ):
1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
1850 
    result = getTrackLogById_result()
1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
3431 rajveer 1853 
    if result.success is not None:
1845 vikas 1854 
      return result.success
3431 rajveer 1855 
    if result.utx is not None:
1845 vikas 1856 
      raise result.utx
1857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1858 
 
3293 vikas 1859 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1860 
    """
1861 
    Parameters:
1996 vikas 1862 
     - affiliateId
3293 vikas 1863 
     - startDate
1864 
     - endDate
1845 vikas 1865 
    """
3293 vikas 1866 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1867 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1868 
 
3293 vikas 1869 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1870 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1871 
    args = getTrackLogsByAffiliate_args()
1872 
    args.affiliateId = affiliateId
3293 vikas 1873 
    args.startDate = startDate
1874 
    args.endDate = endDate
1845 vikas 1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1996 vikas 1879 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1996 vikas 1886 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
3431 rajveer 1889 
    if result.success is not None:
1845 vikas 1890 
      return result.success
3431 rajveer 1891 
    if result.utx is not None:
1845 vikas 1892 
      raise result.utx
1996 vikas 1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1894 
 
1895 
  def getTrackLogsByUser(self, userId):
1896 
    """
1897 
    Parameters:
1898 
     - userId
1899 
    """
1900 
    self.send_getTrackLogsByUser(userId)
1901 
    return self.recv_getTrackLogsByUser()
1902 
 
1903 
  def send_getTrackLogsByUser(self, userId):
1904 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1905 
    args = getTrackLogsByUser_args()
1906 
    args.userId = userId
1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
1911 
  def recv_getTrackLogsByUser(self, ):
1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
1918 
    result = getTrackLogsByUser_result()
1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
3431 rajveer 1921 
    if result.success is not None:
1845 vikas 1922 
      return result.success
3431 rajveer 1923 
    if result.utx is not None:
1845 vikas 1924 
      raise result.utx
1925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1926 
 
1996 vikas 1927 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1928 
    """
1929 
    Parameters:
1930 
     - userId
1931 
     - event
1932 
     - url
1933 
    """
1996 vikas 1934 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1935 
    return self.recv_getTrackLogs()
1936 
 
1996 vikas 1937 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1938 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1939 
    args = getTrackLogs_args()
1940 
    args.userId = userId
1941 
    args.event = event
1942 
    args.url = url
1943 
    args.write(self._oprot)
1944 
    self._oprot.writeMessageEnd()
1945 
    self._oprot.trans.flush()
1946 
 
1947 
  def recv_getTrackLogs(self, ):
1948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1949 
    if mtype == TMessageType.EXCEPTION:
1950 
      x = TApplicationException()
1951 
      x.read(self._iprot)
1952 
      self._iprot.readMessageEnd()
1953 
      raise x
1954 
    result = getTrackLogs_result()
1955 
    result.read(self._iprot)
1956 
    self._iprot.readMessageEnd()
3431 rajveer 1957 
    if result.success is not None:
1845 vikas 1958 
      return result.success
3431 rajveer 1959 
    if result.utx is not None:
1845 vikas 1960 
      raise result.utx
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1962 
 
559 chandransh 1963 
  def getCurrentCart(self, userId):
94 ashish 1964 
    """
1965 
    Parameters:
559 chandransh 1966 
     - userId
94 ashish 1967 
    """
559 chandransh 1968 
    self.send_getCurrentCart(userId)
1969 
    return self.recv_getCurrentCart()
94 ashish 1970 
 
559 chandransh 1971 
  def send_getCurrentCart(self, userId):
1972 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1973 
    args = getCurrentCart_args()
1974 
    args.userId = userId
94 ashish 1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
559 chandransh 1979 
  def recv_getCurrentCart(self, ):
94 ashish 1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
559 chandransh 1986 
    result = getCurrentCart_result()
94 ashish 1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
3431 rajveer 1989 
    if result.success is not None:
94 ashish 1990 
      return result.success
3431 rajveer 1991 
    if result.scx is not None:
559 chandransh 1992 
      raise result.scx
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1994 
 
559 chandransh 1995 
  def getCart(self, cartId):
94 ashish 1996 
    """
1997 
    Parameters:
559 chandransh 1998 
     - cartId
94 ashish 1999 
    """
559 chandransh 2000 
    self.send_getCart(cartId)
2001 
    return self.recv_getCart()
94 ashish 2002 
 
559 chandransh 2003 
  def send_getCart(self, cartId):
2004 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2005 
    args = getCart_args()
2006 
    args.cartId = cartId
94 ashish 2007 
    args.write(self._oprot)
2008 
    self._oprot.writeMessageEnd()
2009 
    self._oprot.trans.flush()
2010 
 
559 chandransh 2011 
  def recv_getCart(self, ):
94 ashish 2012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2013 
    if mtype == TMessageType.EXCEPTION:
2014 
      x = TApplicationException()
2015 
      x.read(self._iprot)
2016 
      self._iprot.readMessageEnd()
2017 
      raise x
559 chandransh 2018 
    result = getCart_result()
94 ashish 2019 
    result.read(self._iprot)
2020 
    self._iprot.readMessageEnd()
3431 rajveer 2021 
    if result.success is not None:
94 ashish 2022 
      return result.success
3431 rajveer 2023 
    if result.scx is not None:
559 chandransh 2024 
      raise result.scx
2025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2026 
 
559 chandransh 2027 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2028 
    """
2029 
    Parameters:
559 chandransh 2030 
     - from_time
2031 
     - to_time
2032 
     - status
94 ashish 2033 
    """
559 chandransh 2034 
    self.send_getCartsByTime(from_time, to_time, status)
2035 
    return self.recv_getCartsByTime()
94 ashish 2036 
 
559 chandransh 2037 
  def send_getCartsByTime(self, from_time, to_time, status):
2038 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2039 
    args = getCartsByTime_args()
2040 
    args.from_time = from_time
2041 
    args.to_time = to_time
2042 
    args.status = status
94 ashish 2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
559 chandransh 2047 
  def recv_getCartsByTime(self, ):
94 ashish 2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
559 chandransh 2054 
    result = getCartsByTime_result()
94 ashish 2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
3431 rajveer 2057 
    if result.success is not None:
94 ashish 2058 
      return result.success
3431 rajveer 2059 
    if result.scx is not None:
559 chandransh 2060 
      raise result.scx
2061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2062 
 
3557 rajveer 2063 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2064 
    """
2065 
    Parameters:
2066 
     - cartId
2067 
     - itemId
2068 
     - quantity
3557 rajveer 2069 
     - sourceId
559 chandransh 2070 
    """
3557 rajveer 2071 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2072 
    return self.recv_addItemToCart()
559 chandransh 2073 
 
3557 rajveer 2074 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2075 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2076 
    args = addItemToCart_args()
2077 
    args.cartId = cartId
2078 
    args.itemId = itemId
2079 
    args.quantity = quantity
3557 rajveer 2080 
    args.sourceId = sourceId
559 chandransh 2081 
    args.write(self._oprot)
2082 
    self._oprot.writeMessageEnd()
2083 
    self._oprot.trans.flush()
2084 
 
2085 
  def recv_addItemToCart(self, ):
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
2092 
    result = addItemToCart_result()
2093 
    result.read(self._iprot)
2094 
    self._iprot.readMessageEnd()
3431 rajveer 2095 
    if result.success is not None:
2035 rajveer 2096 
      return result.success
3431 rajveer 2097 
    if result.scx is not None:
559 chandransh 2098 
      raise result.scx
2035 rajveer 2099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2100 
 
2101 
  def deleteItemFromCart(self, cartId, itemId):
2102 
    """
2103 
    Parameters:
2104 
     - cartId
2105 
     - itemId
2106 
    """
2107 
    self.send_deleteItemFromCart(cartId, itemId)
2108 
    self.recv_deleteItemFromCart()
2109 
 
2110 
  def send_deleteItemFromCart(self, cartId, itemId):
2111 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2112 
    args = deleteItemFromCart_args()
2113 
    args.cartId = cartId
2114 
    args.itemId = itemId
2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
2119 
  def recv_deleteItemFromCart(self, ):
2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
2126 
    result = deleteItemFromCart_result()
2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.scx is not None:
559 chandransh 2130 
      raise result.scx
2131 
    return
2132 
 
2133 
  def addAddressToCart(self, cartId, addressId):
2134 
    """
2135 
    Parameters:
2136 
     - cartId
2137 
     - addressId
2138 
    """
2139 
    self.send_addAddressToCart(cartId, addressId)
2140 
    self.recv_addAddressToCart()
2141 
 
2142 
  def send_addAddressToCart(self, cartId, addressId):
2143 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2144 
    args = addAddressToCart_args()
2145 
    args.cartId = cartId
2146 
    args.addressId = addressId
2147 
    args.write(self._oprot)
2148 
    self._oprot.writeMessageEnd()
2149 
    self._oprot.trans.flush()
2150 
 
2151 
  def recv_addAddressToCart(self, ):
2152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2153 
    if mtype == TMessageType.EXCEPTION:
2154 
      x = TApplicationException()
2155 
      x.read(self._iprot)
2156 
      self._iprot.readMessageEnd()
2157 
      raise x
2158 
    result = addAddressToCart_result()
2159 
    result.read(self._iprot)
2160 
    self._iprot.readMessageEnd()
3431 rajveer 2161 
    if result.scx is not None:
575 chandransh 2162 
      raise result.scx
559 chandransh 2163 
    return
2164 
 
5553 rajveer 2165 
  def addStoreToCart(self, cartId, storeId):
2166 
    """
2167 
    Parameters:
2168 
     - cartId
2169 
     - storeId
2170 
    """
2171 
    self.send_addStoreToCart(cartId, storeId)
2172 
    self.recv_addStoreToCart()
2173 
 
2174 
  def send_addStoreToCart(self, cartId, storeId):
2175 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2176 
    args = addStoreToCart_args()
2177 
    args.cartId = cartId
2178 
    args.storeId = storeId
2179 
    args.write(self._oprot)
2180 
    self._oprot.writeMessageEnd()
2181 
    self._oprot.trans.flush()
2182 
 
2183 
  def recv_addStoreToCart(self, ):
2184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2185 
    if mtype == TMessageType.EXCEPTION:
2186 
      x = TApplicationException()
2187 
      x.read(self._iprot)
2188 
      self._iprot.readMessageEnd()
2189 
      raise x
2190 
    result = addStoreToCart_result()
2191 
    result.read(self._iprot)
2192 
    self._iprot.readMessageEnd()
2193 
    if result.scx is not None:
2194 
      raise result.scx
2195 
    return
2196 
 
6922 anupam.sin 2197 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2198 
    """
2199 
    Parameters:
6922 anupam.sin 2200 
     - cart
1976 varun.gupt 2201 
     - couponCode
2202 
    """
6922 anupam.sin 2203 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2204 
    self.recv_applyCouponToCart()
2205 
 
6922 anupam.sin 2206 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2207 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2208 
    args = applyCouponToCart_args()
6922 anupam.sin 2209 
    args.cart = cart
1976 varun.gupt 2210 
    args.couponCode = couponCode
2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
2215 
  def recv_applyCouponToCart(self, ):
2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
2222 
    result = applyCouponToCart_result()
2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
3431 rajveer 2225 
    if result.scx is not None:
1976 varun.gupt 2226 
      raise result.scx
2227 
    return
2228 
 
2229 
  def removeCoupon(self, cartId):
2230 
    """
2231 
    Parameters:
2232 
     - cartId
2233 
    """
2234 
    self.send_removeCoupon(cartId)
2235 
    self.recv_removeCoupon()
2236 
 
2237 
  def send_removeCoupon(self, cartId):
2238 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2239 
    args = removeCoupon_args()
2240 
    args.cartId = cartId
2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
2245 
  def recv_removeCoupon(self, ):
2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
2252 
    result = removeCoupon_result()
2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
3431 rajveer 2255 
    if result.scx is not None:
1976 varun.gupt 2256 
      raise result.scx
2257 
    return
2258 
 
3554 varun.gupt 2259 
  def deleteDiscountsFromCart(self, cartId):
2260 
    """
2261 
    Deletes all the discounts associated with the cart
2262 
 
2263 
    Parameters:
2264 
     - cartId
2265 
    """
2266 
    self.send_deleteDiscountsFromCart(cartId)
2267 
    self.recv_deleteDiscountsFromCart()
2268 
 
2269 
  def send_deleteDiscountsFromCart(self, cartId):
2270 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2271 
    args = deleteDiscountsFromCart_args()
2272 
    args.cartId = cartId
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_deleteDiscountsFromCart(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = deleteDiscountsFromCart_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.scx is not None:
2288 
      raise result.scx
2289 
    return
2290 
 
2291 
  def saveDiscounts(self, discounts):
2292 
    """
2293 
    Accepts a list of thrift objects of Discount type and saves them
2294 
 
2295 
    Parameters:
2296 
     - discounts
2297 
    """
2298 
    self.send_saveDiscounts(discounts)
2299 
    self.recv_saveDiscounts()
2300 
 
2301 
  def send_saveDiscounts(self, discounts):
2302 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2303 
    args = saveDiscounts_args()
2304 
    args.discounts = discounts
2305 
    args.write(self._oprot)
2306 
    self._oprot.writeMessageEnd()
2307 
    self._oprot.trans.flush()
2308 
 
2309 
  def recv_saveDiscounts(self, ):
2310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2311 
    if mtype == TMessageType.EXCEPTION:
2312 
      x = TApplicationException()
2313 
      x.read(self._iprot)
2314 
      self._iprot.readMessageEnd()
2315 
      raise x
2316 
    result = saveDiscounts_result()
2317 
    result.read(self._iprot)
2318 
    self._iprot.readMessageEnd()
2319 
    if result.scx is not None:
2320 
      raise result.scx
2321 
    return
2322 
 
11526 amit.gupta 2323 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2324 
    """
690 chandransh 2325 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2326 
 
559 chandransh 2327 
    Parameters:
2328 
     - cartId
2815 vikas 2329 
     - sessionSource
2330 
     - sessionStartTime
3858 vikas 2331 
     - firstSource
2332 
     - firstSourceTime
5326 rajveer 2333 
     - userId
6389 rajveer 2334 
     - schemeId
11526 amit.gupta 2335 
     - orderSource
559 chandransh 2336 
    """
11526 amit.gupta 2337 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2338 
    return self.recv_createOrders()
559 chandransh 2339 
 
11526 amit.gupta 2340 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2341 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2342 
    args = createOrders_args()
559 chandransh 2343 
    args.cartId = cartId
2815 vikas 2344 
    args.sessionSource = sessionSource
2345 
    args.sessionStartTime = sessionStartTime
3858 vikas 2346 
    args.firstSource = firstSource
2347 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2348 
    args.userId = userId
6389 rajveer 2349 
    args.schemeId = schemeId
11526 amit.gupta 2350 
    args.orderSource = orderSource
559 chandransh 2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
690 chandransh 2355 
  def recv_createOrders(self, ):
559 chandransh 2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
690 chandransh 2362 
    result = createOrders_result()
559 chandransh 2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
3431 rajveer 2365 
    if result.success is not None:
130 ashish 2366 
      return result.success
3431 rajveer 2367 
    if result.scx is not None:
559 chandransh 2368 
      raise result.scx
690 chandransh 2369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2370 
 
3557 rajveer 2371 
  def validateCart(self, cartId, sourceId):
130 ashish 2372 
    """
690 chandransh 2373 
    Validates that:
2374 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2375 
    2. All of the lines in the cart are active items.
690 chandransh 2376 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2377 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2378 
 
130 ashish 2379 
    Parameters:
559 chandransh 2380 
     - cartId
3557 rajveer 2381 
     - sourceId
130 ashish 2382 
    """
3557 rajveer 2383 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2384 
    return self.recv_validateCart()
130 ashish 2385 
 
3557 rajveer 2386 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2387 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2388 
    args = validateCart_args()
2389 
    args.cartId = cartId
3557 rajveer 2390 
    args.sourceId = sourceId
130 ashish 2391 
    args.write(self._oprot)
2392 
    self._oprot.writeMessageEnd()
2393 
    self._oprot.trans.flush()
2394 
 
559 chandransh 2395 
  def recv_validateCart(self, ):
130 ashish 2396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2397 
    if mtype == TMessageType.EXCEPTION:
2398 
      x = TApplicationException()
2399 
      x.read(self._iprot)
2400 
      self._iprot.readMessageEnd()
2401 
      raise x
559 chandransh 2402 
    result = validateCart_result()
130 ashish 2403 
    result.read(self._iprot)
2404 
    self._iprot.readMessageEnd()
3431 rajveer 2405 
    if result.success is not None:
130 ashish 2406 
      return result.success
3431 rajveer 2407 
    if result.scex is not None:
575 chandransh 2408 
      raise result.scex
559 chandransh 2409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2410 
 
690 chandransh 2411 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2412 
    """
690 chandransh 2413 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2414 
 
575 chandransh 2415 
    Parameters:
690 chandransh 2416 
     - fromCartId
2417 
     - toCartId
2418 
    """
2419 
    self.send_mergeCart(fromCartId, toCartId)
2420 
    self.recv_mergeCart()
2421 
 
2422 
  def send_mergeCart(self, fromCartId, toCartId):
2423 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2424 
    args = mergeCart_args()
2425 
    args.fromCartId = fromCartId
2426 
    args.toCartId = toCartId
2427 
    args.write(self._oprot)
2428 
    self._oprot.writeMessageEnd()
2429 
    self._oprot.trans.flush()
2430 
 
2431 
  def recv_mergeCart(self, ):
2432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2433 
    if mtype == TMessageType.EXCEPTION:
2434 
      x = TApplicationException()
2435 
      x.read(self._iprot)
2436 
      self._iprot.readMessageEnd()
2437 
      raise x
2438 
    result = mergeCart_result()
2439 
    result.read(self._iprot)
2440 
    self._iprot.readMessageEnd()
2441 
    return
2442 
 
2443 
  def checkOut(self, cartId):
2444 
    """
2445 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2446 
 
690 chandransh 2447 
    Parameters:
575 chandransh 2448 
     - cartId
2449 
    """
690 chandransh 2450 
    self.send_checkOut(cartId)
2451 
    return self.recv_checkOut()
575 chandransh 2452 
 
690 chandransh 2453 
  def send_checkOut(self, cartId):
2454 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2455 
    args = checkOut_args()
575 chandransh 2456 
    args.cartId = cartId
2457 
    args.write(self._oprot)
2458 
    self._oprot.writeMessageEnd()
2459 
    self._oprot.trans.flush()
2460 
 
690 chandransh 2461 
  def recv_checkOut(self, ):
575 chandransh 2462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2463 
    if mtype == TMessageType.EXCEPTION:
2464 
      x = TApplicationException()
2465 
      x.read(self._iprot)
2466 
      self._iprot.readMessageEnd()
2467 
      raise x
690 chandransh 2468 
    result = checkOut_result()
575 chandransh 2469 
    result.read(self._iprot)
2470 
    self._iprot.readMessageEnd()
3431 rajveer 2471 
    if result.success is not None:
575 chandransh 2472 
      return result.success
3431 rajveer 2473 
    if result.scex is not None:
575 chandransh 2474 
      raise result.scex
690 chandransh 2475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2476 
 
690 chandransh 2477 
  def resetCart(self, cartId, items):
559 chandransh 2478 
    """
690 chandransh 2479 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2480 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2481 
 
559 chandransh 2482 
    Parameters:
690 chandransh 2483 
     - cartId
2484 
     - items
559 chandransh 2485 
    """
690 chandransh 2486 
    self.send_resetCart(cartId, items)
2487 
    return self.recv_resetCart()
130 ashish 2488 
 
690 chandransh 2489 
  def send_resetCart(self, cartId, items):
2490 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2491 
    args = resetCart_args()
2492 
    args.cartId = cartId
2493 
    args.items = items
559 chandransh 2494 
    args.write(self._oprot)
2495 
    self._oprot.writeMessageEnd()
2496 
    self._oprot.trans.flush()
2497 
 
690 chandransh 2498 
  def recv_resetCart(self, ):
559 chandransh 2499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2500 
    if mtype == TMessageType.EXCEPTION:
2501 
      x = TApplicationException()
2502 
      x.read(self._iprot)
2503 
      self._iprot.readMessageEnd()
2504 
      raise x
690 chandransh 2505 
    result = resetCart_result()
559 chandransh 2506 
    result.read(self._iprot)
2507 
    self._iprot.readMessageEnd()
3431 rajveer 2508 
    if result.success is not None:
690 chandransh 2509 
      return result.success
3431 rajveer 2510 
    if result.scex is not None:
690 chandransh 2511 
      raise result.scex
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2513 
 
2981 rajveer 2514 
  def getUserCount(self, userType):
559 chandransh 2515 
    """
2981 rajveer 2516 
    Returns number of registered users.
2517 
    If userType = null, then it returns count of all users, including anonymous
2518 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2519 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2520 
 
559 chandransh 2521 
    Parameters:
2981 rajveer 2522 
     - userType
559 chandransh 2523 
    """
2981 rajveer 2524 
    self.send_getUserCount(userType)
2525 
    return self.recv_getUserCount()
559 chandransh 2526 
 
2981 rajveer 2527 
  def send_getUserCount(self, userType):
2528 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2529 
    args = getUserCount_args()
2530 
    args.userType = userType
559 chandransh 2531 
    args.write(self._oprot)
2532 
    self._oprot.writeMessageEnd()
2533 
    self._oprot.trans.flush()
2534 
 
2981 rajveer 2535 
  def recv_getUserCount(self, ):
559 chandransh 2536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2537 
    if mtype == TMessageType.EXCEPTION:
2538 
      x = TApplicationException()
2539 
      x.read(self._iprot)
2540 
      self._iprot.readMessageEnd()
2541 
      raise x
2981 rajveer 2542 
    result = getUserCount_result()
559 chandransh 2543 
    result.read(self._iprot)
2544 
    self._iprot.readMessageEnd()
3431 rajveer 2545 
    if result.success is not None:
559 chandransh 2546 
      return result.success
2981 rajveer 2547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2548 
 
2981 rajveer 2549 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2550 
    """
2981 rajveer 2551 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2552 
    If any of startDate or endDate is -1, then that filter is ignored.
2553 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2554 
 
2555 
 
559 chandransh 2556 
    Parameters:
2981 rajveer 2557 
     - userType
2558 
     - startDate
2559 
     - endDate
559 chandransh 2560 
    """
2981 rajveer 2561 
    self.send_getAllUsers(userType, startDate, endDate)
2562 
    return self.recv_getAllUsers()
559 chandransh 2563 
 
2981 rajveer 2564 
  def send_getAllUsers(self, userType, startDate, endDate):
2565 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2566 
    args = getAllUsers_args()
2567 
    args.userType = userType
2568 
    args.startDate = startDate
2569 
    args.endDate = endDate
559 chandransh 2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
2981 rajveer 2574 
  def recv_getAllUsers(self, ):
559 chandransh 2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
2981 rajveer 2581 
    result = getAllUsers_result()
559 chandransh 2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
3431 rajveer 2584 
    if result.success is not None:
559 chandransh 2585 
      return result.success
2981 rajveer 2586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2587 
 
2981 rajveer 2588 
  def getMyResearchItems(self, userId):
559 chandransh 2589 
    """
2981 rajveer 2590 
    Returns list of item ids in myresearch for the user
3431 rajveer 2591 
 
559 chandransh 2592 
    Parameters:
772 rajveer 2593 
     - userId
559 chandransh 2594 
    """
2981 rajveer 2595 
    self.send_getMyResearchItems(userId)
2596 
    return self.recv_getMyResearchItems()
559 chandransh 2597 
 
2981 rajveer 2598 
  def send_getMyResearchItems(self, userId):
2599 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2600 
    args = getMyResearchItems_args()
772 rajveer 2601 
    args.userId = userId
559 chandransh 2602 
    args.write(self._oprot)
2603 
    self._oprot.writeMessageEnd()
2604 
    self._oprot.trans.flush()
2605 
 
2981 rajveer 2606 
  def recv_getMyResearchItems(self, ):
559 chandransh 2607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2608 
    if mtype == TMessageType.EXCEPTION:
2609 
      x = TApplicationException()
2610 
      x.read(self._iprot)
2611 
      self._iprot.readMessageEnd()
2612 
      raise x
2981 rajveer 2613 
    result = getMyResearchItems_result()
559 chandransh 2614 
    result.read(self._iprot)
2615 
    self._iprot.readMessageEnd()
3431 rajveer 2616 
    if result.success is not None:
559 chandransh 2617 
      return result.success
3431 rajveer 2618 
    if result.scx is not None:
559 chandransh 2619 
      raise result.scx
2981 rajveer 2620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2621 
 
2981 rajveer 2622 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2623 
    """
2981 rajveer 2624 
    add item to my research for a user
3431 rajveer 2625 
 
559 chandransh 2626 
    Parameters:
2981 rajveer 2627 
     - userId
2628 
     - itemId
559 chandransh 2629 
    """
2981 rajveer 2630 
    self.send_updateMyResearch(userId, itemId)
2631 
    return self.recv_updateMyResearch()
559 chandransh 2632 
 
2981 rajveer 2633 
  def send_updateMyResearch(self, userId, itemId):
2634 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2635 
    args = updateMyResearch_args()
2636 
    args.userId = userId
2637 
    args.itemId = itemId
559 chandransh 2638 
    args.write(self._oprot)
2639 
    self._oprot.writeMessageEnd()
2640 
    self._oprot.trans.flush()
2641 
 
2981 rajveer 2642 
  def recv_updateMyResearch(self, ):
559 chandransh 2643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2644 
    if mtype == TMessageType.EXCEPTION:
2645 
      x = TApplicationException()
2646 
      x.read(self._iprot)
2647 
      self._iprot.readMessageEnd()
2648 
      raise x
2981 rajveer 2649 
    result = updateMyResearch_result()
559 chandransh 2650 
    result.read(self._iprot)
2651 
    self._iprot.readMessageEnd()
3431 rajveer 2652 
    if result.success is not None:
2981 rajveer 2653 
      return result.success
3431 rajveer 2654 
    if result.scx is not None:
2981 rajveer 2655 
      raise result.scx
2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2657 
 
2981 rajveer 2658 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2659 
    """
2981 rajveer 2660 
    delete item from my research for a user
3431 rajveer 2661 
 
1596 ankur.sing 2662 
    Parameters:
2981 rajveer 2663 
     - userId
2664 
     - itemId
1596 ankur.sing 2665 
    """
2981 rajveer 2666 
    self.send_deleteItemFromMyResearch(userId, itemId)
2667 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2668 
 
2981 rajveer 2669 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2670 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2671 
    args = deleteItemFromMyResearch_args()
2672 
    args.userId = userId
2673 
    args.itemId = itemId
1596 ankur.sing 2674 
    args.write(self._oprot)
2675 
    self._oprot.writeMessageEnd()
2676 
    self._oprot.trans.flush()
2677 
 
2981 rajveer 2678 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2680 
    if mtype == TMessageType.EXCEPTION:
2681 
      x = TApplicationException()
2682 
      x.read(self._iprot)
2683 
      self._iprot.readMessageEnd()
2684 
      raise x
2981 rajveer 2685 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2686 
    result.read(self._iprot)
2687 
    self._iprot.readMessageEnd()
3431 rajveer 2688 
    if result.scx is not None:
2981 rajveer 2689 
      raise result.scx
2690 
    return
1596 ankur.sing 2691 
 
2981 rajveer 2692 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2693 
    """
2981 rajveer 2694 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2695 
 
1673 ankur.sing 2696 
    Parameters:
2981 rajveer 2697 
     - userId
1673 ankur.sing 2698 
    """
2981 rajveer 2699 
    self.send_getBrowseHistoryItems(userId)
2700 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2701 
 
2981 rajveer 2702 
  def send_getBrowseHistoryItems(self, userId):
2703 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2704 
    args = getBrowseHistoryItems_args()
2705 
    args.userId = userId
1673 ankur.sing 2706 
    args.write(self._oprot)
2707 
    self._oprot.writeMessageEnd()
2708 
    self._oprot.trans.flush()
2709 
 
2981 rajveer 2710 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2712 
    if mtype == TMessageType.EXCEPTION:
2713 
      x = TApplicationException()
2714 
      x.read(self._iprot)
2715 
      self._iprot.readMessageEnd()
2716 
      raise x
2981 rajveer 2717 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2718 
    result.read(self._iprot)
2719 
    self._iprot.readMessageEnd()
3431 rajveer 2720 
    if result.success is not None:
1673 ankur.sing 2721 
      return result.success
3431 rajveer 2722 
    if result.scx is not None:
2981 rajveer 2723 
      raise result.scx
2724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2725 
 
2981 rajveer 2726 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2727 
    """
2981 rajveer 2728 
    add item to browse history for a user
3431 rajveer 2729 
 
2642 varun.gupt 2730 
    Parameters:
2981 rajveer 2731 
     - userId
2732 
     - itemId
2642 varun.gupt 2733 
    """
2981 rajveer 2734 
    self.send_updateBrowseHistory(userId, itemId)
2735 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2736 
 
2981 rajveer 2737 
  def send_updateBrowseHistory(self, userId, itemId):
2738 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2739 
    args = updateBrowseHistory_args()
2740 
    args.userId = userId
2741 
    args.itemId = itemId
2642 varun.gupt 2742 
    args.write(self._oprot)
2743 
    self._oprot.writeMessageEnd()
2744 
    self._oprot.trans.flush()
2745 
 
2981 rajveer 2746 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2748 
    if mtype == TMessageType.EXCEPTION:
2749 
      x = TApplicationException()
2750 
      x.read(self._iprot)
2751 
      self._iprot.readMessageEnd()
2752 
      raise x
2981 rajveer 2753 
    result = updateBrowseHistory_result()
2642 varun.gupt 2754 
    result.read(self._iprot)
2755 
    self._iprot.readMessageEnd()
2756 
    return
2757 
 
3385 varun.gupt 2758 
  def getCartsWithCouponCount(self, couponCode):
2759 
    """
2760 
    Returns count of Carts with given coupon applied
3431 rajveer 2761 
 
3385 varun.gupt 2762 
    Parameters:
2763 
     - couponCode
2764 
    """
2765 
    self.send_getCartsWithCouponCount(couponCode)
2766 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2767 
 
3385 varun.gupt 2768 
  def send_getCartsWithCouponCount(self, couponCode):
2769 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2770 
    args = getCartsWithCouponCount_args()
2771 
    args.couponCode = couponCode
2772 
    args.write(self._oprot)
2773 
    self._oprot.writeMessageEnd()
2774 
    self._oprot.trans.flush()
2775 
 
2776 
  def recv_getCartsWithCouponCount(self, ):
2777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2778 
    if mtype == TMessageType.EXCEPTION:
2779 
      x = TApplicationException()
2780 
      x.read(self._iprot)
2781 
      self._iprot.readMessageEnd()
2782 
      raise x
2783 
    result = getCartsWithCouponCount_result()
2784 
    result.read(self._iprot)
2785 
    self._iprot.readMessageEnd()
3431 rajveer 2786 
    if result.success is not None:
3385 varun.gupt 2787 
      return result.success
2788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2789 
 
3499 mandeep.dh 2790 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2791 
    """
2792 
    Updates COD trust level of a user
3385 varun.gupt 2793 
 
3499 mandeep.dh 2794 
    Parameters:
2795 
     - userId
2796 
     - trustLevelDelta
2797 
    """
2798 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2799 
 
2800 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2801 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2802 
    args = increaseTrustLevel_args()
2803 
    args.userId = userId
2804 
    args.trustLevelDelta = trustLevelDelta
2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
5407 amar.kumar 2808 
  def getTrustLevel(self, userId):
2809 
    """
2810 
    Get trust level of a user
2811 
 
2812 
    Parameters:
2813 
     - userId
2814 
    """
2815 
    self.send_getTrustLevel(userId)
2816 
    return self.recv_getTrustLevel()
2817 
 
2818 
  def send_getTrustLevel(self, userId):
2819 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2820 
    args = getTrustLevel_args()
2821 
    args.userId = userId
2822 
    args.write(self._oprot)
2823 
    self._oprot.writeMessageEnd()
2824 
    self._oprot.trans.flush()
2825 
 
2826 
  def recv_getTrustLevel(self, ):
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
2833 
    result = getTrustLevel_result()
2834 
    result.read(self._iprot)
2835 
    self._iprot.readMessageEnd()
2836 
    if result.success is not None:
2837 
      return result.success
2838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2839 
 
4668 varun.gupt 2840 
  def showCODOption(self, cartId, sourceId, pincode):
2841 
    """
2842 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2843 
 
4668 varun.gupt 2844 
    Parameters:
2845 
     - cartId
2846 
     - sourceId
2847 
     - pincode
2848 
    """
2849 
    self.send_showCODOption(cartId, sourceId, pincode)
2850 
    return self.recv_showCODOption()
2851 
 
2852 
  def send_showCODOption(self, cartId, sourceId, pincode):
2853 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2854 
    args = showCODOption_args()
2855 
    args.cartId = cartId
2856 
    args.sourceId = sourceId
2857 
    args.pincode = pincode
2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
2862 
  def recv_showCODOption(self, ):
2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
2869 
    result = showCODOption_result()
2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
2872 
    if result.success is not None:
2873 
      return result.success
2874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2875 
 
5623 anupam.sin 2876 
  def getUserEmails(self, startDate, endDate):
2877 
    """
2878 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2879 
 
5623 anupam.sin 2880 
    Parameters:
2881 
     - startDate
2882 
     - endDate
2883 
    """
2884 
    self.send_getUserEmails(startDate, endDate)
2885 
    return self.recv_getUserEmails()
2886 
 
2887 
  def send_getUserEmails(self, startDate, endDate):
2888 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
2889 
    args = getUserEmails_args()
2890 
    args.startDate = startDate
2891 
    args.endDate = endDate
2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
2896 
  def recv_getUserEmails(self, ):
2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
2903 
    result = getUserEmails_result()
2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
2906 
    if result.success is not None:
2907 
      return result.success
2908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
2909 
 
9299 kshitij.so 2910 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 2911 
    """
2912 
    Mark a cart lineitem as insured. Returns true/false.
2913 
 
2914 
    Parameters:
2915 
     - itemId
2916 
     - cartId
2917 
     - toInsure
9299 kshitij.so 2918 
     - insurerType
6903 anupam.sin 2919 
    """
9299 kshitij.so 2920 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 2921 
    return self.recv_insureItem()
2922 
 
9299 kshitij.so 2923 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 2924 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
2925 
    args = insureItem_args()
2926 
    args.itemId = itemId
2927 
    args.cartId = cartId
2928 
    args.toInsure = toInsure
9299 kshitij.so 2929 
    args.insurerType = insurerType
6903 anupam.sin 2930 
    args.write(self._oprot)
2931 
    self._oprot.writeMessageEnd()
2932 
    self._oprot.trans.flush()
2933 
 
2934 
  def recv_insureItem(self, ):
2935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2936 
    if mtype == TMessageType.EXCEPTION:
2937 
      x = TApplicationException()
2938 
      x.read(self._iprot)
2939 
      self._iprot.readMessageEnd()
2940 
      raise x
2941 
    result = insureItem_result()
2942 
    result.read(self._iprot)
2943 
    self._iprot.readMessageEnd()
2944 
    if result.success is not None:
2945 
      return result.success
2946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
2947 
 
2948 
  def cancelInsurance(self, cartId):
2949 
    """
2950 
    Cancel insurance for all items in the cart
2951 
 
2952 
    Parameters:
2953 
     - cartId
2954 
    """
2955 
    self.send_cancelInsurance(cartId)
2956 
    return self.recv_cancelInsurance()
2957 
 
2958 
  def send_cancelInsurance(self, cartId):
2959 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
2960 
    args = cancelInsurance_args()
2961 
    args.cartId = cartId
2962 
    args.write(self._oprot)
2963 
    self._oprot.writeMessageEnd()
2964 
    self._oprot.trans.flush()
2965 
 
2966 
  def recv_cancelInsurance(self, ):
2967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2968 
    if mtype == TMessageType.EXCEPTION:
2969 
      x = TApplicationException()
2970 
      x.read(self._iprot)
2971 
      self._iprot.readMessageEnd()
2972 
      raise x
2973 
    result = cancelInsurance_result()
2974 
    result.read(self._iprot)
2975 
    self._iprot.readMessageEnd()
2976 
    if result.success is not None:
2977 
      return result.success
2978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
2979 
 
2980 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
2981 
    """
2982 
    Stores insurance specific details like date of birth and guardianName
2983 
 
2984 
    Parameters:
2985 
     - addressId
2986 
     - dob
2987 
     - guardianName
2988 
    """
2989 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
2990 
    return self.recv_storeInsuranceSpecificDetails()
2991 
 
2992 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
2993 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
2994 
    args = storeInsuranceSpecificDetails_args()
2995 
    args.addressId = addressId
2996 
    args.dob = dob
2997 
    args.guardianName = guardianName
2998 
    args.write(self._oprot)
2999 
    self._oprot.writeMessageEnd()
3000 
    self._oprot.trans.flush()
3001 
 
3002 
  def recv_storeInsuranceSpecificDetails(self, ):
3003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3004 
    if mtype == TMessageType.EXCEPTION:
3005 
      x = TApplicationException()
3006 
      x.read(self._iprot)
3007 
      self._iprot.readMessageEnd()
3008 
      raise x
3009 
    result = storeInsuranceSpecificDetails_result()
3010 
    result.read(self._iprot)
3011 
    self._iprot.readMessageEnd()
3012 
    if result.success is not None:
3013 
      return result.success
3014 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3015 
 
3016 
  def isInsuranceDetailPresent(self, addressId):
3017 
    """
3018 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3019 
 
3020 
    Parameters:
3021 
     - addressId
3022 
    """
3023 
    self.send_isInsuranceDetailPresent(addressId)
3024 
    return self.recv_isInsuranceDetailPresent()
3025 
 
3026 
  def send_isInsuranceDetailPresent(self, addressId):
3027 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3028 
    args = isInsuranceDetailPresent_args()
3029 
    args.addressId = addressId
3030 
    args.write(self._oprot)
3031 
    self._oprot.writeMessageEnd()
3032 
    self._oprot.trans.flush()
3033 
 
3034 
  def recv_isInsuranceDetailPresent(self, ):
3035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3036 
    if mtype == TMessageType.EXCEPTION:
3037 
      x = TApplicationException()
3038 
      x.read(self._iprot)
3039 
      self._iprot.readMessageEnd()
3040 
      raise x
3041 
    result = isInsuranceDetailPresent_result()
3042 
    result.read(self._iprot)
3043 
    self._iprot.readMessageEnd()
3044 
    if result.success is not None:
3045 
      return result.success
3046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3047 
 
9791 rajveer 3048 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3049 
    """
9791 rajveer 3050 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3051 
 
6821 amar.kumar 3052 
    Parameters:
3053 
     - startDate
3054 
     - endDate
3055 
    """
9791 rajveer 3056 
    self.send_getProductsAddedToCart(startDate, endDate)
3057 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3058 
 
9791 rajveer 3059 
  def send_getProductsAddedToCart(self, startDate, endDate):
3060 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3061 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3062 
    args.startDate = startDate
3063 
    args.endDate = endDate
3064 
    args.write(self._oprot)
3065 
    self._oprot.writeMessageEnd()
3066 
    self._oprot.trans.flush()
3067 
 
9791 rajveer 3068 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3070 
    if mtype == TMessageType.EXCEPTION:
3071 
      x = TApplicationException()
3072 
      x.read(self._iprot)
3073 
      self._iprot.readMessageEnd()
3074 
      raise x
9791 rajveer 3075 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3076 
    result.read(self._iprot)
3077 
    self._iprot.readMessageEnd()
3078 
    if result.success is not None:
3079 
      return result.success
9791 rajveer 3080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3081 
 
11592 amit.gupta 3082 
  def validateCartPlus(self, cartId, sourceId):
3083 
    """
3084 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3085 
 
11592 amit.gupta 3086 
    Parameters:
3087 
     - cartId
3088 
     - sourceId
3089 
    """
3090 
    self.send_validateCartPlus(cartId, sourceId)
3091 
    return self.recv_validateCartPlus()
3092 
 
3093 
  def send_validateCartPlus(self, cartId, sourceId):
3094 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3095 
    args = validateCartPlus_args()
3096 
    args.cartId = cartId
3097 
    args.sourceId = sourceId
3098 
    args.write(self._oprot)
3099 
    self._oprot.writeMessageEnd()
3100 
    self._oprot.trans.flush()
3101 
 
3102 
  def recv_validateCartPlus(self, ):
3103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3104 
    if mtype == TMessageType.EXCEPTION:
3105 
      x = TApplicationException()
3106 
      x.read(self._iprot)
3107 
      self._iprot.readMessageEnd()
3108 
      raise x
3109 
    result = validateCartPlus_result()
3110 
    result.read(self._iprot)
3111 
    self._iprot.readMessageEnd()
3112 
    if result.success is not None:
3113 
      return result.success
3114 
    if result.scex is not None:
3115 
      raise result.scex
3116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3117 
 
11679 vikram.rag 3118 
  def isPrivateDealUser(self, userId):
3119 
    """
3120 
    Parameters:
3121 
     - userId
3122 
    """
3123 
    self.send_isPrivateDealUser(userId)
3124 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3125 
 
11679 vikram.rag 3126 
  def send_isPrivateDealUser(self, userId):
3127 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3128 
    args = isPrivateDealUser_args()
3129 
    args.userId = userId
3130 
    args.write(self._oprot)
3131 
    self._oprot.writeMessageEnd()
3132 
    self._oprot.trans.flush()
3133 
 
3134 
  def recv_isPrivateDealUser(self, ):
3135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3136 
    if mtype == TMessageType.EXCEPTION:
3137 
      x = TApplicationException()
3138 
      x.read(self._iprot)
3139 
      self._iprot.readMessageEnd()
3140 
      raise x
3141 
    result = isPrivateDealUser_result()
3142 
    result.read(self._iprot)
3143 
    self._iprot.readMessageEnd()
3144 
    if result.success is not None:
3145 
      return result.success
3146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3147 
 
3148 
 
3376 rajveer 3149 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3150 
  def __init__(self, handler):
3376 rajveer 3151 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3152 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3153 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3154 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3155 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3156 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3157 
    self._processMap["createUser"] = Processor.process_createUser
3158 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3159 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3160 
    self._processMap["userExists"] = Processor.process_userExists
3161 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3162 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3163 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3164 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3165 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3166 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3167 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3168 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3169 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3170 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3171 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3172 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3173 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3174 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3175 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3176 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3177 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3178 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3179 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3180 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3181 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3182 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3183 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3184 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3185 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3186 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3187 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3188 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3189 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3190 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3191 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3192 
    self._processMap["getCart"] = Processor.process_getCart
3193 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3194 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3195 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3196 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3197 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3198 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3199 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3200 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3201 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3202 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3203 
    self._processMap["validateCart"] = Processor.process_validateCart
3204 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3205 
    self._processMap["checkOut"] = Processor.process_checkOut
3206 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3207 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3208 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3209 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3210 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3211 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3212 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3213 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3214 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3215 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3216 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3217 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3218 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3219 
    self._processMap["insureItem"] = Processor.process_insureItem
3220 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3221 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3222 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3223 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3224 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3225 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
94 ashish 3226 
 
3227 
  def process(self, iprot, oprot):
3228 
    (name, type, seqid) = iprot.readMessageBegin()
3229 
    if name not in self._processMap:
3230 
      iprot.skip(TType.STRUCT)
3231 
      iprot.readMessageEnd()
3232 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3233 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3234 
      x.write(oprot)
3235 
      oprot.writeMessageEnd()
3236 
      oprot.trans.flush()
3237 
      return
3238 
    else:
3239 
      self._processMap[name](self, seqid, iprot, oprot)
3240 
    return True
3241 
 
559 chandransh 3242 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3243 
    args = createAnonymousUser_args()
94 ashish 3244 
    args.read(iprot)
3245 
    iprot.readMessageEnd()
559 chandransh 3246 
    result = createAnonymousUser_result()
94 ashish 3247 
    try:
559 chandransh 3248 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3249 
    except UserContextException, ucex:
3250 
      result.ucex = ucex
3251 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3252 
    result.write(oprot)
3253 
    oprot.writeMessageEnd()
3254 
    oprot.trans.flush()
3255 
 
559 chandransh 3256 
  def process_getUserById(self, seqid, iprot, oprot):
3257 
    args = getUserById_args()
94 ashish 3258 
    args.read(iprot)
3259 
    iprot.readMessageEnd()
559 chandransh 3260 
    result = getUserById_result()
94 ashish 3261 
    try:
559 chandransh 3262 
      result.success = self._handler.getUserById(args.userId)
3263 
    except UserContextException, ucex:
3264 
      result.ucex = ucex
3265 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3266 
    result.write(oprot)
3267 
    oprot.writeMessageEnd()
3268 
    oprot.trans.flush()
3269 
 
5326 rajveer 3270 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3271 
    args = getUserByCartId_args()
3272 
    args.read(iprot)
3273 
    iprot.readMessageEnd()
3274 
    result = getUserByCartId_result()
3275 
    try:
3276 
      result.success = self._handler.getUserByCartId(args.cartId)
3277 
    except UserContextException, ucex:
3278 
      result.ucex = ucex
3279 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3280 
    result.write(oprot)
3281 
    oprot.writeMessageEnd()
3282 
    oprot.trans.flush()
3283 
 
1491 vikas 3284 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3285 
    args = getUserByEmail_args()
3286 
    args.read(iprot)
3287 
    iprot.readMessageEnd()
3288 
    result = getUserByEmail_result()
3289 
    try:
3290 
      result.success = self._handler.getUserByEmail(args.email)
3291 
    except UserContextException, ucex:
3292 
      result.ucex = ucex
3293 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3294 
    result.write(oprot)
3295 
    oprot.writeMessageEnd()
3296 
    oprot.trans.flush()
3297 
 
3032 mandeep.dh 3298 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3299 
    args = getUserByMobileNumber_args()
3300 
    args.read(iprot)
3301 
    iprot.readMessageEnd()
3302 
    result = getUserByMobileNumber_result()
3303 
    try:
3304 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3305 
    except UserContextException, ucex:
3306 
      result.ucex = ucex
3307 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3308 
    result.write(oprot)
3309 
    oprot.writeMessageEnd()
3310 
    oprot.trans.flush()
3311 
 
559 chandransh 3312 
  def process_createUser(self, seqid, iprot, oprot):
3313 
    args = createUser_args()
94 ashish 3314 
    args.read(iprot)
3315 
    iprot.readMessageEnd()
559 chandransh 3316 
    result = createUser_result()
94 ashish 3317 
    try:
559 chandransh 3318 
      result.success = self._handler.createUser(args.user)
3319 
    except UserContextException, ucex:
3320 
      result.ucex = ucex
3321 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3322 
    result.write(oprot)
3323 
    oprot.writeMessageEnd()
3324 
    oprot.trans.flush()
3325 
 
559 chandransh 3326 
  def process_updateUser(self, seqid, iprot, oprot):
3327 
    args = updateUser_args()
94 ashish 3328 
    args.read(iprot)
3329 
    iprot.readMessageEnd()
559 chandransh 3330 
    result = updateUser_result()
94 ashish 3331 
    try:
559 chandransh 3332 
      result.success = self._handler.updateUser(args.user)
3333 
    except UserContextException, ucex:
3334 
      result.ucex = ucex
3335 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3336 
    result.write(oprot)
3337 
    oprot.writeMessageEnd()
3338 
    oprot.trans.flush()
3339 
 
122 ashish 3340 
  def process_authenticateUser(self, seqid, iprot, oprot):
3341 
    args = authenticateUser_args()
3342 
    args.read(iprot)
3343 
    iprot.readMessageEnd()
3344 
    result = authenticateUser_result()
3345 
    try:
559 chandransh 3346 
      result.success = self._handler.authenticateUser(args.email, args.password)
3347 
    except AuthenticationException, auex:
3348 
      result.auex = auex
122 ashish 3349 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3350 
    result.write(oprot)
3351 
    oprot.writeMessageEnd()
3352 
    oprot.trans.flush()
3353 
 
94 ashish 3354 
  def process_userExists(self, seqid, iprot, oprot):
3355 
    args = userExists_args()
3356 
    args.read(iprot)
3357 
    iprot.readMessageEnd()
3358 
    result = userExists_result()
3359 
    try:
3360 
      result.success = self._handler.userExists(args.email)
3361 
    except UserContextException, ucx:
3362 
      result.ucx = ucx
3363 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3364 
    result.write(oprot)
3365 
    oprot.writeMessageEnd()
3366 
    oprot.trans.flush()
3367 
 
3368 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3369 
    args = addAddressForUser_args()
3370 
    args.read(iprot)
3371 
    iprot.readMessageEnd()
3372 
    result = addAddressForUser_result()
3373 
    try:
567 rajveer 3374 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3375 
    except UserContextException, ucx:
3376 
      result.ucx = ucx
3377 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3378 
    result.write(oprot)
3379 
    oprot.writeMessageEnd()
3380 
    oprot.trans.flush()
3381 
 
3382 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3383 
    args = removeAddressForUser_args()
3384 
    args.read(iprot)
3385 
    iprot.readMessageEnd()
3386 
    result = removeAddressForUser_result()
3387 
    try:
3388 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3389 
    except UserContextException, ucx:
3390 
      result.ucx = ucx
3391 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3392 
    result.write(oprot)
3393 
    oprot.writeMessageEnd()
3394 
    oprot.trans.flush()
3395 
 
3396 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3397 
    args = setUserAsLoggedIn_args()
3398 
    args.read(iprot)
3399 
    iprot.readMessageEnd()
3400 
    result = setUserAsLoggedIn_result()
3401 
    try:
3402 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3403 
    except UserContextException, ucx:
3404 
      result.ucx = ucx
3405 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3406 
    result.write(oprot)
3407 
    oprot.writeMessageEnd()
3408 
    oprot.trans.flush()
3409 
 
3410 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3411 
    args = setUserAsLoggedOut_args()
3412 
    args.read(iprot)
3413 
    iprot.readMessageEnd()
3414 
    result = setUserAsLoggedOut_result()
3415 
    try:
3416 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3417 
    except UserContextException, ucx:
3418 
      result.ucx = ucx
3419 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3420 
    result.write(oprot)
3421 
    oprot.writeMessageEnd()
3422 
    oprot.trans.flush()
3423 
 
504 rajveer 3424 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3425 
    args = setDefaultAddress_args()
3426 
    args.read(iprot)
3427 
    iprot.readMessageEnd()
3428 
    result = setDefaultAddress_result()
3429 
    try:
3430 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3431 
    except UserContextException, ucx:
3432 
      result.ucx = ucx
3433 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3434 
    result.write(oprot)
3435 
    oprot.writeMessageEnd()
3436 
    oprot.trans.flush()
3437 
 
94 ashish 3438 
  def process_updatePassword(self, seqid, iprot, oprot):
3439 
    args = updatePassword_args()
3440 
    args.read(iprot)
3441 
    iprot.readMessageEnd()
3442 
    result = updatePassword_result()
3443 
    try:
594 rajveer 3444 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3445 
    except UserContextException, ucx:
3446 
      result.ucx = ucx
3447 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3448 
    result.write(oprot)
3449 
    oprot.writeMessageEnd()
3450 
    oprot.trans.flush()
3451 
 
581 rajveer 3452 
  def process_forgotPassword(self, seqid, iprot, oprot):
3453 
    args = forgotPassword_args()
3454 
    args.read(iprot)
3455 
    iprot.readMessageEnd()
3456 
    result = forgotPassword_result()
3457 
    try:
884 rajveer 3458 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3459 
    except UserContextException, ucx:
3460 
      result.ucx = ucx
3461 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3462 
    result.write(oprot)
3463 
    oprot.writeMessageEnd()
3464 
    oprot.trans.flush()
3465 
 
594 rajveer 3466 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3467 
    args = getAllAddressesForUser_args()
3468 
    args.read(iprot)
3469 
    iprot.readMessageEnd()
3470 
    result = getAllAddressesForUser_result()
3471 
    try:
3472 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3473 
    except UserContextException, ucx:
3474 
      result.ucx = ucx
3475 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3476 
    result.write(oprot)
3477 
    oprot.writeMessageEnd()
3478 
    oprot.trans.flush()
3479 
 
1894 vikas 3480 
  def process_getAddressById(self, seqid, iprot, oprot):
3481 
    args = getAddressById_args()
3482 
    args.read(iprot)
3483 
    iprot.readMessageEnd()
3484 
    result = getAddressById_result()
3485 
    try:
3486 
      result.success = self._handler.getAddressById(args.addressId)
3487 
    except UserContextException, ucx:
3488 
      result.ucx = ucx
3489 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3490 
    result.write(oprot)
3491 
    oprot.writeMessageEnd()
3492 
    oprot.trans.flush()
3493 
 
594 rajveer 3494 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3495 
    args = getDefaultAddressId_args()
3496 
    args.read(iprot)
3497 
    iprot.readMessageEnd()
3498 
    result = getDefaultAddressId_result()
3499 
    try:
3500 
      result.success = self._handler.getDefaultAddressId(args.userId)
3501 
    except UserContextException, ucx:
3502 
      result.ucx = ucx
3503 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3504 
    result.write(oprot)
3505 
    oprot.writeMessageEnd()
3506 
    oprot.trans.flush()
3507 
 
785 rajveer 3508 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3509 
    args = getDefaultPincode_args()
3510 
    args.read(iprot)
3511 
    iprot.readMessageEnd()
3512 
    result = getDefaultPincode_result()
3513 
    try:
3514 
      result.success = self._handler.getDefaultPincode(args.userId)
3515 
    except UserContextException, ucx:
3516 
      result.ucx = ucx
3517 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3518 
    result.write(oprot)
3519 
    oprot.writeMessageEnd()
3520 
    oprot.trans.flush()
3521 
 
1274 varun.gupt 3522 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3523 
    args = saveUserCommunication_args()
3524 
    args.read(iprot)
3525 
    iprot.readMessageEnd()
3526 
    result = saveUserCommunication_result()
3527 
    try:
3528 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3529 
    except UserCommunicationException, ucx:
3530 
      result.ucx = ucx
3531 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3532 
    result.write(oprot)
3533 
    oprot.writeMessageEnd()
3534 
    oprot.trans.flush()
3535 
 
1590 varun.gupt 3536 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3537 
    args = getUserCommunicationById_args()
3538 
    args.read(iprot)
3539 
    iprot.readMessageEnd()
3540 
    result = getUserCommunicationById_result()
3541 
    try:
3542 
      result.success = self._handler.getUserCommunicationById(args.id)
3543 
    except UserCommunicationException, ucx:
3544 
      result.ucx = ucx
3545 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3546 
    result.write(oprot)
3547 
    oprot.writeMessageEnd()
3548 
    oprot.trans.flush()
3549 
 
3550 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3551 
    args = getUserCommunicationByUser_args()
3552 
    args.read(iprot)
3553 
    iprot.readMessageEnd()
3554 
    result = getUserCommunicationByUser_result()
3555 
    try:
3556 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3557 
    except UserCommunicationException, ucx:
3558 
      result.ucx = ucx
3559 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3560 
    result.write(oprot)
3561 
    oprot.writeMessageEnd()
3562 
    oprot.trans.flush()
3563 
 
3564 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3565 
    args = getAllUserCommunications_args()
3566 
    args.read(iprot)
3567 
    iprot.readMessageEnd()
3568 
    result = getAllUserCommunications_result()
3569 
    try:
3570 
      result.success = self._handler.getAllUserCommunications()
3571 
    except UserCommunicationException, ucx:
3572 
      result.ucx = ucx
3573 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3574 
    result.write(oprot)
3575 
    oprot.writeMessageEnd()
3576 
    oprot.trans.flush()
3577 
 
5407 amar.kumar 3578 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3579 
    args = removeUserCommunication_args()
3580 
    args.read(iprot)
3581 
    iprot.readMessageEnd()
3582 
    result = removeUserCommunication_result()
3583 
    try:
3584 
      self._handler.removeUserCommunication(args.id)
3585 
    except UserCommunicationException, ucx:
3586 
      result.ucx = ucx
3587 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3588 
    result.write(oprot)
3589 
    oprot.writeMessageEnd()
3590 
    oprot.trans.flush()
3591 
 
1845 vikas 3592 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3593 
    args = createMasterAffiliate_args()
3594 
    args.read(iprot)
3595 
    iprot.readMessageEnd()
3596 
    result = createMasterAffiliate_result()
3597 
    try:
1859 vikas 3598 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3599 
    except UserAffiliateException, utx:
1845 vikas 3600 
      result.utx = utx
3601 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3602 
    result.write(oprot)
3603 
    oprot.writeMessageEnd()
3604 
    oprot.trans.flush()
3605 
 
1899 vikas 3606 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3607 
    args = getAllMasterAffiliates_args()
3608 
    args.read(iprot)
3609 
    iprot.readMessageEnd()
3610 
    result = getAllMasterAffiliates_result()
3611 
    try:
3612 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3613 
    except UserAffiliateException, utx:
1899 vikas 3614 
      result.utx = utx
3615 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3616 
    result.write(oprot)
3617 
    oprot.writeMessageEnd()
3618 
    oprot.trans.flush()
3619 
 
1845 vikas 3620 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3621 
    args = getMasterAffiliateById_args()
3622 
    args.read(iprot)
3623 
    iprot.readMessageEnd()
3624 
    result = getMasterAffiliateById_result()
3625 
    try:
3626 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3627 
    except UserAffiliateException, utx:
1845 vikas 3628 
      result.utx = utx
3629 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3630 
    result.write(oprot)
3631 
    oprot.writeMessageEnd()
3632 
    oprot.trans.flush()
3633 
 
3634 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3635 
    args = getMasterAffiliateByName_args()
3636 
    args.read(iprot)
3637 
    iprot.readMessageEnd()
3638 
    result = getMasterAffiliateByName_result()
3639 
    try:
3640 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3641 
    except UserAffiliateException, utx:
1845 vikas 3642 
      result.utx = utx
3643 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3644 
    result.write(oprot)
3645 
    oprot.writeMessageEnd()
3646 
    oprot.trans.flush()
3647 
 
3648 
  def process_createAffiliate(self, seqid, iprot, oprot):
3649 
    args = createAffiliate_args()
3650 
    args.read(iprot)
3651 
    iprot.readMessageEnd()
3652 
    result = createAffiliate_result()
3653 
    try:
1859 vikas 3654 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3655 
    except UserAffiliateException, utx:
1845 vikas 3656 
      result.utx = utx
3657 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3658 
    result.write(oprot)
3659 
    oprot.writeMessageEnd()
3660 
    oprot.trans.flush()
3661 
 
3662 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3663 
    args = getAffiliateById_args()
3664 
    args.read(iprot)
3665 
    iprot.readMessageEnd()
3666 
    result = getAffiliateById_result()
3667 
    try:
3668 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3669 
    except UserAffiliateException, utx:
1845 vikas 3670 
      result.utx = utx
3671 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3672 
    result.write(oprot)
3673 
    oprot.writeMessageEnd()
3674 
    oprot.trans.flush()
3675 
 
3676 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3677 
    args = getAffiliateByName_args()
3678 
    args.read(iprot)
3679 
    iprot.readMessageEnd()
3680 
    result = getAffiliateByName_result()
3681 
    try:
3682 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3683 
    except UserAffiliateException, utx:
1845 vikas 3684 
      result.utx = utx
3685 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3686 
    result.write(oprot)
3687 
    oprot.writeMessageEnd()
3688 
    oprot.trans.flush()
3689 
 
3690 
  def process_getTrackerById(self, seqid, iprot, oprot):
3691 
    args = getTrackerById_args()
3692 
    args.read(iprot)
3693 
    iprot.readMessageEnd()
3694 
    result = getTrackerById_result()
3695 
    try:
1996 vikas 3696 
      result.success = self._handler.getTrackerById(args.id)
3697 
    except UserAffiliateException, utx:
1845 vikas 3698 
      result.utx = utx
3699 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3700 
    result.write(oprot)
3701 
    oprot.writeMessageEnd()
3702 
    oprot.trans.flush()
3703 
 
1996 vikas 3704 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3705 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3706 
    args.read(iprot)
3707 
    iprot.readMessageEnd()
1996 vikas 3708 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3709 
    try:
1996 vikas 3710 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3711 
    except UserAffiliateException, utx:
1845 vikas 3712 
      result.utx = utx
1996 vikas 3713 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3714 
    result.write(oprot)
3715 
    oprot.writeMessageEnd()
3716 
    oprot.trans.flush()
3717 
 
3718 
  def process_addTrackLog(self, seqid, iprot, oprot):
3719 
    args = addTrackLog_args()
3720 
    args.read(iprot)
3721 
    iprot.readMessageEnd()
3722 
    result = addTrackLog_result()
3723 
    try:
1996 vikas 3724 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3725 
    except UserAffiliateException, utx:
1845 vikas 3726 
      result.utx = utx
3727 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3728 
    result.write(oprot)
3729 
    oprot.writeMessageEnd()
3730 
    oprot.trans.flush()
3731 
 
3732 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3733 
    args = getTrackLogById_args()
3734 
    args.read(iprot)
3735 
    iprot.readMessageEnd()
3736 
    result = getTrackLogById_result()
3737 
    try:
3738 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3739 
    except UserAffiliateException, utx:
1845 vikas 3740 
      result.utx = utx
3741 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3742 
    result.write(oprot)
3743 
    oprot.writeMessageEnd()
3744 
    oprot.trans.flush()
3745 
 
1996 vikas 3746 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3747 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3748 
    args.read(iprot)
3749 
    iprot.readMessageEnd()
1996 vikas 3750 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3751 
    try:
3293 vikas 3752 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3753 
    except UserAffiliateException, utx:
1845 vikas 3754 
      result.utx = utx
1996 vikas 3755 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3756 
    result.write(oprot)
3757 
    oprot.writeMessageEnd()
3758 
    oprot.trans.flush()
3759 
 
3760 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3761 
    args = getTrackLogsByUser_args()
3762 
    args.read(iprot)
3763 
    iprot.readMessageEnd()
3764 
    result = getTrackLogsByUser_result()
3765 
    try:
3766 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3767 
    except UserAffiliateException, utx:
1845 vikas 3768 
      result.utx = utx
3769 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3770 
    result.write(oprot)
3771 
    oprot.writeMessageEnd()
3772 
    oprot.trans.flush()
3773 
 
3774 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3775 
    args = getTrackLogs_args()
3776 
    args.read(iprot)
3777 
    iprot.readMessageEnd()
3778 
    result = getTrackLogs_result()
3779 
    try:
1996 vikas 3780 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3781 
    except UserAffiliateException, utx:
1845 vikas 3782 
      result.utx = utx
3783 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3784 
    result.write(oprot)
3785 
    oprot.writeMessageEnd()
3786 
    oprot.trans.flush()
3787 
 
559 chandransh 3788 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3789 
    args = getCurrentCart_args()
94 ashish 3790 
    args.read(iprot)
3791 
    iprot.readMessageEnd()
559 chandransh 3792 
    result = getCurrentCart_result()
94 ashish 3793 
    try:
559 chandransh 3794 
      result.success = self._handler.getCurrentCart(args.userId)
3795 
    except ShoppingCartException, scx:
3796 
      result.scx = scx
3797 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3798 
    result.write(oprot)
3799 
    oprot.writeMessageEnd()
3800 
    oprot.trans.flush()
3801 
 
559 chandransh 3802 
  def process_getCart(self, seqid, iprot, oprot):
3803 
    args = getCart_args()
94 ashish 3804 
    args.read(iprot)
3805 
    iprot.readMessageEnd()
559 chandransh 3806 
    result = getCart_result()
94 ashish 3807 
    try:
559 chandransh 3808 
      result.success = self._handler.getCart(args.cartId)
3809 
    except ShoppingCartException, scx:
3810 
      result.scx = scx
3811 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3812 
    result.write(oprot)
3813 
    oprot.writeMessageEnd()
3814 
    oprot.trans.flush()
3815 
 
559 chandransh 3816 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3817 
    args = getCartsByTime_args()
94 ashish 3818 
    args.read(iprot)
3819 
    iprot.readMessageEnd()
559 chandransh 3820 
    result = getCartsByTime_result()
94 ashish 3821 
    try:
559 chandransh 3822 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3823 
    except ShoppingCartException, scx:
3824 
      result.scx = scx
3825 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3826 
    result.write(oprot)
3827 
    oprot.writeMessageEnd()
3828 
    oprot.trans.flush()
3829 
 
559 chandransh 3830 
  def process_addItemToCart(self, seqid, iprot, oprot):
3831 
    args = addItemToCart_args()
130 ashish 3832 
    args.read(iprot)
3833 
    iprot.readMessageEnd()
559 chandransh 3834 
    result = addItemToCart_result()
130 ashish 3835 
    try:
3557 rajveer 3836 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 3837 
    except ShoppingCartException, scx:
3838 
      result.scx = scx
3839 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3840 
    result.write(oprot)
3841 
    oprot.writeMessageEnd()
3842 
    oprot.trans.flush()
3843 
 
559 chandransh 3844 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3845 
    args = deleteItemFromCart_args()
3846 
    args.read(iprot)
3847 
    iprot.readMessageEnd()
3848 
    result = deleteItemFromCart_result()
3849 
    try:
3850 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3851 
    except ShoppingCartException, scx:
3852 
      result.scx = scx
3853 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3854 
    result.write(oprot)
3855 
    oprot.writeMessageEnd()
3856 
    oprot.trans.flush()
130 ashish 3857 
 
559 chandransh 3858 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3859 
    args = addAddressToCart_args()
3860 
    args.read(iprot)
3861 
    iprot.readMessageEnd()
3862 
    result = addAddressToCart_result()
575 chandransh 3863 
    try:
3864 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3865 
    except ShoppingCartException, scx:
3866 
      result.scx = scx
559 chandransh 3867 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3868 
    result.write(oprot)
3869 
    oprot.writeMessageEnd()
3870 
    oprot.trans.flush()
3871 
 
5553 rajveer 3872 
  def process_addStoreToCart(self, seqid, iprot, oprot):
3873 
    args = addStoreToCart_args()
3874 
    args.read(iprot)
3875 
    iprot.readMessageEnd()
3876 
    result = addStoreToCart_result()
3877 
    try:
3878 
      self._handler.addStoreToCart(args.cartId, args.storeId)
3879 
    except ShoppingCartException, scx:
3880 
      result.scx = scx
3881 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
3882 
    result.write(oprot)
3883 
    oprot.writeMessageEnd()
3884 
    oprot.trans.flush()
3885 
 
1976 varun.gupt 3886 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3887 
    args = applyCouponToCart_args()
3888 
    args.read(iprot)
3889 
    iprot.readMessageEnd()
3890 
    result = applyCouponToCart_result()
3891 
    try:
6922 anupam.sin 3892 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 3893 
    except ShoppingCartException, scx:
3894 
      result.scx = scx
3895 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3896 
    result.write(oprot)
3897 
    oprot.writeMessageEnd()
3898 
    oprot.trans.flush()
3899 
 
3900 
  def process_removeCoupon(self, seqid, iprot, oprot):
3901 
    args = removeCoupon_args()
3902 
    args.read(iprot)
3903 
    iprot.readMessageEnd()
3904 
    result = removeCoupon_result()
3905 
    try:
3906 
      self._handler.removeCoupon(args.cartId)
3907 
    except ShoppingCartException, scx:
3908 
      result.scx = scx
3909 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3910 
    result.write(oprot)
3911 
    oprot.writeMessageEnd()
3912 
    oprot.trans.flush()
3913 
 
3554 varun.gupt 3914 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
3915 
    args = deleteDiscountsFromCart_args()
3916 
    args.read(iprot)
3917 
    iprot.readMessageEnd()
3918 
    result = deleteDiscountsFromCart_result()
3919 
    try:
3920 
      self._handler.deleteDiscountsFromCart(args.cartId)
3921 
    except ShoppingCartException, scx:
3922 
      result.scx = scx
3923 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
3924 
    result.write(oprot)
3925 
    oprot.writeMessageEnd()
3926 
    oprot.trans.flush()
3927 
 
3928 
  def process_saveDiscounts(self, seqid, iprot, oprot):
3929 
    args = saveDiscounts_args()
3930 
    args.read(iprot)
3931 
    iprot.readMessageEnd()
3932 
    result = saveDiscounts_result()
3933 
    try:
3934 
      self._handler.saveDiscounts(args.discounts)
3935 
    except ShoppingCartException, scx:
3936 
      result.scx = scx
3937 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
3938 
    result.write(oprot)
3939 
    oprot.writeMessageEnd()
3940 
    oprot.trans.flush()
3941 
 
690 chandransh 3942 
  def process_createOrders(self, seqid, iprot, oprot):
3943 
    args = createOrders_args()
559 chandransh 3944 
    args.read(iprot)
3945 
    iprot.readMessageEnd()
690 chandransh 3946 
    result = createOrders_result()
559 chandransh 3947 
    try:
11526 amit.gupta 3948 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 3949 
    except ShoppingCartException, scx:
3950 
      result.scx = scx
690 chandransh 3951 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3952 
    result.write(oprot)
3953 
    oprot.writeMessageEnd()
3954 
    oprot.trans.flush()
3955 
 
3956 
  def process_validateCart(self, seqid, iprot, oprot):
3957 
    args = validateCart_args()
3958 
    args.read(iprot)
3959 
    iprot.readMessageEnd()
3960 
    result = validateCart_result()
575 chandransh 3961 
    try:
3557 rajveer 3962 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 3963 
    except ShoppingCartException, scex:
3964 
      result.scex = scex
559 chandransh 3965 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3966 
    result.write(oprot)
3967 
    oprot.writeMessageEnd()
3968 
    oprot.trans.flush()
3969 
 
690 chandransh 3970 
  def process_mergeCart(self, seqid, iprot, oprot):
3971 
    args = mergeCart_args()
575 chandransh 3972 
    args.read(iprot)
3973 
    iprot.readMessageEnd()
690 chandransh 3974 
    result = mergeCart_result()
3975 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3976 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3977 
    result.write(oprot)
3978 
    oprot.writeMessageEnd()
3979 
    oprot.trans.flush()
3980 
 
3981 
  def process_checkOut(self, seqid, iprot, oprot):
3982 
    args = checkOut_args()
3983 
    args.read(iprot)
3984 
    iprot.readMessageEnd()
3985 
    result = checkOut_result()
575 chandransh 3986 
    try:
690 chandransh 3987 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3988 
    except ShoppingCartException, scex:
3989 
      result.scex = scex
690 chandransh 3990 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3991 
    result.write(oprot)
3992 
    oprot.writeMessageEnd()
3993 
    oprot.trans.flush()
3994 
 
690 chandransh 3995 
  def process_resetCart(self, seqid, iprot, oprot):
3996 
    args = resetCart_args()
559 chandransh 3997 
    args.read(iprot)
3998 
    iprot.readMessageEnd()
690 chandransh 3999 
    result = resetCart_result()
4000 
    try:
4001 
      result.success = self._handler.resetCart(args.cartId, args.items)
4002 
    except ShoppingCartException, scex:
4003 
      result.scex = scex
4004 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4005 
    result.write(oprot)
4006 
    oprot.writeMessageEnd()
4007 
    oprot.trans.flush()
4008 
 
2981 rajveer 4009 
  def process_getUserCount(self, seqid, iprot, oprot):
4010 
    args = getUserCount_args()
559 chandransh 4011 
    args.read(iprot)
4012 
    iprot.readMessageEnd()
2981 rajveer 4013 
    result = getUserCount_result()
4014 
    result.success = self._handler.getUserCount(args.userType)
4015 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4016 
    result.write(oprot)
4017 
    oprot.writeMessageEnd()
4018 
    oprot.trans.flush()
4019 
 
2981 rajveer 4020 
  def process_getAllUsers(self, seqid, iprot, oprot):
4021 
    args = getAllUsers_args()
559 chandransh 4022 
    args.read(iprot)
4023 
    iprot.readMessageEnd()
2981 rajveer 4024 
    result = getAllUsers_result()
4025 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4026 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4027 
    result.write(oprot)
4028 
    oprot.writeMessageEnd()
4029 
    oprot.trans.flush()
4030 
 
2981 rajveer 4031 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4032 
    args = getMyResearchItems_args()
559 chandransh 4033 
    args.read(iprot)
4034 
    iprot.readMessageEnd()
2981 rajveer 4035 
    result = getMyResearchItems_result()
559 chandransh 4036 
    try:
2981 rajveer 4037 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4038 
    except WidgetException, scx:
4039 
      result.scx = scx
2981 rajveer 4040 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4041 
    result.write(oprot)
4042 
    oprot.writeMessageEnd()
4043 
    oprot.trans.flush()
4044 
 
2981 rajveer 4045 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4046 
    args = updateMyResearch_args()
772 rajveer 4047 
    args.read(iprot)
4048 
    iprot.readMessageEnd()
2981 rajveer 4049 
    result = updateMyResearch_result()
4050 
    try:
4051 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4052 
    except WidgetException, scx:
4053 
      result.scx = scx
4054 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4055 
    result.write(oprot)
4056 
    oprot.writeMessageEnd()
4057 
    oprot.trans.flush()
559 chandransh 4058 
 
2981 rajveer 4059 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4060 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4061 
    args.read(iprot)
4062 
    iprot.readMessageEnd()
2981 rajveer 4063 
    result = deleteItemFromMyResearch_result()
4064 
    try:
4065 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4066 
    except WidgetException, scx:
4067 
      result.scx = scx
4068 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4069 
    result.write(oprot)
4070 
    oprot.writeMessageEnd()
4071 
    oprot.trans.flush()
772 rajveer 4072 
 
2981 rajveer 4073 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4074 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4075 
    args.read(iprot)
4076 
    iprot.readMessageEnd()
2981 rajveer 4077 
    result = getBrowseHistoryItems_result()
4078 
    try:
4079 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4080 
    except WidgetException, scx:
4081 
      result.scx = scx
4082 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4083 
    result.write(oprot)
4084 
    oprot.writeMessageEnd()
4085 
    oprot.trans.flush()
1596 ankur.sing 4086 
 
2981 rajveer 4087 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4088 
    args = updateBrowseHistory_args()
2642 varun.gupt 4089 
    args.read(iprot)
4090 
    iprot.readMessageEnd()
2981 rajveer 4091 
    result = updateBrowseHistory_result()
4092 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4093 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4094 
    result.write(oprot)
4095 
    oprot.writeMessageEnd()
4096 
    oprot.trans.flush()
1673 ankur.sing 4097 
 
3385 varun.gupt 4098 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4099 
    args = getCartsWithCouponCount_args()
4100 
    args.read(iprot)
4101 
    iprot.readMessageEnd()
4102 
    result = getCartsWithCouponCount_result()
4103 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4104 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
2642 varun.gupt 4108 
 
3499 mandeep.dh 4109 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4110 
    args = increaseTrustLevel_args()
4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
4113 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4114 
    return
3385 varun.gupt 4115 
 
5407 amar.kumar 4116 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4117 
    args = getTrustLevel_args()
4118 
    args.read(iprot)
4119 
    iprot.readMessageEnd()
4120 
    result = getTrustLevel_result()
4121 
    result.success = self._handler.getTrustLevel(args.userId)
4122 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4123 
    result.write(oprot)
4124 
    oprot.writeMessageEnd()
4125 
    oprot.trans.flush()
4126 
 
4668 varun.gupt 4127 
  def process_showCODOption(self, seqid, iprot, oprot):
4128 
    args = showCODOption_args()
4129 
    args.read(iprot)
4130 
    iprot.readMessageEnd()
4131 
    result = showCODOption_result()
4132 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4133 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4134 
    result.write(oprot)
4135 
    oprot.writeMessageEnd()
4136 
    oprot.trans.flush()
3499 mandeep.dh 4137 
 
5623 anupam.sin 4138 
  def process_getUserEmails(self, seqid, iprot, oprot):
4139 
    args = getUserEmails_args()
4140 
    args.read(iprot)
4141 
    iprot.readMessageEnd()
4142 
    result = getUserEmails_result()
4143 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4144 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4145 
    result.write(oprot)
4146 
    oprot.writeMessageEnd()
4147 
    oprot.trans.flush()
4668 varun.gupt 4148 
 
6903 anupam.sin 4149 
  def process_insureItem(self, seqid, iprot, oprot):
4150 
    args = insureItem_args()
4151 
    args.read(iprot)
4152 
    iprot.readMessageEnd()
4153 
    result = insureItem_result()
9299 kshitij.so 4154 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4155 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4156 
    result.write(oprot)
4157 
    oprot.writeMessageEnd()
4158 
    oprot.trans.flush()
4159 
 
4160 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4161 
    args = cancelInsurance_args()
4162 
    args.read(iprot)
4163 
    iprot.readMessageEnd()
4164 
    result = cancelInsurance_result()
4165 
    result.success = self._handler.cancelInsurance(args.cartId)
4166 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4167 
    result.write(oprot)
4168 
    oprot.writeMessageEnd()
4169 
    oprot.trans.flush()
4170 
 
4171 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4172 
    args = storeInsuranceSpecificDetails_args()
4173 
    args.read(iprot)
4174 
    iprot.readMessageEnd()
4175 
    result = storeInsuranceSpecificDetails_result()
4176 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4177 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4178 
    result.write(oprot)
4179 
    oprot.writeMessageEnd()
4180 
    oprot.trans.flush()
4181 
 
4182 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4183 
    args = isInsuranceDetailPresent_args()
4184 
    args.read(iprot)
4185 
    iprot.readMessageEnd()
4186 
    result = isInsuranceDetailPresent_result()
4187 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4188 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4189 
    result.write(oprot)
4190 
    oprot.writeMessageEnd()
4191 
    oprot.trans.flush()
4192 
 
9791 rajveer 4193 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4194 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4195 
    args.read(iprot)
4196 
    iprot.readMessageEnd()
9791 rajveer 4197 
    result = getProductsAddedToCart_result()
4198 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4199 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
5623 anupam.sin 4203 
 
11592 amit.gupta 4204 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4205 
    args = validateCartPlus_args()
4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
4208 
    result = validateCartPlus_result()
4209 
    try:
4210 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId)
4211 
    except ShoppingCartException, scex:
4212 
      result.scex = scex
4213 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4214 
    result.write(oprot)
4215 
    oprot.writeMessageEnd()
4216 
    oprot.trans.flush()
6821 amar.kumar 4217 
 
11679 vikram.rag 4218 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4219 
    args = isPrivateDealUser_args()
4220 
    args.read(iprot)
4221 
    iprot.readMessageEnd()
4222 
    result = isPrivateDealUser_result()
4223 
    result.success = self._handler.isPrivateDealUser(args.userId)
4224 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4225 
    result.write(oprot)
4226 
    oprot.writeMessageEnd()
4227 
    oprot.trans.flush()
11592 amit.gupta 4228 
 
11679 vikram.rag 4229 
 
94 ashish 4230 
# HELPER FUNCTIONS AND STRUCTURES
4231 
 
559 chandransh 4232 
class createAnonymousUser_args:
94 ashish 4233 
  """
4234 
  Attributes:
559 chandransh 4235 
   - jsessionId
94 ashish 4236 
  """
4237 
 
4238 
  thrift_spec = (
4239 
    None, # 0
559 chandransh 4240 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4241 
  )
4242 
 
559 chandransh 4243 
  def __init__(self, jsessionId=None,):
4244 
    self.jsessionId = jsessionId
94 ashish 4245 
 
4246 
  def read(self, iprot):
4247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4249 
      return
4250 
    iprot.readStructBegin()
4251 
    while True:
4252 
      (fname, ftype, fid) = iprot.readFieldBegin()
4253 
      if ftype == TType.STOP:
4254 
        break
4255 
      if fid == 1:
559 chandransh 4256 
        if ftype == TType.STRING:
4257 
          self.jsessionId = iprot.readString();
94 ashish 4258 
        else:
4259 
          iprot.skip(ftype)
4260 
      else:
4261 
        iprot.skip(ftype)
4262 
      iprot.readFieldEnd()
4263 
    iprot.readStructEnd()
4264 
 
4265 
  def write(self, oprot):
4266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4268 
      return
559 chandransh 4269 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4270 
    if self.jsessionId is not None:
559 chandransh 4271 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4272 
      oprot.writeString(self.jsessionId)
94 ashish 4273 
      oprot.writeFieldEnd()
4274 
    oprot.writeFieldStop()
4275 
    oprot.writeStructEnd()
4276 
 
3431 rajveer 4277 
  def validate(self):
4278 
    return
4279 
 
4280 
 
94 ashish 4281 
  def __repr__(self):
4282 
    L = ['%s=%r' % (key, value)
4283 
      for key, value in self.__dict__.iteritems()]
4284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4285 
 
4286 
  def __eq__(self, other):
4287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4288 
 
4289 
  def __ne__(self, other):
4290 
    return not (self == other)
4291 
 
559 chandransh 4292 
class createAnonymousUser_result:
94 ashish 4293 
  """
4294 
  Attributes:
4295 
   - success
559 chandransh 4296 
   - ucex
94 ashish 4297 
  """
4298 
 
4299 
  thrift_spec = (
559 chandransh 4300 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4301 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4302 
  )
4303 
 
559 chandransh 4304 
  def __init__(self, success=None, ucex=None,):
94 ashish 4305 
    self.success = success
559 chandransh 4306 
    self.ucex = ucex
94 ashish 4307 
 
4308 
  def read(self, iprot):
4309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4311 
      return
4312 
    iprot.readStructBegin()
4313 
    while True:
4314 
      (fname, ftype, fid) = iprot.readFieldBegin()
4315 
      if ftype == TType.STOP:
4316 
        break
4317 
      if fid == 0:
4318 
        if ftype == TType.STRUCT:
559 chandransh 4319 
          self.success = User()
94 ashish 4320 
          self.success.read(iprot)
4321 
        else:
4322 
          iprot.skip(ftype)
4323 
      elif fid == 1:
4324 
        if ftype == TType.STRUCT:
559 chandransh 4325 
          self.ucex = UserContextException()
4326 
          self.ucex.read(iprot)
94 ashish 4327 
        else:
4328 
          iprot.skip(ftype)
4329 
      else:
4330 
        iprot.skip(ftype)
4331 
      iprot.readFieldEnd()
4332 
    iprot.readStructEnd()
4333 
 
4334 
  def write(self, oprot):
4335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4337 
      return
559 chandransh 4338 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4339 
    if self.success is not None:
94 ashish 4340 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4341 
      self.success.write(oprot)
4342 
      oprot.writeFieldEnd()
3431 rajveer 4343 
    if self.ucex is not None:
559 chandransh 4344 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4345 
      self.ucex.write(oprot)
94 ashish 4346 
      oprot.writeFieldEnd()
4347 
    oprot.writeFieldStop()
4348 
    oprot.writeStructEnd()
4349 
 
3431 rajveer 4350 
  def validate(self):
4351 
    return
4352 
 
4353 
 
94 ashish 4354 
  def __repr__(self):
4355 
    L = ['%s=%r' % (key, value)
4356 
      for key, value in self.__dict__.iteritems()]
4357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4358 
 
4359 
  def __eq__(self, other):
4360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4361 
 
4362 
  def __ne__(self, other):
4363 
    return not (self == other)
4364 
 
559 chandransh 4365 
class getUserById_args:
94 ashish 4366 
  """
4367 
  Attributes:
4368 
   - userId
4369 
  """
4370 
 
4371 
  thrift_spec = (
4372 
    None, # 0
4373 
    (1, TType.I64, 'userId', None, None, ), # 1
4374 
  )
4375 
 
559 chandransh 4376 
  def __init__(self, userId=None,):
94 ashish 4377 
    self.userId = userId
4378 
 
4379 
  def read(self, iprot):
4380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4382 
      return
4383 
    iprot.readStructBegin()
4384 
    while True:
4385 
      (fname, ftype, fid) = iprot.readFieldBegin()
4386 
      if ftype == TType.STOP:
4387 
        break
4388 
      if fid == 1:
4389 
        if ftype == TType.I64:
4390 
          self.userId = iprot.readI64();
4391 
        else:
4392 
          iprot.skip(ftype)
4393 
      else:
4394 
        iprot.skip(ftype)
4395 
      iprot.readFieldEnd()
4396 
    iprot.readStructEnd()
4397 
 
4398 
  def write(self, oprot):
4399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4401 
      return
559 chandransh 4402 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4403 
    if self.userId is not None:
94 ashish 4404 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4405 
      oprot.writeI64(self.userId)
4406 
      oprot.writeFieldEnd()
4407 
    oprot.writeFieldStop()
4408 
    oprot.writeStructEnd()
4409 
 
3431 rajveer 4410 
  def validate(self):
4411 
    return
4412 
 
4413 
 
94 ashish 4414 
  def __repr__(self):
4415 
    L = ['%s=%r' % (key, value)
4416 
      for key, value in self.__dict__.iteritems()]
4417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4418 
 
4419 
  def __eq__(self, other):
4420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4421 
 
4422 
  def __ne__(self, other):
4423 
    return not (self == other)
4424 
 
559 chandransh 4425 
class getUserById_result:
94 ashish 4426 
  """
4427 
  Attributes:
4428 
   - success
559 chandransh 4429 
   - ucex
94 ashish 4430 
  """
4431 
 
4432 
  thrift_spec = (
559 chandransh 4433 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4434 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4435 
  )
4436 
 
559 chandransh 4437 
  def __init__(self, success=None, ucex=None,):
94 ashish 4438 
    self.success = success
559 chandransh 4439 
    self.ucex = ucex
94 ashish 4440 
 
4441 
  def read(self, iprot):
4442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4444 
      return
4445 
    iprot.readStructBegin()
4446 
    while True:
4447 
      (fname, ftype, fid) = iprot.readFieldBegin()
4448 
      if ftype == TType.STOP:
4449 
        break
4450 
      if fid == 0:
4451 
        if ftype == TType.STRUCT:
559 chandransh 4452 
          self.success = User()
94 ashish 4453 
          self.success.read(iprot)
4454 
        else:
4455 
          iprot.skip(ftype)
4456 
      elif fid == 1:
4457 
        if ftype == TType.STRUCT:
559 chandransh 4458 
          self.ucex = UserContextException()
4459 
          self.ucex.read(iprot)
94 ashish 4460 
        else:
4461 
          iprot.skip(ftype)
4462 
      else:
4463 
        iprot.skip(ftype)
4464 
      iprot.readFieldEnd()
4465 
    iprot.readStructEnd()
4466 
 
4467 
  def write(self, oprot):
4468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4470 
      return
559 chandransh 4471 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4472 
    if self.success is not None:
94 ashish 4473 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4474 
      self.success.write(oprot)
4475 
      oprot.writeFieldEnd()
3431 rajveer 4476 
    if self.ucex is not None:
559 chandransh 4477 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4478 
      self.ucex.write(oprot)
94 ashish 4479 
      oprot.writeFieldEnd()
4480 
    oprot.writeFieldStop()
4481 
    oprot.writeStructEnd()
4482 
 
3431 rajveer 4483 
  def validate(self):
4484 
    return
4485 
 
4486 
 
94 ashish 4487 
  def __repr__(self):
4488 
    L = ['%s=%r' % (key, value)
4489 
      for key, value in self.__dict__.iteritems()]
4490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4491 
 
4492 
  def __eq__(self, other):
4493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4494 
 
4495 
  def __ne__(self, other):
4496 
    return not (self == other)
4497 
 
5326 rajveer 4498 
class getUserByCartId_args:
1491 vikas 4499 
  """
4500 
  Attributes:
5326 rajveer 4501 
   - cartId
1491 vikas 4502 
  """
4503 
 
4504 
  thrift_spec = (
4505 
    None, # 0
5326 rajveer 4506 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4507 
  )
4508 
 
5326 rajveer 4509 
  def __init__(self, cartId=None,):
4510 
    self.cartId = cartId
1491 vikas 4511 
 
4512 
  def read(self, iprot):
4513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4515 
      return
4516 
    iprot.readStructBegin()
4517 
    while True:
4518 
      (fname, ftype, fid) = iprot.readFieldBegin()
4519 
      if ftype == TType.STOP:
4520 
        break
4521 
      if fid == 1:
5326 rajveer 4522 
        if ftype == TType.I64:
4523 
          self.cartId = iprot.readI64();
1491 vikas 4524 
        else:
4525 
          iprot.skip(ftype)
4526 
      else:
4527 
        iprot.skip(ftype)
4528 
      iprot.readFieldEnd()
4529 
    iprot.readStructEnd()
4530 
 
4531 
  def write(self, oprot):
4532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4534 
      return
5326 rajveer 4535 
    oprot.writeStructBegin('getUserByCartId_args')
4536 
    if self.cartId is not None:
4537 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4538 
      oprot.writeI64(self.cartId)
1491 vikas 4539 
      oprot.writeFieldEnd()
4540 
    oprot.writeFieldStop()
4541 
    oprot.writeStructEnd()
4542 
 
3431 rajveer 4543 
  def validate(self):
4544 
    return
4545 
 
4546 
 
1491 vikas 4547 
  def __repr__(self):
4548 
    L = ['%s=%r' % (key, value)
4549 
      for key, value in self.__dict__.iteritems()]
4550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4551 
 
4552 
  def __eq__(self, other):
4553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4554 
 
4555 
  def __ne__(self, other):
4556 
    return not (self == other)
4557 
 
5326 rajveer 4558 
class getUserByCartId_result:
1491 vikas 4559 
  """
4560 
  Attributes:
4561 
   - success
4562 
   - ucex
4563 
  """
4564 
 
4565 
  thrift_spec = (
4566 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4567 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4568 
  )
4569 
 
4570 
  def __init__(self, success=None, ucex=None,):
4571 
    self.success = success
4572 
    self.ucex = ucex
4573 
 
4574 
  def read(self, iprot):
4575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4577 
      return
4578 
    iprot.readStructBegin()
4579 
    while True:
4580 
      (fname, ftype, fid) = iprot.readFieldBegin()
4581 
      if ftype == TType.STOP:
4582 
        break
4583 
      if fid == 0:
4584 
        if ftype == TType.STRUCT:
4585 
          self.success = User()
4586 
          self.success.read(iprot)
4587 
        else:
4588 
          iprot.skip(ftype)
4589 
      elif fid == 1:
4590 
        if ftype == TType.STRUCT:
4591 
          self.ucex = UserContextException()
4592 
          self.ucex.read(iprot)
4593 
        else:
4594 
          iprot.skip(ftype)
4595 
      else:
4596 
        iprot.skip(ftype)
4597 
      iprot.readFieldEnd()
4598 
    iprot.readStructEnd()
4599 
 
4600 
  def write(self, oprot):
4601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4603 
      return
5326 rajveer 4604 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 4605 
    if self.success is not None:
1491 vikas 4606 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4607 
      self.success.write(oprot)
4608 
      oprot.writeFieldEnd()
3431 rajveer 4609 
    if self.ucex is not None:
1491 vikas 4610 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4611 
      self.ucex.write(oprot)
4612 
      oprot.writeFieldEnd()
4613 
    oprot.writeFieldStop()
4614 
    oprot.writeStructEnd()
4615 
 
3431 rajveer 4616 
  def validate(self):
4617 
    return
4618 
 
4619 
 
1491 vikas 4620 
  def __repr__(self):
4621 
    L = ['%s=%r' % (key, value)
4622 
      for key, value in self.__dict__.iteritems()]
4623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4624 
 
4625 
  def __eq__(self, other):
4626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4627 
 
4628 
  def __ne__(self, other):
4629 
    return not (self == other)
4630 
 
5326 rajveer 4631 
class getUserByEmail_args:
3032 mandeep.dh 4632 
  """
4633 
  Attributes:
5326 rajveer 4634 
   - email
3032 mandeep.dh 4635 
  """
4636 
 
4637 
  thrift_spec = (
4638 
    None, # 0
5326 rajveer 4639 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 4640 
  )
4641 
 
5326 rajveer 4642 
  def __init__(self, email=None,):
4643 
    self.email = email
3032 mandeep.dh 4644 
 
4645 
  def read(self, iprot):
4646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4648 
      return
4649 
    iprot.readStructBegin()
4650 
    while True:
4651 
      (fname, ftype, fid) = iprot.readFieldBegin()
4652 
      if ftype == TType.STOP:
4653 
        break
4654 
      if fid == 1:
5326 rajveer 4655 
        if ftype == TType.STRING:
4656 
          self.email = iprot.readString();
3032 mandeep.dh 4657 
        else:
4658 
          iprot.skip(ftype)
4659 
      else:
4660 
        iprot.skip(ftype)
4661 
      iprot.readFieldEnd()
4662 
    iprot.readStructEnd()
4663 
 
4664 
  def write(self, oprot):
4665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4667 
      return
5326 rajveer 4668 
    oprot.writeStructBegin('getUserByEmail_args')
4669 
    if self.email is not None:
4670 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4671 
      oprot.writeString(self.email)
3032 mandeep.dh 4672 
      oprot.writeFieldEnd()
4673 
    oprot.writeFieldStop()
4674 
    oprot.writeStructEnd()
4675 
 
3431 rajveer 4676 
  def validate(self):
4677 
    return
4678 
 
4679 
 
3032 mandeep.dh 4680 
  def __repr__(self):
4681 
    L = ['%s=%r' % (key, value)
4682 
      for key, value in self.__dict__.iteritems()]
4683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4684 
 
4685 
  def __eq__(self, other):
4686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4687 
 
4688 
  def __ne__(self, other):
4689 
    return not (self == other)
4690 
 
5326 rajveer 4691 
class getUserByEmail_result:
3032 mandeep.dh 4692 
  """
4693 
  Attributes:
4694 
   - success
4695 
   - ucex
4696 
  """
4697 
 
4698 
  thrift_spec = (
4699 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4700 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4701 
  )
4702 
 
4703 
  def __init__(self, success=None, ucex=None,):
4704 
    self.success = success
4705 
    self.ucex = ucex
4706 
 
4707 
  def read(self, iprot):
4708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4710 
      return
4711 
    iprot.readStructBegin()
4712 
    while True:
4713 
      (fname, ftype, fid) = iprot.readFieldBegin()
4714 
      if ftype == TType.STOP:
4715 
        break
4716 
      if fid == 0:
4717 
        if ftype == TType.STRUCT:
4718 
          self.success = User()
4719 
          self.success.read(iprot)
4720 
        else:
4721 
          iprot.skip(ftype)
4722 
      elif fid == 1:
4723 
        if ftype == TType.STRUCT:
4724 
          self.ucex = UserContextException()
4725 
          self.ucex.read(iprot)
4726 
        else:
4727 
          iprot.skip(ftype)
4728 
      else:
4729 
        iprot.skip(ftype)
4730 
      iprot.readFieldEnd()
4731 
    iprot.readStructEnd()
4732 
 
4733 
  def write(self, oprot):
4734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4736 
      return
5326 rajveer 4737 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 4738 
    if self.success is not None:
3032 mandeep.dh 4739 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4740 
      self.success.write(oprot)
4741 
      oprot.writeFieldEnd()
3431 rajveer 4742 
    if self.ucex is not None:
3032 mandeep.dh 4743 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4744 
      self.ucex.write(oprot)
4745 
      oprot.writeFieldEnd()
4746 
    oprot.writeFieldStop()
4747 
    oprot.writeStructEnd()
4748 
 
3431 rajveer 4749 
  def validate(self):
4750 
    return
4751 
 
4752 
 
3032 mandeep.dh 4753 
  def __repr__(self):
4754 
    L = ['%s=%r' % (key, value)
4755 
      for key, value in self.__dict__.iteritems()]
4756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4757 
 
4758 
  def __eq__(self, other):
4759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4760 
 
4761 
  def __ne__(self, other):
4762 
    return not (self == other)
4763 
 
5326 rajveer 4764 
class getUserByMobileNumber_args:
94 ashish 4765 
  """
4766 
  Attributes:
5326 rajveer 4767 
   - mobileNumber
94 ashish 4768 
  """
4769 
 
4770 
  thrift_spec = (
4771 
    None, # 0
5326 rajveer 4772 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 4773 
  )
4774 
 
5326 rajveer 4775 
  def __init__(self, mobileNumber=None,):
4776 
    self.mobileNumber = mobileNumber
94 ashish 4777 
 
4778 
  def read(self, iprot):
4779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4781 
      return
4782 
    iprot.readStructBegin()
4783 
    while True:
4784 
      (fname, ftype, fid) = iprot.readFieldBegin()
4785 
      if ftype == TType.STOP:
4786 
        break
4787 
      if fid == 1:
5326 rajveer 4788 
        if ftype == TType.I64:
4789 
          self.mobileNumber = iprot.readI64();
94 ashish 4790 
        else:
4791 
          iprot.skip(ftype)
4792 
      else:
4793 
        iprot.skip(ftype)
4794 
      iprot.readFieldEnd()
4795 
    iprot.readStructEnd()
4796 
 
4797 
  def write(self, oprot):
4798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4800 
      return
5326 rajveer 4801 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4802 
    if self.mobileNumber is not None:
4803 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4804 
      oprot.writeI64(self.mobileNumber)
94 ashish 4805 
      oprot.writeFieldEnd()
4806 
    oprot.writeFieldStop()
4807 
    oprot.writeStructEnd()
4808 
 
3431 rajveer 4809 
  def validate(self):
4810 
    return
4811 
 
4812 
 
94 ashish 4813 
  def __repr__(self):
4814 
    L = ['%s=%r' % (key, value)
4815 
      for key, value in self.__dict__.iteritems()]
4816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4817 
 
4818 
  def __eq__(self, other):
4819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4820 
 
4821 
  def __ne__(self, other):
4822 
    return not (self == other)
4823 
 
5326 rajveer 4824 
class getUserByMobileNumber_result:
94 ashish 4825 
  """
4826 
  Attributes:
4827 
   - success
559 chandransh 4828 
   - ucex
94 ashish 4829 
  """
4830 
 
4831 
  thrift_spec = (
559 chandransh 4832 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4833 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4834 
  )
4835 
 
559 chandransh 4836 
  def __init__(self, success=None, ucex=None,):
94 ashish 4837 
    self.success = success
559 chandransh 4838 
    self.ucex = ucex
94 ashish 4839 
 
4840 
  def read(self, iprot):
4841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4843 
      return
4844 
    iprot.readStructBegin()
4845 
    while True:
4846 
      (fname, ftype, fid) = iprot.readFieldBegin()
4847 
      if ftype == TType.STOP:
4848 
        break
4849 
      if fid == 0:
4850 
        if ftype == TType.STRUCT:
559 chandransh 4851 
          self.success = User()
94 ashish 4852 
          self.success.read(iprot)
4853 
        else:
4854 
          iprot.skip(ftype)
4855 
      elif fid == 1:
4856 
        if ftype == TType.STRUCT:
559 chandransh 4857 
          self.ucex = UserContextException()
4858 
          self.ucex.read(iprot)
94 ashish 4859 
        else:
4860 
          iprot.skip(ftype)
4861 
      else:
4862 
        iprot.skip(ftype)
4863 
      iprot.readFieldEnd()
4864 
    iprot.readStructEnd()
4865 
 
4866 
  def write(self, oprot):
4867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4869 
      return
5326 rajveer 4870 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 4871 
    if self.success is not None:
94 ashish 4872 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4873 
      self.success.write(oprot)
4874 
      oprot.writeFieldEnd()
3431 rajveer 4875 
    if self.ucex is not None:
559 chandransh 4876 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4877 
      self.ucex.write(oprot)
94 ashish 4878 
      oprot.writeFieldEnd()
4879 
    oprot.writeFieldStop()
4880 
    oprot.writeStructEnd()
4881 
 
3431 rajveer 4882 
  def validate(self):
4883 
    return
4884 
 
4885 
 
94 ashish 4886 
  def __repr__(self):
4887 
    L = ['%s=%r' % (key, value)
4888 
      for key, value in self.__dict__.iteritems()]
4889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4890 
 
4891 
  def __eq__(self, other):
4892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4893 
 
4894 
  def __ne__(self, other):
4895 
    return not (self == other)
4896 
 
5326 rajveer 4897 
class createUser_args:
94 ashish 4898 
  """
4899 
  Attributes:
559 chandransh 4900 
   - user
94 ashish 4901 
  """
4902 
 
4903 
  thrift_spec = (
4904 
    None, # 0
559 chandransh 4905 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4906 
  )
4907 
 
559 chandransh 4908 
  def __init__(self, user=None,):
4909 
    self.user = user
94 ashish 4910 
 
4911 
  def read(self, iprot):
4912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4914 
      return
4915 
    iprot.readStructBegin()
4916 
    while True:
4917 
      (fname, ftype, fid) = iprot.readFieldBegin()
4918 
      if ftype == TType.STOP:
4919 
        break
4920 
      if fid == 1:
559 chandransh 4921 
        if ftype == TType.STRUCT:
4922 
          self.user = User()
4923 
          self.user.read(iprot)
94 ashish 4924 
        else:
4925 
          iprot.skip(ftype)
4926 
      else:
4927 
        iprot.skip(ftype)
4928 
      iprot.readFieldEnd()
4929 
    iprot.readStructEnd()
4930 
 
4931 
  def write(self, oprot):
4932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4934 
      return
5326 rajveer 4935 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 4936 
    if self.user is not None:
559 chandransh 4937 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4938 
      self.user.write(oprot)
94 ashish 4939 
      oprot.writeFieldEnd()
4940 
    oprot.writeFieldStop()
4941 
    oprot.writeStructEnd()
4942 
 
3431 rajveer 4943 
  def validate(self):
4944 
    return
4945 
 
4946 
 
94 ashish 4947 
  def __repr__(self):
4948 
    L = ['%s=%r' % (key, value)
4949 
      for key, value in self.__dict__.iteritems()]
4950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4951 
 
4952 
  def __eq__(self, other):
4953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4954 
 
4955 
  def __ne__(self, other):
4956 
    return not (self == other)
4957 
 
5326 rajveer 4958 
class createUser_result:
94 ashish 4959 
  """
4960 
  Attributes:
4961 
   - success
559 chandransh 4962 
   - ucex
94 ashish 4963 
  """
4964 
 
4965 
  thrift_spec = (
559 chandransh 4966 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4967 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4968 
  )
4969 
 
559 chandransh 4970 
  def __init__(self, success=None, ucex=None,):
94 ashish 4971 
    self.success = success
559 chandransh 4972 
    self.ucex = ucex
94 ashish 4973 
 
4974 
  def read(self, iprot):
4975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4977 
      return
4978 
    iprot.readStructBegin()
4979 
    while True:
4980 
      (fname, ftype, fid) = iprot.readFieldBegin()
4981 
      if ftype == TType.STOP:
4982 
        break
4983 
      if fid == 0:
4984 
        if ftype == TType.STRUCT:
559 chandransh 4985 
          self.success = User()
94 ashish 4986 
          self.success.read(iprot)
4987 
        else:
4988 
          iprot.skip(ftype)
4989 
      elif fid == 1:
4990 
        if ftype == TType.STRUCT:
559 chandransh 4991 
          self.ucex = UserContextException()
4992 
          self.ucex.read(iprot)
94 ashish 4993 
        else:
4994 
          iprot.skip(ftype)
4995 
      else:
4996 
        iprot.skip(ftype)
4997 
      iprot.readFieldEnd()
4998 
    iprot.readStructEnd()
4999 
 
5000 
  def write(self, oprot):
5001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5003 
      return
5326 rajveer 5004 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5005 
    if self.success is not None:
94 ashish 5006 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5007 
      self.success.write(oprot)
5008 
      oprot.writeFieldEnd()
3431 rajveer 5009 
    if self.ucex is not None:
559 chandransh 5010 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5011 
      self.ucex.write(oprot)
94 ashish 5012 
      oprot.writeFieldEnd()
5013 
    oprot.writeFieldStop()
5014 
    oprot.writeStructEnd()
5015 
 
3431 rajveer 5016 
  def validate(self):
5017 
    return
5018 
 
5019 
 
94 ashish 5020 
  def __repr__(self):
5021 
    L = ['%s=%r' % (key, value)
5022 
      for key, value in self.__dict__.iteritems()]
5023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5024 
 
5025 
  def __eq__(self, other):
5026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5027 
 
5028 
  def __ne__(self, other):
5029 
    return not (self == other)
5030 
 
5326 rajveer 5031 
class updateUser_args:
94 ashish 5032 
  """
5033 
  Attributes:
5326 rajveer 5034 
   - user
94 ashish 5035 
  """
5036 
 
5037 
  thrift_spec = (
5038 
    None, # 0
5326 rajveer 5039 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5040 
  )
5041 
 
5326 rajveer 5042 
  def __init__(self, user=None,):
5043 
    self.user = user
94 ashish 5044 
 
5045 
  def read(self, iprot):
5046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5048 
      return
5049 
    iprot.readStructBegin()
5050 
    while True:
5051 
      (fname, ftype, fid) = iprot.readFieldBegin()
5052 
      if ftype == TType.STOP:
5053 
        break
5054 
      if fid == 1:
5326 rajveer 5055 
        if ftype == TType.STRUCT:
5056 
          self.user = User()
5057 
          self.user.read(iprot)
94 ashish 5058 
        else:
5059 
          iprot.skip(ftype)
5060 
      else:
5061 
        iprot.skip(ftype)
5062 
      iprot.readFieldEnd()
5063 
    iprot.readStructEnd()
5064 
 
5065 
  def write(self, oprot):
5066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5068 
      return
5326 rajveer 5069 
    oprot.writeStructBegin('updateUser_args')
5070 
    if self.user is not None:
5071 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5072 
      self.user.write(oprot)
94 ashish 5073 
      oprot.writeFieldEnd()
5074 
    oprot.writeFieldStop()
5075 
    oprot.writeStructEnd()
5076 
 
3431 rajveer 5077 
  def validate(self):
5078 
    return
5079 
 
5080 
 
94 ashish 5081 
  def __repr__(self):
5082 
    L = ['%s=%r' % (key, value)
5083 
      for key, value in self.__dict__.iteritems()]
5084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5085 
 
5086 
  def __eq__(self, other):
5087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5088 
 
5089 
  def __ne__(self, other):
5090 
    return not (self == other)
5091 
 
5326 rajveer 5092 
class updateUser_result:
94 ashish 5093 
  """
5094 
  Attributes:
5095 
   - success
559 chandransh 5096 
   - ucex
94 ashish 5097 
  """
5098 
 
5099 
  thrift_spec = (
5326 rajveer 5100 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5101 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5102 
  )
5103 
 
559 chandransh 5104 
  def __init__(self, success=None, ucex=None,):
94 ashish 5105 
    self.success = success
559 chandransh 5106 
    self.ucex = ucex
94 ashish 5107 
 
5108 
  def read(self, iprot):
5109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5111 
      return
5112 
    iprot.readStructBegin()
5113 
    while True:
5114 
      (fname, ftype, fid) = iprot.readFieldBegin()
5115 
      if ftype == TType.STOP:
5116 
        break
5117 
      if fid == 0:
5326 rajveer 5118 
        if ftype == TType.STRUCT:
5119 
          self.success = User()
5120 
          self.success.read(iprot)
94 ashish 5121 
        else:
5122 
          iprot.skip(ftype)
5123 
      elif fid == 1:
5124 
        if ftype == TType.STRUCT:
559 chandransh 5125 
          self.ucex = UserContextException()
5126 
          self.ucex.read(iprot)
94 ashish 5127 
        else:
5128 
          iprot.skip(ftype)
5129 
      else:
5130 
        iprot.skip(ftype)
5131 
      iprot.readFieldEnd()
5132 
    iprot.readStructEnd()
5133 
 
5134 
  def write(self, oprot):
5135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5137 
      return
5326 rajveer 5138 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5139 
    if self.success is not None:
5326 rajveer 5140 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5141 
      self.success.write(oprot)
94 ashish 5142 
      oprot.writeFieldEnd()
3431 rajveer 5143 
    if self.ucex is not None:
559 chandransh 5144 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5145 
      self.ucex.write(oprot)
94 ashish 5146 
      oprot.writeFieldEnd()
5147 
    oprot.writeFieldStop()
5148 
    oprot.writeStructEnd()
5149 
 
3431 rajveer 5150 
  def validate(self):
5151 
    return
5152 
 
5153 
 
94 ashish 5154 
  def __repr__(self):
5155 
    L = ['%s=%r' % (key, value)
5156 
      for key, value in self.__dict__.iteritems()]
5157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5158 
 
5159 
  def __eq__(self, other):
5160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5161 
 
5162 
  def __ne__(self, other):
5163 
    return not (self == other)
5164 
 
559 chandransh 5165 
class authenticateUser_args:
94 ashish 5166 
  """
5167 
  Attributes:
5168 
   - email
5169 
   - password
5170 
  """
5171 
 
5172 
  thrift_spec = (
5173 
    None, # 0
5174 
    (1, TType.STRING, 'email', None, None, ), # 1
5175 
    (2, TType.STRING, 'password', None, None, ), # 2
5176 
  )
5177 
 
5178 
  def __init__(self, email=None, password=None,):
5179 
    self.email = email
5180 
    self.password = password
5181 
 
5182 
  def read(self, iprot):
5183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5185 
      return
5186 
    iprot.readStructBegin()
5187 
    while True:
5188 
      (fname, ftype, fid) = iprot.readFieldBegin()
5189 
      if ftype == TType.STOP:
5190 
        break
5191 
      if fid == 1:
5192 
        if ftype == TType.STRING:
5193 
          self.email = iprot.readString();
5194 
        else:
5195 
          iprot.skip(ftype)
5196 
      elif fid == 2:
5197 
        if ftype == TType.STRING:
5198 
          self.password = iprot.readString();
5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      else:
5202 
        iprot.skip(ftype)
5203 
      iprot.readFieldEnd()
5204 
    iprot.readStructEnd()
5205 
 
5206 
  def write(self, oprot):
5207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5209 
      return
559 chandransh 5210 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5211 
    if self.email is not None:
94 ashish 5212 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5213 
      oprot.writeString(self.email)
5214 
      oprot.writeFieldEnd()
3431 rajveer 5215 
    if self.password is not None:
94 ashish 5216 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5217 
      oprot.writeString(self.password)
5218 
      oprot.writeFieldEnd()
5219 
    oprot.writeFieldStop()
5220 
    oprot.writeStructEnd()
5221 
 
3431 rajveer 5222 
  def validate(self):
5223 
    return
5224 
 
5225 
 
94 ashish 5226 
  def __repr__(self):
5227 
    L = ['%s=%r' % (key, value)
5228 
      for key, value in self.__dict__.iteritems()]
5229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5230 
 
5231 
  def __eq__(self, other):
5232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5233 
 
5234 
  def __ne__(self, other):
5235 
    return not (self == other)
5236 
 
559 chandransh 5237 
class authenticateUser_result:
94 ashish 5238 
  """
5239 
  Attributes:
5240 
   - success
559 chandransh 5241 
   - auex
94 ashish 5242 
  """
5243 
 
5244 
  thrift_spec = (
559 chandransh 5245 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5246 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5247 
  )
5248 
 
559 chandransh 5249 
  def __init__(self, success=None, auex=None,):
94 ashish 5250 
    self.success = success
559 chandransh 5251 
    self.auex = auex
94 ashish 5252 
 
5253 
  def read(self, iprot):
5254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5256 
      return
5257 
    iprot.readStructBegin()
5258 
    while True:
5259 
      (fname, ftype, fid) = iprot.readFieldBegin()
5260 
      if ftype == TType.STOP:
5261 
        break
5262 
      if fid == 0:
5263 
        if ftype == TType.STRUCT:
559 chandransh 5264 
          self.success = User()
94 ashish 5265 
          self.success.read(iprot)
5266 
        else:
5267 
          iprot.skip(ftype)
5268 
      elif fid == 1:
5269 
        if ftype == TType.STRUCT:
559 chandransh 5270 
          self.auex = AuthenticationException()
5271 
          self.auex.read(iprot)
94 ashish 5272 
        else:
5273 
          iprot.skip(ftype)
5274 
      else:
5275 
        iprot.skip(ftype)
5276 
      iprot.readFieldEnd()
5277 
    iprot.readStructEnd()
5278 
 
5279 
  def write(self, oprot):
5280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5282 
      return
559 chandransh 5283 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5284 
    if self.success is not None:
94 ashish 5285 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5286 
      self.success.write(oprot)
5287 
      oprot.writeFieldEnd()
3431 rajveer 5288 
    if self.auex is not None:
559 chandransh 5289 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5290 
      self.auex.write(oprot)
94 ashish 5291 
      oprot.writeFieldEnd()
5292 
    oprot.writeFieldStop()
5293 
    oprot.writeStructEnd()
5294 
 
3431 rajveer 5295 
  def validate(self):
5296 
    return
5297 
 
5298 
 
94 ashish 5299 
  def __repr__(self):
5300 
    L = ['%s=%r' % (key, value)
5301 
      for key, value in self.__dict__.iteritems()]
5302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5303 
 
5304 
  def __eq__(self, other):
5305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5306 
 
5307 
  def __ne__(self, other):
5308 
    return not (self == other)
5309 
 
559 chandransh 5310 
class userExists_args:
122 ashish 5311 
  """
5312 
  Attributes:
559 chandransh 5313 
   - email
122 ashish 5314 
  """
5315 
 
5316 
  thrift_spec = (
5317 
    None, # 0
559 chandransh 5318 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5319 
  )
5320 
 
559 chandransh 5321 
  def __init__(self, email=None,):
5322 
    self.email = email
122 ashish 5323 
 
5324 
  def read(self, iprot):
5325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5327 
      return
5328 
    iprot.readStructBegin()
5329 
    while True:
5330 
      (fname, ftype, fid) = iprot.readFieldBegin()
5331 
      if ftype == TType.STOP:
5332 
        break
5333 
      if fid == 1:
5334 
        if ftype == TType.STRING:
559 chandransh 5335 
          self.email = iprot.readString();
122 ashish 5336 
        else:
5337 
          iprot.skip(ftype)
559 chandransh 5338 
      else:
5339 
        iprot.skip(ftype)
5340 
      iprot.readFieldEnd()
5341 
    iprot.readStructEnd()
5342 
 
5343 
  def write(self, oprot):
5344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5346 
      return
5347 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5348 
    if self.email is not None:
559 chandransh 5349 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5350 
      oprot.writeString(self.email)
5351 
      oprot.writeFieldEnd()
5352 
    oprot.writeFieldStop()
5353 
    oprot.writeStructEnd()
5354 
 
3431 rajveer 5355 
  def validate(self):
5356 
    return
5357 
 
5358 
 
559 chandransh 5359 
  def __repr__(self):
5360 
    L = ['%s=%r' % (key, value)
5361 
      for key, value in self.__dict__.iteritems()]
5362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5363 
 
5364 
  def __eq__(self, other):
5365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5366 
 
5367 
  def __ne__(self, other):
5368 
    return not (self == other)
5369 
 
5370 
class userExists_result:
5371 
  """
5372 
  Attributes:
5373 
   - success
5374 
   - ucx
5375 
  """
5376 
 
5377 
  thrift_spec = (
5378 
    (0, TType.BOOL, 'success', None, None, ), # 0
5379 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5380 
  )
5381 
 
5382 
  def __init__(self, success=None, ucx=None,):
5383 
    self.success = success
5384 
    self.ucx = ucx
5385 
 
5386 
  def read(self, iprot):
5387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5389 
      return
5390 
    iprot.readStructBegin()
5391 
    while True:
5392 
      (fname, ftype, fid) = iprot.readFieldBegin()
5393 
      if ftype == TType.STOP:
5394 
        break
5395 
      if fid == 0:
5396 
        if ftype == TType.BOOL:
5397 
          self.success = iprot.readBool();
5398 
        else:
5399 
          iprot.skip(ftype)
5400 
      elif fid == 1:
5401 
        if ftype == TType.STRUCT:
5402 
          self.ucx = UserContextException()
5403 
          self.ucx.read(iprot)
5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      else:
5407 
        iprot.skip(ftype)
5408 
      iprot.readFieldEnd()
5409 
    iprot.readStructEnd()
5410 
 
5411 
  def write(self, oprot):
5412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5414 
      return
5415 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5416 
    if self.success is not None:
559 chandransh 5417 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5418 
      oprot.writeBool(self.success)
5419 
      oprot.writeFieldEnd()
3431 rajveer 5420 
    if self.ucx is not None:
559 chandransh 5421 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5422 
      self.ucx.write(oprot)
5423 
      oprot.writeFieldEnd()
5424 
    oprot.writeFieldStop()
5425 
    oprot.writeStructEnd()
5426 
 
3431 rajveer 5427 
  def validate(self):
5428 
    return
5429 
 
5430 
 
559 chandransh 5431 
  def __repr__(self):
5432 
    L = ['%s=%r' % (key, value)
5433 
      for key, value in self.__dict__.iteritems()]
5434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5435 
 
5436 
  def __eq__(self, other):
5437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5438 
 
5439 
  def __ne__(self, other):
5440 
    return not (self == other)
5441 
 
5442 
class addAddressForUser_args:
5443 
  """
5444 
  Attributes:
5445 
   - userId
5446 
   - address
5447 
   - setDefault
5448 
  """
5449 
 
5450 
  thrift_spec = (
5451 
    None, # 0
5452 
    (1, TType.I64, 'userId', None, None, ), # 1
5453 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5454 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5455 
  )
5456 
 
567 rajveer 5457 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5458 
    self.userId = userId
5459 
    self.address = address
5460 
    self.setDefault = setDefault
5461 
 
5462 
  def read(self, iprot):
5463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5465 
      return
5466 
    iprot.readStructBegin()
5467 
    while True:
5468 
      (fname, ftype, fid) = iprot.readFieldBegin()
5469 
      if ftype == TType.STOP:
5470 
        break
5471 
      if fid == 1:
5472 
        if ftype == TType.I64:
5473 
          self.userId = iprot.readI64();
5474 
        else:
5475 
          iprot.skip(ftype)
122 ashish 5476 
      elif fid == 2:
559 chandransh 5477 
        if ftype == TType.STRUCT:
5478 
          self.address = Address()
5479 
          self.address.read(iprot)
122 ashish 5480 
        else:
5481 
          iprot.skip(ftype)
5482 
      elif fid == 3:
5483 
        if ftype == TType.BOOL:
559 chandransh 5484 
          self.setDefault = iprot.readBool();
122 ashish 5485 
        else:
5486 
          iprot.skip(ftype)
5487 
      else:
5488 
        iprot.skip(ftype)
5489 
      iprot.readFieldEnd()
5490 
    iprot.readStructEnd()
5491 
 
5492 
  def write(self, oprot):
5493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5495 
      return
559 chandransh 5496 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5497 
    if self.userId is not None:
559 chandransh 5498 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5499 
      oprot.writeI64(self.userId)
122 ashish 5500 
      oprot.writeFieldEnd()
3431 rajveer 5501 
    if self.address is not None:
559 chandransh 5502 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5503 
      self.address.write(oprot)
122 ashish 5504 
      oprot.writeFieldEnd()
3431 rajveer 5505 
    if self.setDefault is not None:
567 rajveer 5506 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5507 
      oprot.writeBool(self.setDefault)
5508 
      oprot.writeFieldEnd()
122 ashish 5509 
    oprot.writeFieldStop()
5510 
    oprot.writeStructEnd()
5511 
 
3431 rajveer 5512 
  def validate(self):
5513 
    return
5514 
 
5515 
 
122 ashish 5516 
  def __repr__(self):
5517 
    L = ['%s=%r' % (key, value)
5518 
      for key, value in self.__dict__.iteritems()]
5519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5520 
 
5521 
  def __eq__(self, other):
5522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5523 
 
5524 
  def __ne__(self, other):
5525 
    return not (self == other)
5526 
 
559 chandransh 5527 
class addAddressForUser_result:
122 ashish 5528 
  """
5529 
  Attributes:
5530 
   - success
559 chandransh 5531 
   - ucx
122 ashish 5532 
  """
5533 
 
5534 
  thrift_spec = (
567 rajveer 5535 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5536 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5537 
  )
5538 
 
559 chandransh 5539 
  def __init__(self, success=None, ucx=None,):
122 ashish 5540 
    self.success = success
559 chandransh 5541 
    self.ucx = ucx
122 ashish 5542 
 
5543 
  def read(self, iprot):
5544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5546 
      return
5547 
    iprot.readStructBegin()
5548 
    while True:
5549 
      (fname, ftype, fid) = iprot.readFieldBegin()
5550 
      if ftype == TType.STOP:
5551 
        break
5552 
      if fid == 0:
567 rajveer 5553 
        if ftype == TType.I64:
5554 
          self.success = iprot.readI64();
122 ashish 5555 
        else:
5556 
          iprot.skip(ftype)
5557 
      elif fid == 1:
5558 
        if ftype == TType.STRUCT:
559 chandransh 5559 
          self.ucx = UserContextException()
5560 
          self.ucx.read(iprot)
122 ashish 5561 
        else:
5562 
          iprot.skip(ftype)
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
559 chandransh 5572 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 5573 
    if self.success is not None:
567 rajveer 5574 
      oprot.writeFieldBegin('success', TType.I64, 0)
5575 
      oprot.writeI64(self.success)
122 ashish 5576 
      oprot.writeFieldEnd()
3431 rajveer 5577 
    if self.ucx is not None:
559 chandransh 5578 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5579 
      self.ucx.write(oprot)
122 ashish 5580 
      oprot.writeFieldEnd()
5581 
    oprot.writeFieldStop()
5582 
    oprot.writeStructEnd()
5583 
 
3431 rajveer 5584 
  def validate(self):
5585 
    return
5586 
 
5587 
 
122 ashish 5588 
  def __repr__(self):
5589 
    L = ['%s=%r' % (key, value)
5590 
      for key, value in self.__dict__.iteritems()]
5591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5592 
 
5593 
  def __eq__(self, other):
5594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5595 
 
5596 
  def __ne__(self, other):
5597 
    return not (self == other)
5598 
 
559 chandransh 5599 
class removeAddressForUser_args:
94 ashish 5600 
  """
5601 
  Attributes:
559 chandransh 5602 
   - userid
5603 
   - addressId
94 ashish 5604 
  """
5605 
 
5606 
  thrift_spec = (
5607 
    None, # 0
559 chandransh 5608 
    (1, TType.I64, 'userid', None, None, ), # 1
5609 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5610 
  )
5611 
 
559 chandransh 5612 
  def __init__(self, userid=None, addressId=None,):
5613 
    self.userid = userid
5614 
    self.addressId = addressId
94 ashish 5615 
 
5616 
  def read(self, iprot):
5617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5619 
      return
5620 
    iprot.readStructBegin()
5621 
    while True:
5622 
      (fname, ftype, fid) = iprot.readFieldBegin()
5623 
      if ftype == TType.STOP:
5624 
        break
5625 
      if fid == 1:
559 chandransh 5626 
        if ftype == TType.I64:
5627 
          self.userid = iprot.readI64();
94 ashish 5628 
        else:
5629 
          iprot.skip(ftype)
559 chandransh 5630 
      elif fid == 2:
5631 
        if ftype == TType.I64:
5632 
          self.addressId = iprot.readI64();
5633 
        else:
5634 
          iprot.skip(ftype)
94 ashish 5635 
      else:
5636 
        iprot.skip(ftype)
5637 
      iprot.readFieldEnd()
5638 
    iprot.readStructEnd()
5639 
 
5640 
  def write(self, oprot):
5641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5643 
      return
559 chandransh 5644 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 5645 
    if self.userid is not None:
559 chandransh 5646 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5647 
      oprot.writeI64(self.userid)
94 ashish 5648 
      oprot.writeFieldEnd()
3431 rajveer 5649 
    if self.addressId is not None:
559 chandransh 5650 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5651 
      oprot.writeI64(self.addressId)
5652 
      oprot.writeFieldEnd()
94 ashish 5653 
    oprot.writeFieldStop()
5654 
    oprot.writeStructEnd()
5655 
 
3431 rajveer 5656 
  def validate(self):
5657 
    return
5658 
 
5659 
 
94 ashish 5660 
  def __repr__(self):
5661 
    L = ['%s=%r' % (key, value)
5662 
      for key, value in self.__dict__.iteritems()]
5663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5664 
 
5665 
  def __eq__(self, other):
5666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5667 
 
5668 
  def __ne__(self, other):
5669 
    return not (self == other)
5670 
 
559 chandransh 5671 
class removeAddressForUser_result:
94 ashish 5672 
  """
5673 
  Attributes:
5674 
   - success
5675 
   - ucx
5676 
  """
5677 
 
5678 
  thrift_spec = (
5679 
    (0, TType.BOOL, 'success', None, None, ), # 0
5680 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5681 
  )
5682 
 
5683 
  def __init__(self, success=None, ucx=None,):
5684 
    self.success = success
5685 
    self.ucx = ucx
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 == 0:
5697 
        if ftype == TType.BOOL:
5698 
          self.success = iprot.readBool();
5699 
        else:
5700 
          iprot.skip(ftype)
5701 
      elif fid == 1:
5702 
        if ftype == TType.STRUCT:
5703 
          self.ucx = UserContextException()
5704 
          self.ucx.read(iprot)
5705 
        else:
5706 
          iprot.skip(ftype)
5707 
      else:
5708 
        iprot.skip(ftype)
5709 
      iprot.readFieldEnd()
5710 
    iprot.readStructEnd()
5711 
 
5712 
  def write(self, oprot):
5713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5715 
      return
559 chandransh 5716 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 5717 
    if self.success is not None:
94 ashish 5718 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5719 
      oprot.writeBool(self.success)
5720 
      oprot.writeFieldEnd()
3431 rajveer 5721 
    if self.ucx is not None:
94 ashish 5722 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5723 
      self.ucx.write(oprot)
5724 
      oprot.writeFieldEnd()
5725 
    oprot.writeFieldStop()
5726 
    oprot.writeStructEnd()
5727 
 
3431 rajveer 5728 
  def validate(self):
5729 
    return
5730 
 
5731 
 
94 ashish 5732 
  def __repr__(self):
5733 
    L = ['%s=%r' % (key, value)
5734 
      for key, value in self.__dict__.iteritems()]
5735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5736 
 
5737 
  def __eq__(self, other):
5738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5739 
 
5740 
  def __ne__(self, other):
5741 
    return not (self == other)
5742 
 
559 chandransh 5743 
class setUserAsLoggedIn_args:
94 ashish 5744 
  """
5745 
  Attributes:
559 chandransh 5746 
   - userId
94 ashish 5747 
   - timestamp
5748 
  """
5749 
 
5750 
  thrift_spec = (
5751 
    None, # 0
559 chandransh 5752 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5753 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5754 
  )
5755 
 
559 chandransh 5756 
  def __init__(self, userId=None, timestamp=None,):
5757 
    self.userId = userId
94 ashish 5758 
    self.timestamp = timestamp
5759 
 
5760 
  def read(self, iprot):
5761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5763 
      return
5764 
    iprot.readStructBegin()
5765 
    while True:
5766 
      (fname, ftype, fid) = iprot.readFieldBegin()
5767 
      if ftype == TType.STOP:
5768 
        break
5769 
      if fid == 1:
559 chandransh 5770 
        if ftype == TType.I64:
5771 
          self.userId = iprot.readI64();
94 ashish 5772 
        else:
5773 
          iprot.skip(ftype)
5774 
      elif fid == 2:
5775 
        if ftype == TType.I64:
5776 
          self.timestamp = iprot.readI64();
5777 
        else:
5778 
          iprot.skip(ftype)
5779 
      else:
5780 
        iprot.skip(ftype)
5781 
      iprot.readFieldEnd()
5782 
    iprot.readStructEnd()
5783 
 
5784 
  def write(self, oprot):
5785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5787 
      return
559 chandransh 5788 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 5789 
    if self.userId is not None:
559 chandransh 5790 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5791 
      oprot.writeI64(self.userId)
94 ashish 5792 
      oprot.writeFieldEnd()
3431 rajveer 5793 
    if self.timestamp is not None:
94 ashish 5794 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5795 
      oprot.writeI64(self.timestamp)
5796 
      oprot.writeFieldEnd()
5797 
    oprot.writeFieldStop()
5798 
    oprot.writeStructEnd()
5799 
 
3431 rajveer 5800 
  def validate(self):
5801 
    return
5802 
 
5803 
 
94 ashish 5804 
  def __repr__(self):
5805 
    L = ['%s=%r' % (key, value)
5806 
      for key, value in self.__dict__.iteritems()]
5807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5808 
 
5809 
  def __eq__(self, other):
5810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5811 
 
5812 
  def __ne__(self, other):
5813 
    return not (self == other)
5814 
 
559 chandransh 5815 
class setUserAsLoggedIn_result:
94 ashish 5816 
  """
5817 
  Attributes:
5818 
   - success
5819 
   - ucx
5820 
  """
5821 
 
5822 
  thrift_spec = (
5823 
    (0, TType.BOOL, 'success', None, None, ), # 0
5824 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5825 
  )
5826 
 
5827 
  def __init__(self, success=None, ucx=None,):
5828 
    self.success = success
5829 
    self.ucx = ucx
5830 
 
5831 
  def read(self, iprot):
5832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5834 
      return
5835 
    iprot.readStructBegin()
5836 
    while True:
5837 
      (fname, ftype, fid) = iprot.readFieldBegin()
5838 
      if ftype == TType.STOP:
5839 
        break
5840 
      if fid == 0:
5841 
        if ftype == TType.BOOL:
5842 
          self.success = iprot.readBool();
5843 
        else:
5844 
          iprot.skip(ftype)
5845 
      elif fid == 1:
5846 
        if ftype == TType.STRUCT:
5847 
          self.ucx = UserContextException()
5848 
          self.ucx.read(iprot)
5849 
        else:
5850 
          iprot.skip(ftype)
5851 
      else:
5852 
        iprot.skip(ftype)
5853 
      iprot.readFieldEnd()
5854 
    iprot.readStructEnd()
5855 
 
5856 
  def write(self, oprot):
5857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5859 
      return
559 chandransh 5860 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 5861 
    if self.success is not None:
94 ashish 5862 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5863 
      oprot.writeBool(self.success)
5864 
      oprot.writeFieldEnd()
3431 rajveer 5865 
    if self.ucx is not None:
94 ashish 5866 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5867 
      self.ucx.write(oprot)
5868 
      oprot.writeFieldEnd()
5869 
    oprot.writeFieldStop()
5870 
    oprot.writeStructEnd()
5871 
 
3431 rajveer 5872 
  def validate(self):
5873 
    return
5874 
 
5875 
 
94 ashish 5876 
  def __repr__(self):
5877 
    L = ['%s=%r' % (key, value)
5878 
      for key, value in self.__dict__.iteritems()]
5879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5880 
 
5881 
  def __eq__(self, other):
5882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5883 
 
5884 
  def __ne__(self, other):
5885 
    return not (self == other)
5886 
 
559 chandransh 5887 
class setUserAsLoggedOut_args:
94 ashish 5888 
  """
5889 
  Attributes:
5890 
   - userid
5891 
   - timestamp
5892 
  """
5893 
 
5894 
  thrift_spec = (
5895 
    None, # 0
559 chandransh 5896 
    (1, TType.I64, 'userid', None, None, ), # 1
5897 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5898 
  )
5899 
 
559 chandransh 5900 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5901 
    self.userid = userid
5902 
    self.timestamp = timestamp
5903 
 
5904 
  def read(self, iprot):
5905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5907 
      return
5908 
    iprot.readStructBegin()
5909 
    while True:
5910 
      (fname, ftype, fid) = iprot.readFieldBegin()
5911 
      if ftype == TType.STOP:
5912 
        break
5913 
      if fid == 1:
5914 
        if ftype == TType.I64:
5915 
          self.userid = iprot.readI64();
5916 
        else:
5917 
          iprot.skip(ftype)
559 chandransh 5918 
      elif fid == 2:
94 ashish 5919 
        if ftype == TType.I64:
5920 
          self.timestamp = iprot.readI64();
5921 
        else:
5922 
          iprot.skip(ftype)
5923 
      else:
5924 
        iprot.skip(ftype)
5925 
      iprot.readFieldEnd()
5926 
    iprot.readStructEnd()
5927 
 
5928 
  def write(self, oprot):
5929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5931 
      return
559 chandransh 5932 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 5933 
    if self.userid is not None:
559 chandransh 5934 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5935 
      oprot.writeI64(self.userid)
5936 
      oprot.writeFieldEnd()
3431 rajveer 5937 
    if self.timestamp is not None:
559 chandransh 5938 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5939 
      oprot.writeI64(self.timestamp)
5940 
      oprot.writeFieldEnd()
5941 
    oprot.writeFieldStop()
5942 
    oprot.writeStructEnd()
5943 
 
3431 rajveer 5944 
  def validate(self):
5945 
    return
5946 
 
5947 
 
94 ashish 5948 
  def __repr__(self):
5949 
    L = ['%s=%r' % (key, value)
5950 
      for key, value in self.__dict__.iteritems()]
5951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5952 
 
5953 
  def __eq__(self, other):
5954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5955 
 
5956 
  def __ne__(self, other):
5957 
    return not (self == other)
5958 
 
559 chandransh 5959 
class setUserAsLoggedOut_result:
94 ashish 5960 
  """
5961 
  Attributes:
5962 
   - success
5963 
   - ucx
5964 
  """
5965 
 
5966 
  thrift_spec = (
5967 
    (0, TType.BOOL, 'success', None, None, ), # 0
5968 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5969 
  )
5970 
 
5971 
  def __init__(self, success=None, ucx=None,):
5972 
    self.success = success
5973 
    self.ucx = ucx
5974 
 
5975 
  def read(self, iprot):
5976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5978 
      return
5979 
    iprot.readStructBegin()
5980 
    while True:
5981 
      (fname, ftype, fid) = iprot.readFieldBegin()
5982 
      if ftype == TType.STOP:
5983 
        break
5984 
      if fid == 0:
5985 
        if ftype == TType.BOOL:
5986 
          self.success = iprot.readBool();
5987 
        else:
5988 
          iprot.skip(ftype)
5989 
      elif fid == 1:
5990 
        if ftype == TType.STRUCT:
5991 
          self.ucx = UserContextException()
5992 
          self.ucx.read(iprot)
5993 
        else:
5994 
          iprot.skip(ftype)
5995 
      else:
5996 
        iprot.skip(ftype)
5997 
      iprot.readFieldEnd()
5998 
    iprot.readStructEnd()
5999 
 
6000 
  def write(self, oprot):
6001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6003 
      return
559 chandransh 6004 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6005 
    if self.success is not None:
94 ashish 6006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6007 
      oprot.writeBool(self.success)
6008 
      oprot.writeFieldEnd()
3431 rajveer 6009 
    if self.ucx is not None:
94 ashish 6010 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6011 
      self.ucx.write(oprot)
6012 
      oprot.writeFieldEnd()
6013 
    oprot.writeFieldStop()
6014 
    oprot.writeStructEnd()
6015 
 
3431 rajveer 6016 
  def validate(self):
6017 
    return
6018 
 
6019 
 
94 ashish 6020 
  def __repr__(self):
6021 
    L = ['%s=%r' % (key, value)
6022 
      for key, value in self.__dict__.iteritems()]
6023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6024 
 
6025 
  def __eq__(self, other):
6026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6027 
 
6028 
  def __ne__(self, other):
6029 
    return not (self == other)
6030 
 
559 chandransh 6031 
class setDefaultAddress_args:
94 ashish 6032 
  """
6033 
  Attributes:
6034 
   - userid
6035 
   - addressId
6036 
  """
6037 
 
6038 
  thrift_spec = (
6039 
    None, # 0
6040 
    (1, TType.I64, 'userid', None, None, ), # 1
6041 
    (2, TType.I64, 'addressId', None, None, ), # 2
6042 
  )
6043 
 
6044 
  def __init__(self, userid=None, addressId=None,):
6045 
    self.userid = userid
6046 
    self.addressId = addressId
6047 
 
6048 
  def read(self, iprot):
6049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6051 
      return
6052 
    iprot.readStructBegin()
6053 
    while True:
6054 
      (fname, ftype, fid) = iprot.readFieldBegin()
6055 
      if ftype == TType.STOP:
6056 
        break
6057 
      if fid == 1:
6058 
        if ftype == TType.I64:
6059 
          self.userid = iprot.readI64();
6060 
        else:
6061 
          iprot.skip(ftype)
6062 
      elif fid == 2:
6063 
        if ftype == TType.I64:
6064 
          self.addressId = iprot.readI64();
6065 
        else:
6066 
          iprot.skip(ftype)
6067 
      else:
6068 
        iprot.skip(ftype)
6069 
      iprot.readFieldEnd()
6070 
    iprot.readStructEnd()
6071 
 
6072 
  def write(self, oprot):
6073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6075 
      return
559 chandransh 6076 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6077 
    if self.userid is not None:
94 ashish 6078 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6079 
      oprot.writeI64(self.userid)
6080 
      oprot.writeFieldEnd()
3431 rajveer 6081 
    if self.addressId is not None:
94 ashish 6082 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6083 
      oprot.writeI64(self.addressId)
6084 
      oprot.writeFieldEnd()
6085 
    oprot.writeFieldStop()
6086 
    oprot.writeStructEnd()
6087 
 
3431 rajveer 6088 
  def validate(self):
6089 
    return
6090 
 
6091 
 
94 ashish 6092 
  def __repr__(self):
6093 
    L = ['%s=%r' % (key, value)
6094 
      for key, value in self.__dict__.iteritems()]
6095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6096 
 
6097 
  def __eq__(self, other):
6098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6099 
 
6100 
  def __ne__(self, other):
6101 
    return not (self == other)
6102 
 
559 chandransh 6103 
class setDefaultAddress_result:
94 ashish 6104 
  """
6105 
  Attributes:
6106 
   - success
6107 
   - ucx
6108 
  """
6109 
 
6110 
  thrift_spec = (
6111 
    (0, TType.BOOL, 'success', None, None, ), # 0
6112 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6113 
  )
6114 
 
6115 
  def __init__(self, success=None, ucx=None,):
6116 
    self.success = success
6117 
    self.ucx = ucx
6118 
 
6119 
  def read(self, iprot):
6120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6122 
      return
6123 
    iprot.readStructBegin()
6124 
    while True:
6125 
      (fname, ftype, fid) = iprot.readFieldBegin()
6126 
      if ftype == TType.STOP:
6127 
        break
6128 
      if fid == 0:
6129 
        if ftype == TType.BOOL:
6130 
          self.success = iprot.readBool();
6131 
        else:
6132 
          iprot.skip(ftype)
6133 
      elif fid == 1:
6134 
        if ftype == TType.STRUCT:
6135 
          self.ucx = UserContextException()
6136 
          self.ucx.read(iprot)
6137 
        else:
6138 
          iprot.skip(ftype)
6139 
      else:
6140 
        iprot.skip(ftype)
6141 
      iprot.readFieldEnd()
6142 
    iprot.readStructEnd()
6143 
 
6144 
  def write(self, oprot):
6145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6147 
      return
559 chandransh 6148 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6149 
    if self.success is not None:
94 ashish 6150 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6151 
      oprot.writeBool(self.success)
6152 
      oprot.writeFieldEnd()
3431 rajveer 6153 
    if self.ucx is not None:
94 ashish 6154 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6155 
      self.ucx.write(oprot)
6156 
      oprot.writeFieldEnd()
6157 
    oprot.writeFieldStop()
6158 
    oprot.writeStructEnd()
6159 
 
3431 rajveer 6160 
  def validate(self):
6161 
    return
6162 
 
6163 
 
94 ashish 6164 
  def __repr__(self):
6165 
    L = ['%s=%r' % (key, value)
6166 
      for key, value in self.__dict__.iteritems()]
6167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6168 
 
6169 
  def __eq__(self, other):
6170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6171 
 
6172 
  def __ne__(self, other):
6173 
    return not (self == other)
6174 
 
559 chandransh 6175 
class updatePassword_args:
94 ashish 6176 
  """
6177 
  Attributes:
559 chandransh 6178 
   - userid
594 rajveer 6179 
   - oldPassword
6180 
   - newPassword
94 ashish 6181 
  """
6182 
 
6183 
  thrift_spec = (
6184 
    None, # 0
559 chandransh 6185 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6186 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6187 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6188 
  )
6189 
 
594 rajveer 6190 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6191 
    self.userid = userid
594 rajveer 6192 
    self.oldPassword = oldPassword
6193 
    self.newPassword = newPassword
94 ashish 6194 
 
6195 
  def read(self, iprot):
6196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6198 
      return
6199 
    iprot.readStructBegin()
6200 
    while True:
6201 
      (fname, ftype, fid) = iprot.readFieldBegin()
6202 
      if ftype == TType.STOP:
6203 
        break
6204 
      if fid == 1:
6205 
        if ftype == TType.I64:
559 chandransh 6206 
          self.userid = iprot.readI64();
94 ashish 6207 
        else:
6208 
          iprot.skip(ftype)
6209 
      elif fid == 2:
559 chandransh 6210 
        if ftype == TType.STRING:
594 rajveer 6211 
          self.oldPassword = iprot.readString();
94 ashish 6212 
        else:
6213 
          iprot.skip(ftype)
594 rajveer 6214 
      elif fid == 3:
6215 
        if ftype == TType.STRING:
6216 
          self.newPassword = iprot.readString();
6217 
        else:
6218 
          iprot.skip(ftype)
94 ashish 6219 
      else:
6220 
        iprot.skip(ftype)
6221 
      iprot.readFieldEnd()
6222 
    iprot.readStructEnd()
6223 
 
6224 
  def write(self, oprot):
6225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6227 
      return
559 chandransh 6228 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6229 
    if self.userid is not None:
559 chandransh 6230 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6231 
      oprot.writeI64(self.userid)
94 ashish 6232 
      oprot.writeFieldEnd()
3431 rajveer 6233 
    if self.oldPassword is not None:
594 rajveer 6234 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6235 
      oprot.writeString(self.oldPassword)
94 ashish 6236 
      oprot.writeFieldEnd()
3431 rajveer 6237 
    if self.newPassword is not None:
594 rajveer 6238 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6239 
      oprot.writeString(self.newPassword)
6240 
      oprot.writeFieldEnd()
94 ashish 6241 
    oprot.writeFieldStop()
6242 
    oprot.writeStructEnd()
6243 
 
3431 rajveer 6244 
  def validate(self):
6245 
    return
6246 
 
6247 
 
94 ashish 6248 
  def __repr__(self):
6249 
    L = ['%s=%r' % (key, value)
6250 
      for key, value in self.__dict__.iteritems()]
6251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6252 
 
6253 
  def __eq__(self, other):
6254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6255 
 
6256 
  def __ne__(self, other):
6257 
    return not (self == other)
6258 
 
559 chandransh 6259 
class updatePassword_result:
94 ashish 6260 
  """
6261 
  Attributes:
6262 
   - success
6263 
   - ucx
6264 
  """
6265 
 
6266 
  thrift_spec = (
6267 
    (0, TType.BOOL, 'success', None, None, ), # 0
6268 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6269 
  )
6270 
 
6271 
  def __init__(self, success=None, ucx=None,):
6272 
    self.success = success
6273 
    self.ucx = ucx
6274 
 
6275 
  def read(self, iprot):
6276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6278 
      return
6279 
    iprot.readStructBegin()
6280 
    while True:
6281 
      (fname, ftype, fid) = iprot.readFieldBegin()
6282 
      if ftype == TType.STOP:
6283 
        break
6284 
      if fid == 0:
6285 
        if ftype == TType.BOOL:
6286 
          self.success = iprot.readBool();
6287 
        else:
6288 
          iprot.skip(ftype)
6289 
      elif fid == 1:
6290 
        if ftype == TType.STRUCT:
6291 
          self.ucx = UserContextException()
6292 
          self.ucx.read(iprot)
6293 
        else:
6294 
          iprot.skip(ftype)
6295 
      else:
6296 
        iprot.skip(ftype)
6297 
      iprot.readFieldEnd()
6298 
    iprot.readStructEnd()
6299 
 
6300 
  def write(self, oprot):
6301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6303 
      return
559 chandransh 6304 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6305 
    if self.success is not None:
94 ashish 6306 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6307 
      oprot.writeBool(self.success)
6308 
      oprot.writeFieldEnd()
3431 rajveer 6309 
    if self.ucx is not None:
94 ashish 6310 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6311 
      self.ucx.write(oprot)
6312 
      oprot.writeFieldEnd()
6313 
    oprot.writeFieldStop()
6314 
    oprot.writeStructEnd()
6315 
 
3431 rajveer 6316 
  def validate(self):
6317 
    return
6318 
 
6319 
 
94 ashish 6320 
  def __repr__(self):
6321 
    L = ['%s=%r' % (key, value)
6322 
      for key, value in self.__dict__.iteritems()]
6323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6324 
 
6325 
  def __eq__(self, other):
6326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6327 
 
6328 
  def __ne__(self, other):
6329 
    return not (self == other)
6330 
 
581 rajveer 6331 
class forgotPassword_args:
6332 
  """
6333 
  Attributes:
6334 
   - email
884 rajveer 6335 
   - newPassword
581 rajveer 6336 
  """
6337 
 
6338 
  thrift_spec = (
6339 
    None, # 0
6340 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6341 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6342 
  )
6343 
 
884 rajveer 6344 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6345 
    self.email = email
884 rajveer 6346 
    self.newPassword = newPassword
581 rajveer 6347 
 
6348 
  def read(self, iprot):
6349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6351 
      return
6352 
    iprot.readStructBegin()
6353 
    while True:
6354 
      (fname, ftype, fid) = iprot.readFieldBegin()
6355 
      if ftype == TType.STOP:
6356 
        break
6357 
      if fid == 1:
6358 
        if ftype == TType.STRING:
6359 
          self.email = iprot.readString();
6360 
        else:
6361 
          iprot.skip(ftype)
884 rajveer 6362 
      elif fid == 2:
6363 
        if ftype == TType.STRING:
6364 
          self.newPassword = iprot.readString();
6365 
        else:
6366 
          iprot.skip(ftype)
581 rajveer 6367 
      else:
6368 
        iprot.skip(ftype)
6369 
      iprot.readFieldEnd()
6370 
    iprot.readStructEnd()
6371 
 
6372 
  def write(self, oprot):
6373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6375 
      return
6376 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6377 
    if self.email is not None:
581 rajveer 6378 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6379 
      oprot.writeString(self.email)
6380 
      oprot.writeFieldEnd()
3431 rajveer 6381 
    if self.newPassword is not None:
884 rajveer 6382 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6383 
      oprot.writeString(self.newPassword)
6384 
      oprot.writeFieldEnd()
581 rajveer 6385 
    oprot.writeFieldStop()
6386 
    oprot.writeStructEnd()
6387 
 
3431 rajveer 6388 
  def validate(self):
6389 
    return
6390 
 
6391 
 
581 rajveer 6392 
  def __repr__(self):
6393 
    L = ['%s=%r' % (key, value)
6394 
      for key, value in self.__dict__.iteritems()]
6395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6396 
 
6397 
  def __eq__(self, other):
6398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6399 
 
6400 
  def __ne__(self, other):
6401 
    return not (self == other)
6402 
 
6403 
class forgotPassword_result:
6404 
  """
6405 
  Attributes:
6406 
   - success
6407 
   - ucx
6408 
  """
6409 
 
6410 
  thrift_spec = (
6411 
    (0, TType.BOOL, 'success', None, None, ), # 0
6412 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6413 
  )
6414 
 
6415 
  def __init__(self, success=None, ucx=None,):
6416 
    self.success = success
6417 
    self.ucx = ucx
6418 
 
6419 
  def read(self, iprot):
6420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6422 
      return
6423 
    iprot.readStructBegin()
6424 
    while True:
6425 
      (fname, ftype, fid) = iprot.readFieldBegin()
6426 
      if ftype == TType.STOP:
6427 
        break
6428 
      if fid == 0:
6429 
        if ftype == TType.BOOL:
6430 
          self.success = iprot.readBool();
6431 
        else:
6432 
          iprot.skip(ftype)
6433 
      elif fid == 1:
6434 
        if ftype == TType.STRUCT:
6435 
          self.ucx = UserContextException()
6436 
          self.ucx.read(iprot)
6437 
        else:
6438 
          iprot.skip(ftype)
6439 
      else:
6440 
        iprot.skip(ftype)
6441 
      iprot.readFieldEnd()
6442 
    iprot.readStructEnd()
6443 
 
6444 
  def write(self, oprot):
6445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6447 
      return
6448 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6449 
    if self.success is not None:
581 rajveer 6450 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6451 
      oprot.writeBool(self.success)
6452 
      oprot.writeFieldEnd()
3431 rajveer 6453 
    if self.ucx is not None:
581 rajveer 6454 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6455 
      self.ucx.write(oprot)
6456 
      oprot.writeFieldEnd()
6457 
    oprot.writeFieldStop()
6458 
    oprot.writeStructEnd()
6459 
 
3431 rajveer 6460 
  def validate(self):
6461 
    return
6462 
 
6463 
 
581 rajveer 6464 
  def __repr__(self):
6465 
    L = ['%s=%r' % (key, value)
6466 
      for key, value in self.__dict__.iteritems()]
6467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6468 
 
6469 
  def __eq__(self, other):
6470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6471 
 
6472 
  def __ne__(self, other):
6473 
    return not (self == other)
6474 
 
594 rajveer 6475 
class getAllAddressesForUser_args:
6476 
  """
6477 
  Attributes:
6478 
   - userId
6479 
  """
6480 
 
6481 
  thrift_spec = (
6482 
    None, # 0
6483 
    (1, TType.I64, 'userId', None, None, ), # 1
6484 
  )
6485 
 
6486 
  def __init__(self, userId=None,):
6487 
    self.userId = userId
6488 
 
6489 
  def read(self, iprot):
6490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6492 
      return
6493 
    iprot.readStructBegin()
6494 
    while True:
6495 
      (fname, ftype, fid) = iprot.readFieldBegin()
6496 
      if ftype == TType.STOP:
6497 
        break
6498 
      if fid == 1:
6499 
        if ftype == TType.I64:
6500 
          self.userId = iprot.readI64();
6501 
        else:
6502 
          iprot.skip(ftype)
6503 
      else:
6504 
        iprot.skip(ftype)
6505 
      iprot.readFieldEnd()
6506 
    iprot.readStructEnd()
6507 
 
6508 
  def write(self, oprot):
6509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6511 
      return
6512 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6513 
    if self.userId is not None:
594 rajveer 6514 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6515 
      oprot.writeI64(self.userId)
6516 
      oprot.writeFieldEnd()
6517 
    oprot.writeFieldStop()
6518 
    oprot.writeStructEnd()
6519 
 
3431 rajveer 6520 
  def validate(self):
6521 
    return
6522 
 
6523 
 
594 rajveer 6524 
  def __repr__(self):
6525 
    L = ['%s=%r' % (key, value)
6526 
      for key, value in self.__dict__.iteritems()]
6527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6528 
 
6529 
  def __eq__(self, other):
6530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6531 
 
6532 
  def __ne__(self, other):
6533 
    return not (self == other)
6534 
 
6535 
class getAllAddressesForUser_result:
6536 
  """
6537 
  Attributes:
6538 
   - success
6539 
   - ucx
6540 
  """
6541 
 
6542 
  thrift_spec = (
6543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6544 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6545 
  )
6546 
 
6547 
  def __init__(self, success=None, ucx=None,):
6548 
    self.success = success
6549 
    self.ucx = ucx
6550 
 
6551 
  def read(self, iprot):
6552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6554 
      return
6555 
    iprot.readStructBegin()
6556 
    while True:
6557 
      (fname, ftype, fid) = iprot.readFieldBegin()
6558 
      if ftype == TType.STOP:
6559 
        break
6560 
      if fid == 0:
6561 
        if ftype == TType.LIST:
6562 
          self.success = []
11592 amit.gupta 6563 
          (_etype100, _size97) = iprot.readListBegin()
6564 
          for _i101 in xrange(_size97):
6565 
            _elem102 = Address()
6566 
            _elem102.read(iprot)
6567 
            self.success.append(_elem102)
594 rajveer 6568 
          iprot.readListEnd()
6569 
        else:
6570 
          iprot.skip(ftype)
6571 
      elif fid == 1:
6572 
        if ftype == TType.STRUCT:
6573 
          self.ucx = UserContextException()
6574 
          self.ucx.read(iprot)
6575 
        else:
6576 
          iprot.skip(ftype)
6577 
      else:
6578 
        iprot.skip(ftype)
6579 
      iprot.readFieldEnd()
6580 
    iprot.readStructEnd()
6581 
 
6582 
  def write(self, oprot):
6583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6585 
      return
6586 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 6587 
    if self.success is not None:
594 rajveer 6588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6589 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 6590 
      for iter103 in self.success:
6591 
        iter103.write(oprot)
594 rajveer 6592 
      oprot.writeListEnd()
6593 
      oprot.writeFieldEnd()
3431 rajveer 6594 
    if self.ucx is not None:
594 rajveer 6595 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6596 
      self.ucx.write(oprot)
6597 
      oprot.writeFieldEnd()
6598 
    oprot.writeFieldStop()
6599 
    oprot.writeStructEnd()
6600 
 
3431 rajveer 6601 
  def validate(self):
6602 
    return
6603 
 
6604 
 
594 rajveer 6605 
  def __repr__(self):
6606 
    L = ['%s=%r' % (key, value)
6607 
      for key, value in self.__dict__.iteritems()]
6608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6609 
 
6610 
  def __eq__(self, other):
6611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6612 
 
6613 
  def __ne__(self, other):
6614 
    return not (self == other)
6615 
 
1894 vikas 6616 
class getAddressById_args:
6617 
  """
6618 
  Attributes:
6619 
   - addressId
6620 
  """
6621 
 
6622 
  thrift_spec = (
6623 
    None, # 0
6624 
    (1, TType.I64, 'addressId', None, None, ), # 1
6625 
  )
6626 
 
6627 
  def __init__(self, addressId=None,):
6628 
    self.addressId = addressId
6629 
 
6630 
  def read(self, iprot):
6631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6633 
      return
6634 
    iprot.readStructBegin()
6635 
    while True:
6636 
      (fname, ftype, fid) = iprot.readFieldBegin()
6637 
      if ftype == TType.STOP:
6638 
        break
6639 
      if fid == 1:
6640 
        if ftype == TType.I64:
6641 
          self.addressId = iprot.readI64();
6642 
        else:
6643 
          iprot.skip(ftype)
6644 
      else:
6645 
        iprot.skip(ftype)
6646 
      iprot.readFieldEnd()
6647 
    iprot.readStructEnd()
6648 
 
6649 
  def write(self, oprot):
6650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6652 
      return
6653 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 6654 
    if self.addressId is not None:
1894 vikas 6655 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6656 
      oprot.writeI64(self.addressId)
6657 
      oprot.writeFieldEnd()
6658 
    oprot.writeFieldStop()
6659 
    oprot.writeStructEnd()
6660 
 
3431 rajveer 6661 
  def validate(self):
6662 
    return
6663 
 
6664 
 
1894 vikas 6665 
  def __repr__(self):
6666 
    L = ['%s=%r' % (key, value)
6667 
      for key, value in self.__dict__.iteritems()]
6668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6669 
 
6670 
  def __eq__(self, other):
6671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6672 
 
6673 
  def __ne__(self, other):
6674 
    return not (self == other)
6675 
 
6676 
class getAddressById_result:
6677 
  """
6678 
  Attributes:
6679 
   - success
6680 
   - ucx
6681 
  """
6682 
 
6683 
  thrift_spec = (
6684 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6685 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6686 
  )
6687 
 
6688 
  def __init__(self, success=None, ucx=None,):
6689 
    self.success = success
6690 
    self.ucx = ucx
6691 
 
6692 
  def read(self, iprot):
6693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6695 
      return
6696 
    iprot.readStructBegin()
6697 
    while True:
6698 
      (fname, ftype, fid) = iprot.readFieldBegin()
6699 
      if ftype == TType.STOP:
6700 
        break
6701 
      if fid == 0:
6702 
        if ftype == TType.STRUCT:
6703 
          self.success = Address()
6704 
          self.success.read(iprot)
6705 
        else:
6706 
          iprot.skip(ftype)
6707 
      elif fid == 1:
6708 
        if ftype == TType.STRUCT:
6709 
          self.ucx = UserContextException()
6710 
          self.ucx.read(iprot)
6711 
        else:
6712 
          iprot.skip(ftype)
6713 
      else:
6714 
        iprot.skip(ftype)
6715 
      iprot.readFieldEnd()
6716 
    iprot.readStructEnd()
6717 
 
6718 
  def write(self, oprot):
6719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6721 
      return
6722 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 6723 
    if self.success is not None:
1894 vikas 6724 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6725 
      self.success.write(oprot)
6726 
      oprot.writeFieldEnd()
3431 rajveer 6727 
    if self.ucx is not None:
1894 vikas 6728 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6729 
      self.ucx.write(oprot)
6730 
      oprot.writeFieldEnd()
6731 
    oprot.writeFieldStop()
6732 
    oprot.writeStructEnd()
6733 
 
3431 rajveer 6734 
  def validate(self):
6735 
    return
6736 
 
6737 
 
1894 vikas 6738 
  def __repr__(self):
6739 
    L = ['%s=%r' % (key, value)
6740 
      for key, value in self.__dict__.iteritems()]
6741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6742 
 
6743 
  def __eq__(self, other):
6744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6745 
 
6746 
  def __ne__(self, other):
6747 
    return not (self == other)
6748 
 
594 rajveer 6749 
class getDefaultAddressId_args:
6750 
  """
6751 
  Attributes:
6752 
   - userId
6753 
  """
6754 
 
6755 
  thrift_spec = (
6756 
    None, # 0
6757 
    (1, TType.I64, 'userId', None, None, ), # 1
6758 
  )
6759 
 
6760 
  def __init__(self, userId=None,):
6761 
    self.userId = userId
6762 
 
6763 
  def read(self, iprot):
6764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6766 
      return
6767 
    iprot.readStructBegin()
6768 
    while True:
6769 
      (fname, ftype, fid) = iprot.readFieldBegin()
6770 
      if ftype == TType.STOP:
6771 
        break
6772 
      if fid == 1:
6773 
        if ftype == TType.I64:
6774 
          self.userId = iprot.readI64();
6775 
        else:
6776 
          iprot.skip(ftype)
6777 
      else:
6778 
        iprot.skip(ftype)
6779 
      iprot.readFieldEnd()
6780 
    iprot.readStructEnd()
6781 
 
6782 
  def write(self, oprot):
6783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6785 
      return
6786 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 6787 
    if self.userId is not None:
594 rajveer 6788 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6789 
      oprot.writeI64(self.userId)
6790 
      oprot.writeFieldEnd()
6791 
    oprot.writeFieldStop()
6792 
    oprot.writeStructEnd()
6793 
 
3431 rajveer 6794 
  def validate(self):
6795 
    return
6796 
 
6797 
 
594 rajveer 6798 
  def __repr__(self):
6799 
    L = ['%s=%r' % (key, value)
6800 
      for key, value in self.__dict__.iteritems()]
6801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6802 
 
6803 
  def __eq__(self, other):
6804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6805 
 
6806 
  def __ne__(self, other):
6807 
    return not (self == other)
6808 
 
6809 
class getDefaultAddressId_result:
6810 
  """
6811 
  Attributes:
6812 
   - success
6813 
   - ucx
6814 
  """
6815 
 
6816 
  thrift_spec = (
6817 
    (0, TType.I64, 'success', None, None, ), # 0
6818 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6819 
  )
6820 
 
6821 
  def __init__(self, success=None, ucx=None,):
6822 
    self.success = success
6823 
    self.ucx = ucx
6824 
 
6825 
  def read(self, iprot):
6826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6828 
      return
6829 
    iprot.readStructBegin()
6830 
    while True:
6831 
      (fname, ftype, fid) = iprot.readFieldBegin()
6832 
      if ftype == TType.STOP:
6833 
        break
6834 
      if fid == 0:
6835 
        if ftype == TType.I64:
6836 
          self.success = iprot.readI64();
6837 
        else:
6838 
          iprot.skip(ftype)
6839 
      elif fid == 1:
6840 
        if ftype == TType.STRUCT:
6841 
          self.ucx = UserContextException()
6842 
          self.ucx.read(iprot)
6843 
        else:
6844 
          iprot.skip(ftype)
6845 
      else:
6846 
        iprot.skip(ftype)
6847 
      iprot.readFieldEnd()
6848 
    iprot.readStructEnd()
6849 
 
6850 
  def write(self, oprot):
6851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6853 
      return
6854 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 6855 
    if self.success is not None:
594 rajveer 6856 
      oprot.writeFieldBegin('success', TType.I64, 0)
6857 
      oprot.writeI64(self.success)
6858 
      oprot.writeFieldEnd()
3431 rajveer 6859 
    if self.ucx is not None:
594 rajveer 6860 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6861 
      self.ucx.write(oprot)
6862 
      oprot.writeFieldEnd()
6863 
    oprot.writeFieldStop()
6864 
    oprot.writeStructEnd()
6865 
 
3431 rajveer 6866 
  def validate(self):
6867 
    return
6868 
 
6869 
 
594 rajveer 6870 
  def __repr__(self):
6871 
    L = ['%s=%r' % (key, value)
6872 
      for key, value in self.__dict__.iteritems()]
6873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6874 
 
6875 
  def __eq__(self, other):
6876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6877 
 
6878 
  def __ne__(self, other):
6879 
    return not (self == other)
6880 
 
785 rajveer 6881 
class getDefaultPincode_args:
6882 
  """
6883 
  Attributes:
6884 
   - userId
6885 
  """
6886 
 
6887 
  thrift_spec = (
6888 
    None, # 0
6889 
    (1, TType.I64, 'userId', None, None, ), # 1
6890 
  )
6891 
 
6892 
  def __init__(self, userId=None,):
6893 
    self.userId = userId
6894 
 
6895 
  def read(self, iprot):
6896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6898 
      return
6899 
    iprot.readStructBegin()
6900 
    while True:
6901 
      (fname, ftype, fid) = iprot.readFieldBegin()
6902 
      if ftype == TType.STOP:
6903 
        break
6904 
      if fid == 1:
6905 
        if ftype == TType.I64:
6906 
          self.userId = iprot.readI64();
6907 
        else:
6908 
          iprot.skip(ftype)
6909 
      else:
6910 
        iprot.skip(ftype)
6911 
      iprot.readFieldEnd()
6912 
    iprot.readStructEnd()
6913 
 
6914 
  def write(self, oprot):
6915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6917 
      return
6918 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 6919 
    if self.userId is not None:
785 rajveer 6920 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6921 
      oprot.writeI64(self.userId)
6922 
      oprot.writeFieldEnd()
6923 
    oprot.writeFieldStop()
6924 
    oprot.writeStructEnd()
6925 
 
3431 rajveer 6926 
  def validate(self):
6927 
    return
6928 
 
6929 
 
785 rajveer 6930 
  def __repr__(self):
6931 
    L = ['%s=%r' % (key, value)
6932 
      for key, value in self.__dict__.iteritems()]
6933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6934 
 
6935 
  def __eq__(self, other):
6936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6937 
 
6938 
  def __ne__(self, other):
6939 
    return not (self == other)
6940 
 
6941 
class getDefaultPincode_result:
6942 
  """
6943 
  Attributes:
6944 
   - success
6945 
   - ucx
6946 
  """
6947 
 
6948 
  thrift_spec = (
6949 
    (0, TType.STRING, 'success', None, None, ), # 0
6950 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6951 
  )
6952 
 
6953 
  def __init__(self, success=None, ucx=None,):
6954 
    self.success = success
6955 
    self.ucx = ucx
6956 
 
6957 
  def read(self, iprot):
6958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6960 
      return
6961 
    iprot.readStructBegin()
6962 
    while True:
6963 
      (fname, ftype, fid) = iprot.readFieldBegin()
6964 
      if ftype == TType.STOP:
6965 
        break
6966 
      if fid == 0:
6967 
        if ftype == TType.STRING:
6968 
          self.success = iprot.readString();
6969 
        else:
6970 
          iprot.skip(ftype)
6971 
      elif fid == 1:
6972 
        if ftype == TType.STRUCT:
6973 
          self.ucx = UserContextException()
6974 
          self.ucx.read(iprot)
6975 
        else:
6976 
          iprot.skip(ftype)
6977 
      else:
6978 
        iprot.skip(ftype)
6979 
      iprot.readFieldEnd()
6980 
    iprot.readStructEnd()
6981 
 
6982 
  def write(self, oprot):
6983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6985 
      return
6986 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 6987 
    if self.success is not None:
785 rajveer 6988 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6989 
      oprot.writeString(self.success)
6990 
      oprot.writeFieldEnd()
3431 rajveer 6991 
    if self.ucx is not None:
785 rajveer 6992 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6993 
      self.ucx.write(oprot)
6994 
      oprot.writeFieldEnd()
6995 
    oprot.writeFieldStop()
6996 
    oprot.writeStructEnd()
6997 
 
3431 rajveer 6998 
  def validate(self):
6999 
    return
7000 
 
7001 
 
785 rajveer 7002 
  def __repr__(self):
7003 
    L = ['%s=%r' % (key, value)
7004 
      for key, value in self.__dict__.iteritems()]
7005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7006 
 
7007 
  def __eq__(self, other):
7008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7009 
 
7010 
  def __ne__(self, other):
7011 
    return not (self == other)
7012 
 
1274 varun.gupt 7013 
class saveUserCommunication_args:
7014 
  """
7015 
  Attributes:
7016 
   - userId
7017 
   - replyTo
7018 
   - communicationType
7019 
   - orderId
7020 
   - airwaybillNo
7021 
   - productName
7022 
   - subject
7023 
   - message
7024 
  """
7025 
 
7026 
  thrift_spec = (
7027 
    None, # 0
7028 
    (1, TType.I64, 'userId', None, None, ), # 1
7029 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7030 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7031 
    (4, TType.I64, 'orderId', None, None, ), # 4
7032 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7033 
    (6, TType.STRING, 'productName', None, None, ), # 6
7034 
    (7, TType.STRING, 'subject', None, None, ), # 7
7035 
    (8, TType.STRING, 'message', None, None, ), # 8
7036 
  )
7037 
 
7038 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7039 
    self.userId = userId
7040 
    self.replyTo = replyTo
7041 
    self.communicationType = communicationType
7042 
    self.orderId = orderId
7043 
    self.airwaybillNo = airwaybillNo
7044 
    self.productName = productName
7045 
    self.subject = subject
7046 
    self.message = message
7047 
 
7048 
  def read(self, iprot):
7049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7051 
      return
7052 
    iprot.readStructBegin()
7053 
    while True:
7054 
      (fname, ftype, fid) = iprot.readFieldBegin()
7055 
      if ftype == TType.STOP:
7056 
        break
7057 
      if fid == 1:
7058 
        if ftype == TType.I64:
7059 
          self.userId = iprot.readI64();
7060 
        else:
7061 
          iprot.skip(ftype)
7062 
      elif fid == 2:
7063 
        if ftype == TType.STRING:
7064 
          self.replyTo = iprot.readString();
7065 
        else:
7066 
          iprot.skip(ftype)
7067 
      elif fid == 3:
7068 
        if ftype == TType.I64:
7069 
          self.communicationType = iprot.readI64();
7070 
        else:
7071 
          iprot.skip(ftype)
7072 
      elif fid == 4:
7073 
        if ftype == TType.I64:
7074 
          self.orderId = iprot.readI64();
7075 
        else:
7076 
          iprot.skip(ftype)
7077 
      elif fid == 5:
7078 
        if ftype == TType.STRING:
7079 
          self.airwaybillNo = iprot.readString();
7080 
        else:
7081 
          iprot.skip(ftype)
7082 
      elif fid == 6:
7083 
        if ftype == TType.STRING:
7084 
          self.productName = iprot.readString();
7085 
        else:
7086 
          iprot.skip(ftype)
7087 
      elif fid == 7:
7088 
        if ftype == TType.STRING:
7089 
          self.subject = iprot.readString();
7090 
        else:
7091 
          iprot.skip(ftype)
7092 
      elif fid == 8:
7093 
        if ftype == TType.STRING:
7094 
          self.message = iprot.readString();
7095 
        else:
7096 
          iprot.skip(ftype)
7097 
      else:
7098 
        iprot.skip(ftype)
7099 
      iprot.readFieldEnd()
7100 
    iprot.readStructEnd()
7101 
 
7102 
  def write(self, oprot):
7103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7105 
      return
7106 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7107 
    if self.userId is not None:
1274 varun.gupt 7108 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7109 
      oprot.writeI64(self.userId)
7110 
      oprot.writeFieldEnd()
3431 rajveer 7111 
    if self.replyTo is not None:
1274 varun.gupt 7112 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7113 
      oprot.writeString(self.replyTo)
7114 
      oprot.writeFieldEnd()
3431 rajveer 7115 
    if self.communicationType is not None:
1274 varun.gupt 7116 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7117 
      oprot.writeI64(self.communicationType)
7118 
      oprot.writeFieldEnd()
3431 rajveer 7119 
    if self.orderId is not None:
1274 varun.gupt 7120 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7121 
      oprot.writeI64(self.orderId)
7122 
      oprot.writeFieldEnd()
3431 rajveer 7123 
    if self.airwaybillNo is not None:
1274 varun.gupt 7124 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7125 
      oprot.writeString(self.airwaybillNo)
7126 
      oprot.writeFieldEnd()
3431 rajveer 7127 
    if self.productName is not None:
1274 varun.gupt 7128 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7129 
      oprot.writeString(self.productName)
7130 
      oprot.writeFieldEnd()
3431 rajveer 7131 
    if self.subject is not None:
1274 varun.gupt 7132 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7133 
      oprot.writeString(self.subject)
7134 
      oprot.writeFieldEnd()
3431 rajveer 7135 
    if self.message is not None:
1274 varun.gupt 7136 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7137 
      oprot.writeString(self.message)
7138 
      oprot.writeFieldEnd()
7139 
    oprot.writeFieldStop()
7140 
    oprot.writeStructEnd()
7141 
 
3431 rajveer 7142 
  def validate(self):
7143 
    return
7144 
 
7145 
 
1274 varun.gupt 7146 
  def __repr__(self):
7147 
    L = ['%s=%r' % (key, value)
7148 
      for key, value in self.__dict__.iteritems()]
7149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7150 
 
7151 
  def __eq__(self, other):
7152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7153 
 
7154 
  def __ne__(self, other):
7155 
    return not (self == other)
7156 
 
7157 
class saveUserCommunication_result:
7158 
  """
7159 
  Attributes:
7160 
   - success
7161 
   - ucx
7162 
  """
7163 
 
7164 
  thrift_spec = (
7165 
    (0, TType.BOOL, 'success', None, None, ), # 0
7166 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7167 
  )
7168 
 
7169 
  def __init__(self, success=None, ucx=None,):
7170 
    self.success = success
7171 
    self.ucx = ucx
7172 
 
7173 
  def read(self, iprot):
7174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7176 
      return
7177 
    iprot.readStructBegin()
7178 
    while True:
7179 
      (fname, ftype, fid) = iprot.readFieldBegin()
7180 
      if ftype == TType.STOP:
7181 
        break
7182 
      if fid == 0:
7183 
        if ftype == TType.BOOL:
7184 
          self.success = iprot.readBool();
7185 
        else:
7186 
          iprot.skip(ftype)
7187 
      elif fid == 1:
7188 
        if ftype == TType.STRUCT:
7189 
          self.ucx = UserCommunicationException()
7190 
          self.ucx.read(iprot)
7191 
        else:
7192 
          iprot.skip(ftype)
7193 
      else:
7194 
        iprot.skip(ftype)
7195 
      iprot.readFieldEnd()
7196 
    iprot.readStructEnd()
7197 
 
7198 
  def write(self, oprot):
7199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7201 
      return
7202 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7203 
    if self.success is not None:
1274 varun.gupt 7204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7205 
      oprot.writeBool(self.success)
7206 
      oprot.writeFieldEnd()
3431 rajveer 7207 
    if self.ucx is not None:
1274 varun.gupt 7208 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7209 
      self.ucx.write(oprot)
7210 
      oprot.writeFieldEnd()
7211 
    oprot.writeFieldStop()
7212 
    oprot.writeStructEnd()
7213 
 
3431 rajveer 7214 
  def validate(self):
7215 
    return
7216 
 
7217 
 
1274 varun.gupt 7218 
  def __repr__(self):
7219 
    L = ['%s=%r' % (key, value)
7220 
      for key, value in self.__dict__.iteritems()]
7221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7222 
 
7223 
  def __eq__(self, other):
7224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7225 
 
7226 
  def __ne__(self, other):
7227 
    return not (self == other)
7228 
 
1590 varun.gupt 7229 
class getUserCommunicationById_args:
7230 
  """
7231 
  Attributes:
7232 
   - id
7233 
  """
7234 
 
7235 
  thrift_spec = (
7236 
    None, # 0
7237 
    (1, TType.I64, 'id', None, None, ), # 1
7238 
  )
7239 
 
7240 
  def __init__(self, id=None,):
7241 
    self.id = id
7242 
 
7243 
  def read(self, iprot):
7244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7246 
      return
7247 
    iprot.readStructBegin()
7248 
    while True:
7249 
      (fname, ftype, fid) = iprot.readFieldBegin()
7250 
      if ftype == TType.STOP:
7251 
        break
7252 
      if fid == 1:
7253 
        if ftype == TType.I64:
7254 
          self.id = iprot.readI64();
7255 
        else:
7256 
          iprot.skip(ftype)
7257 
      else:
7258 
        iprot.skip(ftype)
7259 
      iprot.readFieldEnd()
7260 
    iprot.readStructEnd()
7261 
 
7262 
  def write(self, oprot):
7263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7265 
      return
7266 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7267 
    if self.id is not None:
1590 varun.gupt 7268 
      oprot.writeFieldBegin('id', TType.I64, 1)
7269 
      oprot.writeI64(self.id)
7270 
      oprot.writeFieldEnd()
7271 
    oprot.writeFieldStop()
7272 
    oprot.writeStructEnd()
7273 
 
3431 rajveer 7274 
  def validate(self):
7275 
    return
7276 
 
7277 
 
1590 varun.gupt 7278 
  def __repr__(self):
7279 
    L = ['%s=%r' % (key, value)
7280 
      for key, value in self.__dict__.iteritems()]
7281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7282 
 
7283 
  def __eq__(self, other):
7284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7285 
 
7286 
  def __ne__(self, other):
7287 
    return not (self == other)
7288 
 
7289 
class getUserCommunicationById_result:
7290 
  """
7291 
  Attributes:
7292 
   - success
7293 
   - ucx
7294 
  """
7295 
 
7296 
  thrift_spec = (
7297 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7298 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7299 
  )
7300 
 
7301 
  def __init__(self, success=None, ucx=None,):
7302 
    self.success = success
7303 
    self.ucx = ucx
7304 
 
7305 
  def read(self, iprot):
7306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7308 
      return
7309 
    iprot.readStructBegin()
7310 
    while True:
7311 
      (fname, ftype, fid) = iprot.readFieldBegin()
7312 
      if ftype == TType.STOP:
7313 
        break
7314 
      if fid == 0:
7315 
        if ftype == TType.STRUCT:
7316 
          self.success = UserCommunication()
7317 
          self.success.read(iprot)
7318 
        else:
7319 
          iprot.skip(ftype)
7320 
      elif fid == 1:
7321 
        if ftype == TType.STRUCT:
7322 
          self.ucx = UserCommunicationException()
7323 
          self.ucx.read(iprot)
7324 
        else:
7325 
          iprot.skip(ftype)
7326 
      else:
7327 
        iprot.skip(ftype)
7328 
      iprot.readFieldEnd()
7329 
    iprot.readStructEnd()
7330 
 
7331 
  def write(self, oprot):
7332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7334 
      return
7335 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7336 
    if self.success is not None:
1590 varun.gupt 7337 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7338 
      self.success.write(oprot)
7339 
      oprot.writeFieldEnd()
3431 rajveer 7340 
    if self.ucx is not None:
1590 varun.gupt 7341 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7342 
      self.ucx.write(oprot)
7343 
      oprot.writeFieldEnd()
7344 
    oprot.writeFieldStop()
7345 
    oprot.writeStructEnd()
7346 
 
3431 rajveer 7347 
  def validate(self):
7348 
    return
7349 
 
7350 
 
1590 varun.gupt 7351 
  def __repr__(self):
7352 
    L = ['%s=%r' % (key, value)
7353 
      for key, value in self.__dict__.iteritems()]
7354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7355 
 
7356 
  def __eq__(self, other):
7357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7358 
 
7359 
  def __ne__(self, other):
7360 
    return not (self == other)
7361 
 
7362 
class getUserCommunicationByUser_args:
7363 
  """
7364 
  Attributes:
7365 
   - userId
7366 
  """
7367 
 
7368 
  thrift_spec = (
7369 
    None, # 0
7370 
    (1, TType.I64, 'userId', None, None, ), # 1
7371 
  )
7372 
 
7373 
  def __init__(self, userId=None,):
7374 
    self.userId = userId
7375 
 
7376 
  def read(self, iprot):
7377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7379 
      return
7380 
    iprot.readStructBegin()
7381 
    while True:
7382 
      (fname, ftype, fid) = iprot.readFieldBegin()
7383 
      if ftype == TType.STOP:
7384 
        break
7385 
      if fid == 1:
7386 
        if ftype == TType.I64:
7387 
          self.userId = iprot.readI64();
7388 
        else:
7389 
          iprot.skip(ftype)
7390 
      else:
7391 
        iprot.skip(ftype)
7392 
      iprot.readFieldEnd()
7393 
    iprot.readStructEnd()
7394 
 
7395 
  def write(self, oprot):
7396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7398 
      return
7399 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7400 
    if self.userId is not None:
1590 varun.gupt 7401 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7402 
      oprot.writeI64(self.userId)
7403 
      oprot.writeFieldEnd()
7404 
    oprot.writeFieldStop()
7405 
    oprot.writeStructEnd()
7406 
 
3431 rajveer 7407 
  def validate(self):
7408 
    return
7409 
 
7410 
 
1590 varun.gupt 7411 
  def __repr__(self):
7412 
    L = ['%s=%r' % (key, value)
7413 
      for key, value in self.__dict__.iteritems()]
7414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7415 
 
7416 
  def __eq__(self, other):
7417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7418 
 
7419 
  def __ne__(self, other):
7420 
    return not (self == other)
7421 
 
7422 
class getUserCommunicationByUser_result:
7423 
  """
7424 
  Attributes:
7425 
   - success
7426 
   - ucx
7427 
  """
7428 
 
7429 
  thrift_spec = (
7430 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7431 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7432 
  )
7433 
 
7434 
  def __init__(self, success=None, ucx=None,):
7435 
    self.success = success
7436 
    self.ucx = ucx
7437 
 
7438 
  def read(self, iprot):
7439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7441 
      return
7442 
    iprot.readStructBegin()
7443 
    while True:
7444 
      (fname, ftype, fid) = iprot.readFieldBegin()
7445 
      if ftype == TType.STOP:
7446 
        break
7447 
      if fid == 0:
7448 
        if ftype == TType.LIST:
7449 
          self.success = []
11592 amit.gupta 7450 
          (_etype107, _size104) = iprot.readListBegin()
7451 
          for _i108 in xrange(_size104):
7452 
            _elem109 = UserCommunication()
7453 
            _elem109.read(iprot)
7454 
            self.success.append(_elem109)
1590 varun.gupt 7455 
          iprot.readListEnd()
7456 
        else:
7457 
          iprot.skip(ftype)
7458 
      elif fid == 1:
7459 
        if ftype == TType.STRUCT:
7460 
          self.ucx = UserCommunicationException()
7461 
          self.ucx.read(iprot)
7462 
        else:
7463 
          iprot.skip(ftype)
7464 
      else:
7465 
        iprot.skip(ftype)
7466 
      iprot.readFieldEnd()
7467 
    iprot.readStructEnd()
7468 
 
7469 
  def write(self, oprot):
7470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7472 
      return
7473 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7474 
    if self.success is not None:
1590 varun.gupt 7475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7477 
      for iter110 in self.success:
7478 
        iter110.write(oprot)
1590 varun.gupt 7479 
      oprot.writeListEnd()
7480 
      oprot.writeFieldEnd()
3431 rajveer 7481 
    if self.ucx is not None:
1590 varun.gupt 7482 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7483 
      self.ucx.write(oprot)
7484 
      oprot.writeFieldEnd()
7485 
    oprot.writeFieldStop()
7486 
    oprot.writeStructEnd()
7487 
 
3431 rajveer 7488 
  def validate(self):
7489 
    return
7490 
 
7491 
 
1590 varun.gupt 7492 
  def __repr__(self):
7493 
    L = ['%s=%r' % (key, value)
7494 
      for key, value in self.__dict__.iteritems()]
7495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7496 
 
7497 
  def __eq__(self, other):
7498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7499 
 
7500 
  def __ne__(self, other):
7501 
    return not (self == other)
7502 
 
7503 
class getAllUserCommunications_args:
7504 
 
7505 
  thrift_spec = (
7506 
  )
7507 
 
7508 
  def read(self, iprot):
7509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7511 
      return
7512 
    iprot.readStructBegin()
7513 
    while True:
7514 
      (fname, ftype, fid) = iprot.readFieldBegin()
7515 
      if ftype == TType.STOP:
7516 
        break
7517 
      else:
7518 
        iprot.skip(ftype)
7519 
      iprot.readFieldEnd()
7520 
    iprot.readStructEnd()
7521 
 
7522 
  def write(self, oprot):
7523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7525 
      return
7526 
    oprot.writeStructBegin('getAllUserCommunications_args')
7527 
    oprot.writeFieldStop()
7528 
    oprot.writeStructEnd()
7529 
 
3431 rajveer 7530 
  def validate(self):
7531 
    return
7532 
 
7533 
 
1590 varun.gupt 7534 
  def __repr__(self):
7535 
    L = ['%s=%r' % (key, value)
7536 
      for key, value in self.__dict__.iteritems()]
7537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7538 
 
7539 
  def __eq__(self, other):
7540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7541 
 
7542 
  def __ne__(self, other):
7543 
    return not (self == other)
7544 
 
7545 
class getAllUserCommunications_result:
7546 
  """
7547 
  Attributes:
7548 
   - success
7549 
   - ucx
7550 
  """
7551 
 
7552 
  thrift_spec = (
7553 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7554 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7555 
  )
7556 
 
7557 
  def __init__(self, success=None, ucx=None,):
7558 
    self.success = success
7559 
    self.ucx = ucx
7560 
 
7561 
  def read(self, iprot):
7562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7564 
      return
7565 
    iprot.readStructBegin()
7566 
    while True:
7567 
      (fname, ftype, fid) = iprot.readFieldBegin()
7568 
      if ftype == TType.STOP:
7569 
        break
7570 
      if fid == 0:
7571 
        if ftype == TType.LIST:
7572 
          self.success = []
11592 amit.gupta 7573 
          (_etype114, _size111) = iprot.readListBegin()
7574 
          for _i115 in xrange(_size111):
7575 
            _elem116 = UserCommunication()
7576 
            _elem116.read(iprot)
7577 
            self.success.append(_elem116)
1590 varun.gupt 7578 
          iprot.readListEnd()
7579 
        else:
7580 
          iprot.skip(ftype)
7581 
      elif fid == 1:
7582 
        if ftype == TType.STRUCT:
7583 
          self.ucx = UserCommunicationException()
7584 
          self.ucx.read(iprot)
7585 
        else:
7586 
          iprot.skip(ftype)
7587 
      else:
7588 
        iprot.skip(ftype)
7589 
      iprot.readFieldEnd()
7590 
    iprot.readStructEnd()
7591 
 
7592 
  def write(self, oprot):
7593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7595 
      return
7596 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 7597 
    if self.success is not None:
1590 varun.gupt 7598 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7599 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7600 
      for iter117 in self.success:
7601 
        iter117.write(oprot)
1590 varun.gupt 7602 
      oprot.writeListEnd()
7603 
      oprot.writeFieldEnd()
3431 rajveer 7604 
    if self.ucx is not None:
1590 varun.gupt 7605 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7606 
      self.ucx.write(oprot)
7607 
      oprot.writeFieldEnd()
7608 
    oprot.writeFieldStop()
7609 
    oprot.writeStructEnd()
7610 
 
3431 rajveer 7611 
  def validate(self):
7612 
    return
7613 
 
7614 
 
1590 varun.gupt 7615 
  def __repr__(self):
7616 
    L = ['%s=%r' % (key, value)
7617 
      for key, value in self.__dict__.iteritems()]
7618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7619 
 
7620 
  def __eq__(self, other):
7621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7622 
 
7623 
  def __ne__(self, other):
7624 
    return not (self == other)
7625 
 
5407 amar.kumar 7626 
class removeUserCommunication_args:
7627 
  """
7628 
  Attributes:
7629 
   - id
7630 
  """
7631 
 
7632 
  thrift_spec = (
7633 
    None, # 0
7634 
    (1, TType.I64, 'id', None, None, ), # 1
7635 
  )
7636 
 
7637 
  def __init__(self, id=None,):
7638 
    self.id = id
7639 
 
7640 
  def read(self, iprot):
7641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7643 
      return
7644 
    iprot.readStructBegin()
7645 
    while True:
7646 
      (fname, ftype, fid) = iprot.readFieldBegin()
7647 
      if ftype == TType.STOP:
7648 
        break
7649 
      if fid == 1:
7650 
        if ftype == TType.I64:
7651 
          self.id = iprot.readI64();
7652 
        else:
7653 
          iprot.skip(ftype)
7654 
      else:
7655 
        iprot.skip(ftype)
7656 
      iprot.readFieldEnd()
7657 
    iprot.readStructEnd()
7658 
 
7659 
  def write(self, oprot):
7660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7662 
      return
7663 
    oprot.writeStructBegin('removeUserCommunication_args')
7664 
    if self.id is not None:
7665 
      oprot.writeFieldBegin('id', TType.I64, 1)
7666 
      oprot.writeI64(self.id)
7667 
      oprot.writeFieldEnd()
7668 
    oprot.writeFieldStop()
7669 
    oprot.writeStructEnd()
7670 
 
7671 
  def validate(self):
7672 
    return
7673 
 
7674 
 
7675 
  def __repr__(self):
7676 
    L = ['%s=%r' % (key, value)
7677 
      for key, value in self.__dict__.iteritems()]
7678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7679 
 
7680 
  def __eq__(self, other):
7681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7682 
 
7683 
  def __ne__(self, other):
7684 
    return not (self == other)
7685 
 
7686 
class removeUserCommunication_result:
7687 
  """
7688 
  Attributes:
7689 
   - ucx
7690 
  """
7691 
 
7692 
  thrift_spec = (
7693 
    None, # 0
7694 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7695 
  )
7696 
 
7697 
  def __init__(self, ucx=None,):
7698 
    self.ucx = ucx
7699 
 
7700 
  def read(self, iprot):
7701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7703 
      return
7704 
    iprot.readStructBegin()
7705 
    while True:
7706 
      (fname, ftype, fid) = iprot.readFieldBegin()
7707 
      if ftype == TType.STOP:
7708 
        break
7709 
      if fid == 1:
7710 
        if ftype == TType.STRUCT:
7711 
          self.ucx = UserCommunicationException()
7712 
          self.ucx.read(iprot)
7713 
        else:
7714 
          iprot.skip(ftype)
7715 
      else:
7716 
        iprot.skip(ftype)
7717 
      iprot.readFieldEnd()
7718 
    iprot.readStructEnd()
7719 
 
7720 
  def write(self, oprot):
7721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7723 
      return
7724 
    oprot.writeStructBegin('removeUserCommunication_result')
7725 
    if self.ucx is not None:
7726 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7727 
      self.ucx.write(oprot)
7728 
      oprot.writeFieldEnd()
7729 
    oprot.writeFieldStop()
7730 
    oprot.writeStructEnd()
7731 
 
7732 
  def validate(self):
7733 
    return
7734 
 
7735 
 
7736 
  def __repr__(self):
7737 
    L = ['%s=%r' % (key, value)
7738 
      for key, value in self.__dict__.iteritems()]
7739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7740 
 
7741 
  def __eq__(self, other):
7742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7743 
 
7744 
  def __ne__(self, other):
7745 
    return not (self == other)
7746 
 
1845 vikas 7747 
class createMasterAffiliate_args:
7748 
  """
7749 
  Attributes:
7750 
   - name
1859 vikas 7751 
   - addedOn
1845 vikas 7752 
  """
7753 
 
7754 
  thrift_spec = (
7755 
    None, # 0
7756 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7757 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7758 
  )
7759 
 
1859 vikas 7760 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7761 
    self.name = name
1859 vikas 7762 
    self.addedOn = addedOn
1845 vikas 7763 
 
7764 
  def read(self, iprot):
7765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7767 
      return
7768 
    iprot.readStructBegin()
7769 
    while True:
7770 
      (fname, ftype, fid) = iprot.readFieldBegin()
7771 
      if ftype == TType.STOP:
7772 
        break
7773 
      if fid == 1:
7774 
        if ftype == TType.STRING:
7775 
          self.name = iprot.readString();
7776 
        else:
7777 
          iprot.skip(ftype)
1859 vikas 7778 
      elif fid == 2:
7779 
        if ftype == TType.I64:
7780 
          self.addedOn = iprot.readI64();
7781 
        else:
7782 
          iprot.skip(ftype)
1845 vikas 7783 
      else:
7784 
        iprot.skip(ftype)
7785 
      iprot.readFieldEnd()
7786 
    iprot.readStructEnd()
7787 
 
7788 
  def write(self, oprot):
7789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7791 
      return
7792 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 7793 
    if self.name is not None:
1845 vikas 7794 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7795 
      oprot.writeString(self.name)
7796 
      oprot.writeFieldEnd()
3431 rajveer 7797 
    if self.addedOn is not None:
1859 vikas 7798 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7799 
      oprot.writeI64(self.addedOn)
7800 
      oprot.writeFieldEnd()
1845 vikas 7801 
    oprot.writeFieldStop()
7802 
    oprot.writeStructEnd()
7803 
 
3431 rajveer 7804 
  def validate(self):
7805 
    return
7806 
 
7807 
 
1845 vikas 7808 
  def __repr__(self):
7809 
    L = ['%s=%r' % (key, value)
7810 
      for key, value in self.__dict__.iteritems()]
7811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7812 
 
7813 
  def __eq__(self, other):
7814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7815 
 
7816 
  def __ne__(self, other):
7817 
    return not (self == other)
7818 
 
7819 
class createMasterAffiliate_result:
7820 
  """
7821 
  Attributes:
7822 
   - success
7823 
   - utx
7824 
  """
7825 
 
7826 
  thrift_spec = (
7827 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7828 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7829 
  )
7830 
 
7831 
  def __init__(self, success=None, utx=None,):
7832 
    self.success = success
7833 
    self.utx = utx
7834 
 
7835 
  def read(self, iprot):
7836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7838 
      return
7839 
    iprot.readStructBegin()
7840 
    while True:
7841 
      (fname, ftype, fid) = iprot.readFieldBegin()
7842 
      if ftype == TType.STOP:
7843 
        break
7844 
      if fid == 0:
7845 
        if ftype == TType.STRUCT:
7846 
          self.success = MasterAffiliate()
7847 
          self.success.read(iprot)
7848 
        else:
7849 
          iprot.skip(ftype)
7850 
      elif fid == 1:
7851 
        if ftype == TType.STRUCT:
1996 vikas 7852 
          self.utx = UserAffiliateException()
1845 vikas 7853 
          self.utx.read(iprot)
7854 
        else:
7855 
          iprot.skip(ftype)
7856 
      else:
7857 
        iprot.skip(ftype)
7858 
      iprot.readFieldEnd()
7859 
    iprot.readStructEnd()
7860 
 
7861 
  def write(self, oprot):
7862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7864 
      return
7865 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 7866 
    if self.success is not None:
1845 vikas 7867 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7868 
      self.success.write(oprot)
7869 
      oprot.writeFieldEnd()
3431 rajveer 7870 
    if self.utx is not None:
1845 vikas 7871 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7872 
      self.utx.write(oprot)
7873 
      oprot.writeFieldEnd()
7874 
    oprot.writeFieldStop()
7875 
    oprot.writeStructEnd()
7876 
 
3431 rajveer 7877 
  def validate(self):
7878 
    return
7879 
 
7880 
 
1845 vikas 7881 
  def __repr__(self):
7882 
    L = ['%s=%r' % (key, value)
7883 
      for key, value in self.__dict__.iteritems()]
7884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7885 
 
7886 
  def __eq__(self, other):
7887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7888 
 
7889 
  def __ne__(self, other):
7890 
    return not (self == other)
7891 
 
1899 vikas 7892 
class getAllMasterAffiliates_args:
7893 
 
7894 
  thrift_spec = (
7895 
  )
7896 
 
7897 
  def read(self, iprot):
7898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7900 
      return
7901 
    iprot.readStructBegin()
7902 
    while True:
7903 
      (fname, ftype, fid) = iprot.readFieldBegin()
7904 
      if ftype == TType.STOP:
7905 
        break
7906 
      else:
7907 
        iprot.skip(ftype)
7908 
      iprot.readFieldEnd()
7909 
    iprot.readStructEnd()
7910 
 
7911 
  def write(self, oprot):
7912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7914 
      return
7915 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7916 
    oprot.writeFieldStop()
7917 
    oprot.writeStructEnd()
7918 
 
3431 rajveer 7919 
  def validate(self):
7920 
    return
7921 
 
7922 
 
1899 vikas 7923 
  def __repr__(self):
7924 
    L = ['%s=%r' % (key, value)
7925 
      for key, value in self.__dict__.iteritems()]
7926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7927 
 
7928 
  def __eq__(self, other):
7929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7930 
 
7931 
  def __ne__(self, other):
7932 
    return not (self == other)
7933 
 
7934 
class getAllMasterAffiliates_result:
7935 
  """
7936 
  Attributes:
7937 
   - success
7938 
   - utx
7939 
  """
7940 
 
7941 
  thrift_spec = (
7942 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7943 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7944 
  )
7945 
 
7946 
  def __init__(self, success=None, utx=None,):
7947 
    self.success = success
7948 
    self.utx = utx
7949 
 
7950 
  def read(self, iprot):
7951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7953 
      return
7954 
    iprot.readStructBegin()
7955 
    while True:
7956 
      (fname, ftype, fid) = iprot.readFieldBegin()
7957 
      if ftype == TType.STOP:
7958 
        break
7959 
      if fid == 0:
7960 
        if ftype == TType.LIST:
7961 
          self.success = []
11592 amit.gupta 7962 
          (_etype121, _size118) = iprot.readListBegin()
7963 
          for _i122 in xrange(_size118):
7964 
            _elem123 = MasterAffiliate()
7965 
            _elem123.read(iprot)
7966 
            self.success.append(_elem123)
1899 vikas 7967 
          iprot.readListEnd()
7968 
        else:
7969 
          iprot.skip(ftype)
7970 
      elif fid == 1:
7971 
        if ftype == TType.STRUCT:
1996 vikas 7972 
          self.utx = UserAffiliateException()
1899 vikas 7973 
          self.utx.read(iprot)
7974 
        else:
7975 
          iprot.skip(ftype)
7976 
      else:
7977 
        iprot.skip(ftype)
7978 
      iprot.readFieldEnd()
7979 
    iprot.readStructEnd()
7980 
 
7981 
  def write(self, oprot):
7982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7984 
      return
7985 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 7986 
    if self.success is not None:
1899 vikas 7987 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7988 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7989 
      for iter124 in self.success:
7990 
        iter124.write(oprot)
1899 vikas 7991 
      oprot.writeListEnd()
7992 
      oprot.writeFieldEnd()
3431 rajveer 7993 
    if self.utx is not None:
1899 vikas 7994 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7995 
      self.utx.write(oprot)
7996 
      oprot.writeFieldEnd()
7997 
    oprot.writeFieldStop()
7998 
    oprot.writeStructEnd()
7999 
 
3431 rajveer 8000 
  def validate(self):
8001 
    return
8002 
 
8003 
 
1899 vikas 8004 
  def __repr__(self):
8005 
    L = ['%s=%r' % (key, value)
8006 
      for key, value in self.__dict__.iteritems()]
8007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8008 
 
8009 
  def __eq__(self, other):
8010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8011 
 
8012 
  def __ne__(self, other):
8013 
    return not (self == other)
8014 
 
1845 vikas 8015 
class getMasterAffiliateById_args:
8016 
  """
8017 
  Attributes:
8018 
   - id
8019 
  """
8020 
 
8021 
  thrift_spec = (
8022 
    None, # 0
8023 
    (1, TType.I64, 'id', None, None, ), # 1
8024 
  )
8025 
 
8026 
  def __init__(self, id=None,):
8027 
    self.id = id
8028 
 
8029 
  def read(self, iprot):
8030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8032 
      return
8033 
    iprot.readStructBegin()
8034 
    while True:
8035 
      (fname, ftype, fid) = iprot.readFieldBegin()
8036 
      if ftype == TType.STOP:
8037 
        break
8038 
      if fid == 1:
8039 
        if ftype == TType.I64:
8040 
          self.id = iprot.readI64();
8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      else:
8044 
        iprot.skip(ftype)
8045 
      iprot.readFieldEnd()
8046 
    iprot.readStructEnd()
8047 
 
8048 
  def write(self, oprot):
8049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8051 
      return
8052 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8053 
    if self.id is not None:
1845 vikas 8054 
      oprot.writeFieldBegin('id', TType.I64, 1)
8055 
      oprot.writeI64(self.id)
8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
3431 rajveer 8060 
  def validate(self):
8061 
    return
8062 
 
8063 
 
1845 vikas 8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
8075 
class getMasterAffiliateById_result:
8076 
  """
8077 
  Attributes:
8078 
   - success
8079 
   - utx
8080 
  """
8081 
 
8082 
  thrift_spec = (
8083 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8084 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8085 
  )
8086 
 
8087 
  def __init__(self, success=None, utx=None,):
8088 
    self.success = success
8089 
    self.utx = utx
8090 
 
8091 
  def read(self, iprot):
8092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8094 
      return
8095 
    iprot.readStructBegin()
8096 
    while True:
8097 
      (fname, ftype, fid) = iprot.readFieldBegin()
8098 
      if ftype == TType.STOP:
8099 
        break
8100 
      if fid == 0:
8101 
        if ftype == TType.STRUCT:
8102 
          self.success = MasterAffiliate()
8103 
          self.success.read(iprot)
8104 
        else:
8105 
          iprot.skip(ftype)
8106 
      elif fid == 1:
8107 
        if ftype == TType.STRUCT:
1996 vikas 8108 
          self.utx = UserAffiliateException()
1845 vikas 8109 
          self.utx.read(iprot)
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      else:
8113 
        iprot.skip(ftype)
8114 
      iprot.readFieldEnd()
8115 
    iprot.readStructEnd()
8116 
 
8117 
  def write(self, oprot):
8118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8120 
      return
8121 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8122 
    if self.success is not None:
1845 vikas 8123 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8124 
      self.success.write(oprot)
8125 
      oprot.writeFieldEnd()
3431 rajveer 8126 
    if self.utx is not None:
1845 vikas 8127 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8128 
      self.utx.write(oprot)
8129 
      oprot.writeFieldEnd()
8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
3431 rajveer 8133 
  def validate(self):
8134 
    return
8135 
 
8136 
 
1845 vikas 8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
8148 
class getMasterAffiliateByName_args:
8149 
  """
8150 
  Attributes:
8151 
   - name
8152 
  """
8153 
 
8154 
  thrift_spec = (
8155 
    None, # 0
8156 
    (1, TType.STRING, 'name', None, None, ), # 1
8157 
  )
8158 
 
8159 
  def __init__(self, name=None,):
8160 
    self.name = name
8161 
 
8162 
  def read(self, iprot):
8163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8165 
      return
8166 
    iprot.readStructBegin()
8167 
    while True:
8168 
      (fname, ftype, fid) = iprot.readFieldBegin()
8169 
      if ftype == TType.STOP:
8170 
        break
8171 
      if fid == 1:
8172 
        if ftype == TType.STRING:
8173 
          self.name = iprot.readString();
8174 
        else:
8175 
          iprot.skip(ftype)
8176 
      else:
8177 
        iprot.skip(ftype)
8178 
      iprot.readFieldEnd()
8179 
    iprot.readStructEnd()
8180 
 
8181 
  def write(self, oprot):
8182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8184 
      return
8185 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8186 
    if self.name is not None:
1845 vikas 8187 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8188 
      oprot.writeString(self.name)
8189 
      oprot.writeFieldEnd()
8190 
    oprot.writeFieldStop()
8191 
    oprot.writeStructEnd()
8192 
 
3431 rajveer 8193 
  def validate(self):
8194 
    return
8195 
 
8196 
 
1845 vikas 8197 
  def __repr__(self):
8198 
    L = ['%s=%r' % (key, value)
8199 
      for key, value in self.__dict__.iteritems()]
8200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8201 
 
8202 
  def __eq__(self, other):
8203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8204 
 
8205 
  def __ne__(self, other):
8206 
    return not (self == other)
8207 
 
8208 
class getMasterAffiliateByName_result:
8209 
  """
8210 
  Attributes:
8211 
   - success
8212 
   - utx
8213 
  """
8214 
 
8215 
  thrift_spec = (
8216 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8217 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8218 
  )
8219 
 
8220 
  def __init__(self, success=None, utx=None,):
8221 
    self.success = success
8222 
    self.utx = utx
8223 
 
8224 
  def read(self, iprot):
8225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8227 
      return
8228 
    iprot.readStructBegin()
8229 
    while True:
8230 
      (fname, ftype, fid) = iprot.readFieldBegin()
8231 
      if ftype == TType.STOP:
8232 
        break
8233 
      if fid == 0:
8234 
        if ftype == TType.STRUCT:
8235 
          self.success = MasterAffiliate()
8236 
          self.success.read(iprot)
8237 
        else:
8238 
          iprot.skip(ftype)
8239 
      elif fid == 1:
8240 
        if ftype == TType.STRUCT:
1996 vikas 8241 
          self.utx = UserAffiliateException()
1845 vikas 8242 
          self.utx.read(iprot)
8243 
        else:
8244 
          iprot.skip(ftype)
8245 
      else:
8246 
        iprot.skip(ftype)
8247 
      iprot.readFieldEnd()
8248 
    iprot.readStructEnd()
8249 
 
8250 
  def write(self, oprot):
8251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8253 
      return
8254 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8255 
    if self.success is not None:
1845 vikas 8256 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8257 
      self.success.write(oprot)
8258 
      oprot.writeFieldEnd()
3431 rajveer 8259 
    if self.utx is not None:
1845 vikas 8260 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8261 
      self.utx.write(oprot)
8262 
      oprot.writeFieldEnd()
8263 
    oprot.writeFieldStop()
8264 
    oprot.writeStructEnd()
8265 
 
3431 rajveer 8266 
  def validate(self):
8267 
    return
8268 
 
8269 
 
1845 vikas 8270 
  def __repr__(self):
8271 
    L = ['%s=%r' % (key, value)
8272 
      for key, value in self.__dict__.iteritems()]
8273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8274 
 
8275 
  def __eq__(self, other):
8276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8277 
 
8278 
  def __ne__(self, other):
8279 
    return not (self == other)
8280 
 
8281 
class createAffiliate_args:
8282 
  """
8283 
  Attributes:
8284 
   - name
8285 
   - url
8286 
   - masterAffiliateId
1859 vikas 8287 
   - addedOn
1845 vikas 8288 
  """
8289 
 
8290 
  thrift_spec = (
8291 
    None, # 0
8292 
    (1, TType.STRING, 'name', None, None, ), # 1
8293 
    (2, TType.STRING, 'url', None, None, ), # 2
8294 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8295 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8296 
  )
8297 
 
1859 vikas 8298 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8299 
    self.name = name
8300 
    self.url = url
8301 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8302 
    self.addedOn = addedOn
1845 vikas 8303 
 
8304 
  def read(self, iprot):
8305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8307 
      return
8308 
    iprot.readStructBegin()
8309 
    while True:
8310 
      (fname, ftype, fid) = iprot.readFieldBegin()
8311 
      if ftype == TType.STOP:
8312 
        break
8313 
      if fid == 1:
8314 
        if ftype == TType.STRING:
8315 
          self.name = iprot.readString();
8316 
        else:
8317 
          iprot.skip(ftype)
8318 
      elif fid == 2:
8319 
        if ftype == TType.STRING:
8320 
          self.url = iprot.readString();
8321 
        else:
8322 
          iprot.skip(ftype)
8323 
      elif fid == 3:
8324 
        if ftype == TType.I64:
8325 
          self.masterAffiliateId = iprot.readI64();
8326 
        else:
8327 
          iprot.skip(ftype)
1859 vikas 8328 
      elif fid == 4:
8329 
        if ftype == TType.I64:
8330 
          self.addedOn = iprot.readI64();
8331 
        else:
8332 
          iprot.skip(ftype)
1845 vikas 8333 
      else:
8334 
        iprot.skip(ftype)
8335 
      iprot.readFieldEnd()
8336 
    iprot.readStructEnd()
8337 
 
8338 
  def write(self, oprot):
8339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8341 
      return
8342 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8343 
    if self.name is not None:
1845 vikas 8344 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8345 
      oprot.writeString(self.name)
8346 
      oprot.writeFieldEnd()
3431 rajveer 8347 
    if self.url is not None:
1845 vikas 8348 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8349 
      oprot.writeString(self.url)
8350 
      oprot.writeFieldEnd()
3431 rajveer 8351 
    if self.masterAffiliateId is not None:
1845 vikas 8352 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8353 
      oprot.writeI64(self.masterAffiliateId)
8354 
      oprot.writeFieldEnd()
3431 rajveer 8355 
    if self.addedOn is not None:
1859 vikas 8356 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8357 
      oprot.writeI64(self.addedOn)
8358 
      oprot.writeFieldEnd()
1845 vikas 8359 
    oprot.writeFieldStop()
8360 
    oprot.writeStructEnd()
8361 
 
3431 rajveer 8362 
  def validate(self):
8363 
    return
8364 
 
8365 
 
1845 vikas 8366 
  def __repr__(self):
8367 
    L = ['%s=%r' % (key, value)
8368 
      for key, value in self.__dict__.iteritems()]
8369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8370 
 
8371 
  def __eq__(self, other):
8372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8373 
 
8374 
  def __ne__(self, other):
8375 
    return not (self == other)
8376 
 
8377 
class createAffiliate_result:
8378 
  """
8379 
  Attributes:
8380 
   - success
8381 
   - utx
8382 
  """
8383 
 
8384 
  thrift_spec = (
8385 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8386 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8387 
  )
8388 
 
8389 
  def __init__(self, success=None, utx=None,):
8390 
    self.success = success
8391 
    self.utx = utx
8392 
 
8393 
  def read(self, iprot):
8394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8396 
      return
8397 
    iprot.readStructBegin()
8398 
    while True:
8399 
      (fname, ftype, fid) = iprot.readFieldBegin()
8400 
      if ftype == TType.STOP:
8401 
        break
8402 
      if fid == 0:
8403 
        if ftype == TType.STRUCT:
8404 
          self.success = Affiliate()
8405 
          self.success.read(iprot)
8406 
        else:
8407 
          iprot.skip(ftype)
8408 
      elif fid == 1:
8409 
        if ftype == TType.STRUCT:
1996 vikas 8410 
          self.utx = UserAffiliateException()
1845 vikas 8411 
          self.utx.read(iprot)
8412 
        else:
8413 
          iprot.skip(ftype)
8414 
      else:
8415 
        iprot.skip(ftype)
8416 
      iprot.readFieldEnd()
8417 
    iprot.readStructEnd()
8418 
 
8419 
  def write(self, oprot):
8420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8422 
      return
8423 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8424 
    if self.success is not None:
1845 vikas 8425 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8426 
      self.success.write(oprot)
8427 
      oprot.writeFieldEnd()
3431 rajveer 8428 
    if self.utx is not None:
1845 vikas 8429 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8430 
      self.utx.write(oprot)
8431 
      oprot.writeFieldEnd()
8432 
    oprot.writeFieldStop()
8433 
    oprot.writeStructEnd()
8434 
 
3431 rajveer 8435 
  def validate(self):
8436 
    return
8437 
 
8438 
 
1845 vikas 8439 
  def __repr__(self):
8440 
    L = ['%s=%r' % (key, value)
8441 
      for key, value in self.__dict__.iteritems()]
8442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8443 
 
8444 
  def __eq__(self, other):
8445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8446 
 
8447 
  def __ne__(self, other):
8448 
    return not (self == other)
8449 
 
8450 
class getAffiliateById_args:
8451 
  """
8452 
  Attributes:
8453 
   - id
8454 
  """
8455 
 
8456 
  thrift_spec = (
8457 
    None, # 0
8458 
    (1, TType.I64, 'id', None, None, ), # 1
8459 
  )
8460 
 
8461 
  def __init__(self, id=None,):
8462 
    self.id = id
8463 
 
8464 
  def read(self, iprot):
8465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8467 
      return
8468 
    iprot.readStructBegin()
8469 
    while True:
8470 
      (fname, ftype, fid) = iprot.readFieldBegin()
8471 
      if ftype == TType.STOP:
8472 
        break
8473 
      if fid == 1:
8474 
        if ftype == TType.I64:
8475 
          self.id = iprot.readI64();
8476 
        else:
8477 
          iprot.skip(ftype)
8478 
      else:
8479 
        iprot.skip(ftype)
8480 
      iprot.readFieldEnd()
8481 
    iprot.readStructEnd()
8482 
 
8483 
  def write(self, oprot):
8484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8486 
      return
8487 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8488 
    if self.id is not None:
1845 vikas 8489 
      oprot.writeFieldBegin('id', TType.I64, 1)
8490 
      oprot.writeI64(self.id)
8491 
      oprot.writeFieldEnd()
8492 
    oprot.writeFieldStop()
8493 
    oprot.writeStructEnd()
8494 
 
3431 rajveer 8495 
  def validate(self):
8496 
    return
8497 
 
8498 
 
1845 vikas 8499 
  def __repr__(self):
8500 
    L = ['%s=%r' % (key, value)
8501 
      for key, value in self.__dict__.iteritems()]
8502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8503 
 
8504 
  def __eq__(self, other):
8505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8506 
 
8507 
  def __ne__(self, other):
8508 
    return not (self == other)
8509 
 
8510 
class getAffiliateById_result:
8511 
  """
8512 
  Attributes:
8513 
   - success
8514 
   - utx
8515 
  """
8516 
 
8517 
  thrift_spec = (
8518 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8519 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8520 
  )
8521 
 
8522 
  def __init__(self, success=None, utx=None,):
8523 
    self.success = success
8524 
    self.utx = utx
8525 
 
8526 
  def read(self, iprot):
8527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8529 
      return
8530 
    iprot.readStructBegin()
8531 
    while True:
8532 
      (fname, ftype, fid) = iprot.readFieldBegin()
8533 
      if ftype == TType.STOP:
8534 
        break
8535 
      if fid == 0:
8536 
        if ftype == TType.STRUCT:
8537 
          self.success = Affiliate()
8538 
          self.success.read(iprot)
8539 
        else:
8540 
          iprot.skip(ftype)
8541 
      elif fid == 1:
8542 
        if ftype == TType.STRUCT:
1996 vikas 8543 
          self.utx = UserAffiliateException()
1845 vikas 8544 
          self.utx.read(iprot)
8545 
        else:
8546 
          iprot.skip(ftype)
8547 
      else:
8548 
        iprot.skip(ftype)
8549 
      iprot.readFieldEnd()
8550 
    iprot.readStructEnd()
8551 
 
8552 
  def write(self, oprot):
8553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8555 
      return
8556 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 8557 
    if self.success is not None:
1845 vikas 8558 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8559 
      self.success.write(oprot)
8560 
      oprot.writeFieldEnd()
3431 rajveer 8561 
    if self.utx is not None:
1845 vikas 8562 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8563 
      self.utx.write(oprot)
8564 
      oprot.writeFieldEnd()
8565 
    oprot.writeFieldStop()
8566 
    oprot.writeStructEnd()
8567 
 
3431 rajveer 8568 
  def validate(self):
8569 
    return
8570 
 
8571 
 
1845 vikas 8572 
  def __repr__(self):
8573 
    L = ['%s=%r' % (key, value)
8574 
      for key, value in self.__dict__.iteritems()]
8575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8576 
 
8577 
  def __eq__(self, other):
8578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8579 
 
8580 
  def __ne__(self, other):
8581 
    return not (self == other)
8582 
 
8583 
class getAffiliateByName_args:
8584 
  """
8585 
  Attributes:
8586 
   - name
8587 
  """
8588 
 
8589 
  thrift_spec = (
8590 
    None, # 0
8591 
    (1, TType.STRING, 'name', None, None, ), # 1
8592 
  )
8593 
 
8594 
  def __init__(self, name=None,):
8595 
    self.name = name
8596 
 
8597 
  def read(self, iprot):
8598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8600 
      return
8601 
    iprot.readStructBegin()
8602 
    while True:
8603 
      (fname, ftype, fid) = iprot.readFieldBegin()
8604 
      if ftype == TType.STOP:
8605 
        break
8606 
      if fid == 1:
8607 
        if ftype == TType.STRING:
8608 
          self.name = iprot.readString();
8609 
        else:
8610 
          iprot.skip(ftype)
8611 
      else:
8612 
        iprot.skip(ftype)
8613 
      iprot.readFieldEnd()
8614 
    iprot.readStructEnd()
8615 
 
8616 
  def write(self, oprot):
8617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8619 
      return
8620 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 8621 
    if self.name is not None:
1845 vikas 8622 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8623 
      oprot.writeString(self.name)
8624 
      oprot.writeFieldEnd()
8625 
    oprot.writeFieldStop()
8626 
    oprot.writeStructEnd()
8627 
 
3431 rajveer 8628 
  def validate(self):
8629 
    return
8630 
 
8631 
 
1845 vikas 8632 
  def __repr__(self):
8633 
    L = ['%s=%r' % (key, value)
8634 
      for key, value in self.__dict__.iteritems()]
8635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8636 
 
8637 
  def __eq__(self, other):
8638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8639 
 
8640 
  def __ne__(self, other):
8641 
    return not (self == other)
8642 
 
8643 
class getAffiliateByName_result:
8644 
  """
8645 
  Attributes:
8646 
   - success
8647 
   - utx
8648 
  """
8649 
 
8650 
  thrift_spec = (
8651 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8652 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8653 
  )
8654 
 
8655 
  def __init__(self, success=None, utx=None,):
8656 
    self.success = success
8657 
    self.utx = utx
8658 
 
8659 
  def read(self, iprot):
8660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8662 
      return
8663 
    iprot.readStructBegin()
8664 
    while True:
8665 
      (fname, ftype, fid) = iprot.readFieldBegin()
8666 
      if ftype == TType.STOP:
8667 
        break
8668 
      if fid == 0:
8669 
        if ftype == TType.STRUCT:
8670 
          self.success = Affiliate()
8671 
          self.success.read(iprot)
8672 
        else:
8673 
          iprot.skip(ftype)
8674 
      elif fid == 1:
8675 
        if ftype == TType.STRUCT:
1996 vikas 8676 
          self.utx = UserAffiliateException()
1845 vikas 8677 
          self.utx.read(iprot)
8678 
        else:
8679 
          iprot.skip(ftype)
8680 
      else:
8681 
        iprot.skip(ftype)
8682 
      iprot.readFieldEnd()
8683 
    iprot.readStructEnd()
8684 
 
8685 
  def write(self, oprot):
8686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8688 
      return
8689 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 8690 
    if self.success is not None:
1845 vikas 8691 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8692 
      self.success.write(oprot)
8693 
      oprot.writeFieldEnd()
3431 rajveer 8694 
    if self.utx is not None:
1845 vikas 8695 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8696 
      self.utx.write(oprot)
8697 
      oprot.writeFieldEnd()
8698 
    oprot.writeFieldStop()
8699 
    oprot.writeStructEnd()
8700 
 
3431 rajveer 8701 
  def validate(self):
8702 
    return
8703 
 
8704 
 
1845 vikas 8705 
  def __repr__(self):
8706 
    L = ['%s=%r' % (key, value)
8707 
      for key, value in self.__dict__.iteritems()]
8708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8709 
 
8710 
  def __eq__(self, other):
8711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8712 
 
8713 
  def __ne__(self, other):
8714 
    return not (self == other)
8715 
 
1996 vikas 8716 
class getTrackerById_args:
1845 vikas 8717 
  """
8718 
  Attributes:
8719 
   - id
8720 
  """
8721 
 
8722 
  thrift_spec = (
8723 
    None, # 0
8724 
    (1, TType.I64, 'id', None, None, ), # 1
8725 
  )
8726 
 
8727 
  def __init__(self, id=None,):
8728 
    self.id = id
8729 
 
8730 
  def read(self, iprot):
8731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8733 
      return
8734 
    iprot.readStructBegin()
8735 
    while True:
8736 
      (fname, ftype, fid) = iprot.readFieldBegin()
8737 
      if ftype == TType.STOP:
8738 
        break
8739 
      if fid == 1:
8740 
        if ftype == TType.I64:
8741 
          self.id = iprot.readI64();
8742 
        else:
8743 
          iprot.skip(ftype)
8744 
      else:
8745 
        iprot.skip(ftype)
8746 
      iprot.readFieldEnd()
8747 
    iprot.readStructEnd()
8748 
 
8749 
  def write(self, oprot):
8750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8752 
      return
1996 vikas 8753 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 8754 
    if self.id is not None:
1845 vikas 8755 
      oprot.writeFieldBegin('id', TType.I64, 1)
8756 
      oprot.writeI64(self.id)
8757 
      oprot.writeFieldEnd()
8758 
    oprot.writeFieldStop()
8759 
    oprot.writeStructEnd()
8760 
 
3431 rajveer 8761 
  def validate(self):
8762 
    return
8763 
 
8764 
 
1845 vikas 8765 
  def __repr__(self):
8766 
    L = ['%s=%r' % (key, value)
8767 
      for key, value in self.__dict__.iteritems()]
8768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8769 
 
8770 
  def __eq__(self, other):
8771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8772 
 
8773 
  def __ne__(self, other):
8774 
    return not (self == other)
8775 
 
8776 
class getTrackerById_result:
8777 
  """
8778 
  Attributes:
8779 
   - success
8780 
   - utx
8781 
  """
8782 
 
8783 
  thrift_spec = (
8784 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8785 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8786 
  )
8787 
 
8788 
  def __init__(self, success=None, utx=None,):
8789 
    self.success = success
8790 
    self.utx = utx
8791 
 
8792 
  def read(self, iprot):
8793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8795 
      return
8796 
    iprot.readStructBegin()
8797 
    while True:
8798 
      (fname, ftype, fid) = iprot.readFieldBegin()
8799 
      if ftype == TType.STOP:
8800 
        break
8801 
      if fid == 0:
8802 
        if ftype == TType.STRUCT:
8803 
          self.success = Tracker()
8804 
          self.success.read(iprot)
8805 
        else:
8806 
          iprot.skip(ftype)
8807 
      elif fid == 1:
8808 
        if ftype == TType.STRUCT:
1996 vikas 8809 
          self.utx = UserAffiliateException()
1845 vikas 8810 
          self.utx.read(iprot)
8811 
        else:
8812 
          iprot.skip(ftype)
8813 
      else:
8814 
        iprot.skip(ftype)
8815 
      iprot.readFieldEnd()
8816 
    iprot.readStructEnd()
8817 
 
8818 
  def write(self, oprot):
8819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8821 
      return
8822 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 8823 
    if self.success is not None:
1845 vikas 8824 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8825 
      self.success.write(oprot)
8826 
      oprot.writeFieldEnd()
3431 rajveer 8827 
    if self.utx is not None:
1845 vikas 8828 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8829 
      self.utx.write(oprot)
8830 
      oprot.writeFieldEnd()
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
3431 rajveer 8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
1845 vikas 8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
1996 vikas 8849 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8850 
  """
8851 
  Attributes:
1996 vikas 8852 
   - id
1845 vikas 8853 
  """
8854 
 
8855 
  thrift_spec = (
8856 
    None, # 0
1996 vikas 8857 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8858 
  )
8859 
 
1996 vikas 8860 
  def __init__(self, id=None,):
8861 
    self.id = id
1845 vikas 8862 
 
8863 
  def read(self, iprot):
8864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8866 
      return
8867 
    iprot.readStructBegin()
8868 
    while True:
8869 
      (fname, ftype, fid) = iprot.readFieldBegin()
8870 
      if ftype == TType.STOP:
8871 
        break
8872 
      if fid == 1:
8873 
        if ftype == TType.I64:
1996 vikas 8874 
          self.id = iprot.readI64();
1845 vikas 8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      else:
8878 
        iprot.skip(ftype)
8879 
      iprot.readFieldEnd()
8880 
    iprot.readStructEnd()
8881 
 
8882 
  def write(self, oprot):
8883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8885 
      return
1996 vikas 8886 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 8887 
    if self.id is not None:
1996 vikas 8888 
      oprot.writeFieldBegin('id', TType.I64, 1)
8889 
      oprot.writeI64(self.id)
1845 vikas 8890 
      oprot.writeFieldEnd()
8891 
    oprot.writeFieldStop()
8892 
    oprot.writeStructEnd()
8893 
 
3431 rajveer 8894 
  def validate(self):
8895 
    return
8896 
 
8897 
 
1845 vikas 8898 
  def __repr__(self):
8899 
    L = ['%s=%r' % (key, value)
8900 
      for key, value in self.__dict__.iteritems()]
8901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8902 
 
8903 
  def __eq__(self, other):
8904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8905 
 
8906 
  def __ne__(self, other):
8907 
    return not (self == other)
8908 
 
1996 vikas 8909 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8910 
  """
8911 
  Attributes:
8912 
   - success
8913 
   - utx
8914 
  """
8915 
 
8916 
  thrift_spec = (
1996 vikas 8917 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8918 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8919 
  )
8920 
 
8921 
  def __init__(self, success=None, utx=None,):
8922 
    self.success = success
8923 
    self.utx = utx
8924 
 
8925 
  def read(self, iprot):
8926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8928 
      return
8929 
    iprot.readStructBegin()
8930 
    while True:
8931 
      (fname, ftype, fid) = iprot.readFieldBegin()
8932 
      if ftype == TType.STOP:
8933 
        break
8934 
      if fid == 0:
8935 
        if ftype == TType.LIST:
8936 
          self.success = []
11592 amit.gupta 8937 
          (_etype128, _size125) = iprot.readListBegin()
8938 
          for _i129 in xrange(_size125):
8939 
            _elem130 = Affiliate()
8940 
            _elem130.read(iprot)
8941 
            self.success.append(_elem130)
1845 vikas 8942 
          iprot.readListEnd()
8943 
        else:
8944 
          iprot.skip(ftype)
8945 
      elif fid == 1:
8946 
        if ftype == TType.STRUCT:
1996 vikas 8947 
          self.utx = UserAffiliateException()
1845 vikas 8948 
          self.utx.read(iprot)
8949 
        else:
8950 
          iprot.skip(ftype)
8951 
      else:
8952 
        iprot.skip(ftype)
8953 
      iprot.readFieldEnd()
8954 
    iprot.readStructEnd()
8955 
 
8956 
  def write(self, oprot):
8957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8959 
      return
1996 vikas 8960 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 8961 
    if self.success is not None:
1845 vikas 8962 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8963 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8964 
      for iter131 in self.success:
8965 
        iter131.write(oprot)
1845 vikas 8966 
      oprot.writeListEnd()
8967 
      oprot.writeFieldEnd()
3431 rajveer 8968 
    if self.utx is not None:
1845 vikas 8969 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8970 
      self.utx.write(oprot)
8971 
      oprot.writeFieldEnd()
8972 
    oprot.writeFieldStop()
8973 
    oprot.writeStructEnd()
8974 
 
3431 rajveer 8975 
  def validate(self):
8976 
    return
8977 
 
8978 
 
1845 vikas 8979 
  def __repr__(self):
8980 
    L = ['%s=%r' % (key, value)
8981 
      for key, value in self.__dict__.iteritems()]
8982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8983 
 
8984 
  def __eq__(self, other):
8985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8986 
 
8987 
  def __ne__(self, other):
8988 
    return not (self == other)
8989 
 
8990 
class addTrackLog_args:
8991 
  """
8992 
  Attributes:
1996 vikas 8993 
   - affiliateId
1845 vikas 8994 
   - userId
8995 
   - event
8996 
   - url
8997 
   - data
1859 vikas 8998 
   - addedOn
1845 vikas 8999 
  """
9000 
 
9001 
  thrift_spec = (
9002 
    None, # 0
1996 vikas 9003 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9004 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9005 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9006 
    (4, TType.STRING, 'url', None, None, ), # 4
9007 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9008 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9009 
  )
9010 
 
1996 vikas 9011 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9012 
    self.affiliateId = affiliateId
1845 vikas 9013 
    self.userId = userId
9014 
    self.event = event
9015 
    self.url = url
9016 
    self.data = data
1859 vikas 9017 
    self.addedOn = addedOn
1845 vikas 9018 
 
9019 
  def read(self, iprot):
9020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9022 
      return
9023 
    iprot.readStructBegin()
9024 
    while True:
9025 
      (fname, ftype, fid) = iprot.readFieldBegin()
9026 
      if ftype == TType.STOP:
9027 
        break
9028 
      if fid == 1:
9029 
        if ftype == TType.I64:
1996 vikas 9030 
          self.affiliateId = iprot.readI64();
1845 vikas 9031 
        else:
9032 
          iprot.skip(ftype)
9033 
      elif fid == 2:
9034 
        if ftype == TType.I64:
9035 
          self.userId = iprot.readI64();
9036 
        else:
9037 
          iprot.skip(ftype)
9038 
      elif fid == 3:
3378 vikas 9039 
        if ftype == TType.I32:
9040 
          self.event = iprot.readI32();
1845 vikas 9041 
        else:
9042 
          iprot.skip(ftype)
9043 
      elif fid == 4:
9044 
        if ftype == TType.STRING:
9045 
          self.url = iprot.readString();
9046 
        else:
9047 
          iprot.skip(ftype)
9048 
      elif fid == 5:
9049 
        if ftype == TType.STRING:
9050 
          self.data = iprot.readString();
9051 
        else:
9052 
          iprot.skip(ftype)
1859 vikas 9053 
      elif fid == 6:
9054 
        if ftype == TType.I64:
9055 
          self.addedOn = iprot.readI64();
9056 
        else:
9057 
          iprot.skip(ftype)
1845 vikas 9058 
      else:
9059 
        iprot.skip(ftype)
9060 
      iprot.readFieldEnd()
9061 
    iprot.readStructEnd()
9062 
 
9063 
  def write(self, oprot):
9064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9066 
      return
9067 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9068 
    if self.affiliateId is not None:
1996 vikas 9069 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9070 
      oprot.writeI64(self.affiliateId)
1845 vikas 9071 
      oprot.writeFieldEnd()
3431 rajveer 9072 
    if self.userId is not None:
1845 vikas 9073 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9074 
      oprot.writeI64(self.userId)
9075 
      oprot.writeFieldEnd()
3431 rajveer 9076 
    if self.event is not None:
3378 vikas 9077 
      oprot.writeFieldBegin('event', TType.I32, 3)
9078 
      oprot.writeI32(self.event)
1845 vikas 9079 
      oprot.writeFieldEnd()
3431 rajveer 9080 
    if self.url is not None:
1845 vikas 9081 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9082 
      oprot.writeString(self.url)
9083 
      oprot.writeFieldEnd()
3431 rajveer 9084 
    if self.data is not None:
1845 vikas 9085 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9086 
      oprot.writeString(self.data)
9087 
      oprot.writeFieldEnd()
3431 rajveer 9088 
    if self.addedOn is not None:
1859 vikas 9089 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9090 
      oprot.writeI64(self.addedOn)
9091 
      oprot.writeFieldEnd()
1845 vikas 9092 
    oprot.writeFieldStop()
9093 
    oprot.writeStructEnd()
9094 
 
3431 rajveer 9095 
  def validate(self):
9096 
    return
9097 
 
9098 
 
1845 vikas 9099 
  def __repr__(self):
9100 
    L = ['%s=%r' % (key, value)
9101 
      for key, value in self.__dict__.iteritems()]
9102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9103 
 
9104 
  def __eq__(self, other):
9105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9106 
 
9107 
  def __ne__(self, other):
9108 
    return not (self == other)
9109 
 
9110 
class addTrackLog_result:
9111 
  """
9112 
  Attributes:
9113 
   - success
9114 
   - utx
9115 
  """
9116 
 
9117 
  thrift_spec = (
9118 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9119 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9120 
  )
9121 
 
9122 
  def __init__(self, success=None, utx=None,):
9123 
    self.success = success
9124 
    self.utx = utx
9125 
 
9126 
  def read(self, iprot):
9127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9129 
      return
9130 
    iprot.readStructBegin()
9131 
    while True:
9132 
      (fname, ftype, fid) = iprot.readFieldBegin()
9133 
      if ftype == TType.STOP:
9134 
        break
9135 
      if fid == 0:
9136 
        if ftype == TType.I64:
9137 
          self.success = iprot.readI64();
9138 
        else:
9139 
          iprot.skip(ftype)
9140 
      elif fid == 1:
9141 
        if ftype == TType.STRUCT:
1996 vikas 9142 
          self.utx = UserAffiliateException()
1845 vikas 9143 
          self.utx.read(iprot)
9144 
        else:
9145 
          iprot.skip(ftype)
9146 
      else:
9147 
        iprot.skip(ftype)
9148 
      iprot.readFieldEnd()
9149 
    iprot.readStructEnd()
9150 
 
9151 
  def write(self, oprot):
9152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9154 
      return
9155 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9156 
    if self.success is not None:
1845 vikas 9157 
      oprot.writeFieldBegin('success', TType.I64, 0)
9158 
      oprot.writeI64(self.success)
9159 
      oprot.writeFieldEnd()
3431 rajveer 9160 
    if self.utx is not None:
1845 vikas 9161 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9162 
      self.utx.write(oprot)
9163 
      oprot.writeFieldEnd()
9164 
    oprot.writeFieldStop()
9165 
    oprot.writeStructEnd()
9166 
 
3431 rajveer 9167 
  def validate(self):
9168 
    return
9169 
 
9170 
 
1845 vikas 9171 
  def __repr__(self):
9172 
    L = ['%s=%r' % (key, value)
9173 
      for key, value in self.__dict__.iteritems()]
9174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9175 
 
9176 
  def __eq__(self, other):
9177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9178 
 
9179 
  def __ne__(self, other):
9180 
    return not (self == other)
9181 
 
9182 
class getTrackLogById_args:
9183 
  """
9184 
  Attributes:
9185 
   - id
9186 
  """
9187 
 
9188 
  thrift_spec = (
9189 
    None, # 0
9190 
    (1, TType.I64, 'id', None, None, ), # 1
9191 
  )
9192 
 
9193 
  def __init__(self, id=None,):
9194 
    self.id = id
9195 
 
9196 
  def read(self, iprot):
9197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9199 
      return
9200 
    iprot.readStructBegin()
9201 
    while True:
9202 
      (fname, ftype, fid) = iprot.readFieldBegin()
9203 
      if ftype == TType.STOP:
9204 
        break
9205 
      if fid == 1:
9206 
        if ftype == TType.I64:
9207 
          self.id = iprot.readI64();
9208 
        else:
9209 
          iprot.skip(ftype)
9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9220 
    if self.id is not None:
1845 vikas 9221 
      oprot.writeFieldBegin('id', TType.I64, 1)
9222 
      oprot.writeI64(self.id)
9223 
      oprot.writeFieldEnd()
9224 
    oprot.writeFieldStop()
9225 
    oprot.writeStructEnd()
9226 
 
3431 rajveer 9227 
  def validate(self):
9228 
    return
9229 
 
9230 
 
1845 vikas 9231 
  def __repr__(self):
9232 
    L = ['%s=%r' % (key, value)
9233 
      for key, value in self.__dict__.iteritems()]
9234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9235 
 
9236 
  def __eq__(self, other):
9237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9238 
 
9239 
  def __ne__(self, other):
9240 
    return not (self == other)
9241 
 
9242 
class getTrackLogById_result:
9243 
  """
9244 
  Attributes:
9245 
   - success
9246 
   - utx
9247 
  """
9248 
 
9249 
  thrift_spec = (
9250 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9251 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9252 
  )
9253 
 
9254 
  def __init__(self, success=None, utx=None,):
9255 
    self.success = success
9256 
    self.utx = utx
9257 
 
9258 
  def read(self, iprot):
9259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9261 
      return
9262 
    iprot.readStructBegin()
9263 
    while True:
9264 
      (fname, ftype, fid) = iprot.readFieldBegin()
9265 
      if ftype == TType.STOP:
9266 
        break
9267 
      if fid == 0:
9268 
        if ftype == TType.STRUCT:
9269 
          self.success = TrackLog()
9270 
          self.success.read(iprot)
9271 
        else:
9272 
          iprot.skip(ftype)
9273 
      elif fid == 1:
9274 
        if ftype == TType.STRUCT:
1996 vikas 9275 
          self.utx = UserAffiliateException()
1845 vikas 9276 
          self.utx.read(iprot)
9277 
        else:
9278 
          iprot.skip(ftype)
9279 
      else:
9280 
        iprot.skip(ftype)
9281 
      iprot.readFieldEnd()
9282 
    iprot.readStructEnd()
9283 
 
9284 
  def write(self, oprot):
9285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9287 
      return
9288 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9289 
    if self.success is not None:
1845 vikas 9290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9291 
      self.success.write(oprot)
9292 
      oprot.writeFieldEnd()
3431 rajveer 9293 
    if self.utx is not None:
1845 vikas 9294 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9295 
      self.utx.write(oprot)
9296 
      oprot.writeFieldEnd()
9297 
    oprot.writeFieldStop()
9298 
    oprot.writeStructEnd()
9299 
 
3431 rajveer 9300 
  def validate(self):
9301 
    return
9302 
 
9303 
 
1845 vikas 9304 
  def __repr__(self):
9305 
    L = ['%s=%r' % (key, value)
9306 
      for key, value in self.__dict__.iteritems()]
9307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9308 
 
9309 
  def __eq__(self, other):
9310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9311 
 
9312 
  def __ne__(self, other):
9313 
    return not (self == other)
9314 
 
1996 vikas 9315 
class getTrackLogsByAffiliate_args:
1845 vikas 9316 
  """
9317 
  Attributes:
1996 vikas 9318 
   - affiliateId
3293 vikas 9319 
   - startDate
9320 
   - endDate
1845 vikas 9321 
  """
9322 
 
9323 
  thrift_spec = (
9324 
    None, # 0
1996 vikas 9325 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9326 
    (2, TType.I64, 'startDate', None, None, ), # 2
9327 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9328 
  )
9329 
 
3293 vikas 9330 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9331 
    self.affiliateId = affiliateId
3293 vikas 9332 
    self.startDate = startDate
9333 
    self.endDate = endDate
1845 vikas 9334 
 
9335 
  def read(self, iprot):
9336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9338 
      return
9339 
    iprot.readStructBegin()
9340 
    while True:
9341 
      (fname, ftype, fid) = iprot.readFieldBegin()
9342 
      if ftype == TType.STOP:
9343 
        break
9344 
      if fid == 1:
9345 
        if ftype == TType.I64:
1996 vikas 9346 
          self.affiliateId = iprot.readI64();
1845 vikas 9347 
        else:
9348 
          iprot.skip(ftype)
3293 vikas 9349 
      elif fid == 2:
9350 
        if ftype == TType.I64:
9351 
          self.startDate = iprot.readI64();
9352 
        else:
9353 
          iprot.skip(ftype)
9354 
      elif fid == 3:
9355 
        if ftype == TType.I64:
9356 
          self.endDate = iprot.readI64();
9357 
        else:
9358 
          iprot.skip(ftype)
1845 vikas 9359 
      else:
9360 
        iprot.skip(ftype)
9361 
      iprot.readFieldEnd()
9362 
    iprot.readStructEnd()
9363 
 
9364 
  def write(self, oprot):
9365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9367 
      return
1996 vikas 9368 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9369 
    if self.affiliateId is not None:
1996 vikas 9370 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9371 
      oprot.writeI64(self.affiliateId)
1845 vikas 9372 
      oprot.writeFieldEnd()
3431 rajveer 9373 
    if self.startDate is not None:
3293 vikas 9374 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9375 
      oprot.writeI64(self.startDate)
9376 
      oprot.writeFieldEnd()
3431 rajveer 9377 
    if self.endDate is not None:
3293 vikas 9378 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9379 
      oprot.writeI64(self.endDate)
9380 
      oprot.writeFieldEnd()
1845 vikas 9381 
    oprot.writeFieldStop()
9382 
    oprot.writeStructEnd()
9383 
 
3431 rajveer 9384 
  def validate(self):
9385 
    return
9386 
 
9387 
 
1845 vikas 9388 
  def __repr__(self):
9389 
    L = ['%s=%r' % (key, value)
9390 
      for key, value in self.__dict__.iteritems()]
9391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9392 
 
9393 
  def __eq__(self, other):
9394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9395 
 
9396 
  def __ne__(self, other):
9397 
    return not (self == other)
9398 
 
1996 vikas 9399 
class getTrackLogsByAffiliate_result:
1845 vikas 9400 
  """
9401 
  Attributes:
9402 
   - success
9403 
   - utx
9404 
  """
9405 
 
9406 
  thrift_spec = (
9407 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9408 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9409 
  )
9410 
 
9411 
  def __init__(self, success=None, utx=None,):
9412 
    self.success = success
9413 
    self.utx = utx
9414 
 
9415 
  def read(self, iprot):
9416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9418 
      return
9419 
    iprot.readStructBegin()
9420 
    while True:
9421 
      (fname, ftype, fid) = iprot.readFieldBegin()
9422 
      if ftype == TType.STOP:
9423 
        break
9424 
      if fid == 0:
9425 
        if ftype == TType.LIST:
9426 
          self.success = []
11592 amit.gupta 9427 
          (_etype135, _size132) = iprot.readListBegin()
9428 
          for _i136 in xrange(_size132):
9429 
            _elem137 = TrackLog()
9430 
            _elem137.read(iprot)
9431 
            self.success.append(_elem137)
1845 vikas 9432 
          iprot.readListEnd()
9433 
        else:
9434 
          iprot.skip(ftype)
9435 
      elif fid == 1:
9436 
        if ftype == TType.STRUCT:
1996 vikas 9437 
          self.utx = UserAffiliateException()
1845 vikas 9438 
          self.utx.read(iprot)
9439 
        else:
9440 
          iprot.skip(ftype)
9441 
      else:
9442 
        iprot.skip(ftype)
9443 
      iprot.readFieldEnd()
9444 
    iprot.readStructEnd()
9445 
 
9446 
  def write(self, oprot):
9447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9449 
      return
1996 vikas 9450 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9451 
    if self.success is not None:
1845 vikas 9452 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9453 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9454 
      for iter138 in self.success:
9455 
        iter138.write(oprot)
1845 vikas 9456 
      oprot.writeListEnd()
9457 
      oprot.writeFieldEnd()
3431 rajveer 9458 
    if self.utx is not None:
1845 vikas 9459 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9460 
      self.utx.write(oprot)
9461 
      oprot.writeFieldEnd()
9462 
    oprot.writeFieldStop()
9463 
    oprot.writeStructEnd()
9464 
 
3431 rajveer 9465 
  def validate(self):
9466 
    return
9467 
 
9468 
 
1845 vikas 9469 
  def __repr__(self):
9470 
    L = ['%s=%r' % (key, value)
9471 
      for key, value in self.__dict__.iteritems()]
9472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9473 
 
9474 
  def __eq__(self, other):
9475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9476 
 
9477 
  def __ne__(self, other):
9478 
    return not (self == other)
9479 
 
9480 
class getTrackLogsByUser_args:
9481 
  """
9482 
  Attributes:
9483 
   - userId
9484 
  """
9485 
 
9486 
  thrift_spec = (
9487 
    None, # 0
9488 
    (1, TType.I64, 'userId', None, None, ), # 1
9489 
  )
9490 
 
9491 
  def __init__(self, userId=None,):
9492 
    self.userId = userId
9493 
 
9494 
  def read(self, iprot):
9495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9497 
      return
9498 
    iprot.readStructBegin()
9499 
    while True:
9500 
      (fname, ftype, fid) = iprot.readFieldBegin()
9501 
      if ftype == TType.STOP:
9502 
        break
9503 
      if fid == 1:
9504 
        if ftype == TType.I64:
9505 
          self.userId = iprot.readI64();
9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      else:
9509 
        iprot.skip(ftype)
9510 
      iprot.readFieldEnd()
9511 
    iprot.readStructEnd()
9512 
 
9513 
  def write(self, oprot):
9514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9516 
      return
9517 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9518 
    if self.userId is not None:
1845 vikas 9519 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9520 
      oprot.writeI64(self.userId)
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 
 
9540 
class getTrackLogsByUser_result:
9541 
  """
9542 
  Attributes:
9543 
   - success
9544 
   - utx
9545 
  """
9546 
 
9547 
  thrift_spec = (
9548 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9549 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9550 
  )
9551 
 
9552 
  def __init__(self, success=None, utx=None,):
9553 
    self.success = success
9554 
    self.utx = utx
9555 
 
9556 
  def read(self, iprot):
9557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9559 
      return
9560 
    iprot.readStructBegin()
9561 
    while True:
9562 
      (fname, ftype, fid) = iprot.readFieldBegin()
9563 
      if ftype == TType.STOP:
9564 
        break
9565 
      if fid == 0:
9566 
        if ftype == TType.LIST:
9567 
          self.success = []
11592 amit.gupta 9568 
          (_etype142, _size139) = iprot.readListBegin()
9569 
          for _i143 in xrange(_size139):
9570 
            _elem144 = TrackLog()
9571 
            _elem144.read(iprot)
9572 
            self.success.append(_elem144)
1845 vikas 9573 
          iprot.readListEnd()
9574 
        else:
9575 
          iprot.skip(ftype)
9576 
      elif fid == 1:
9577 
        if ftype == TType.STRUCT:
1996 vikas 9578 
          self.utx = UserAffiliateException()
1845 vikas 9579 
          self.utx.read(iprot)
9580 
        else:
9581 
          iprot.skip(ftype)
9582 
      else:
9583 
        iprot.skip(ftype)
9584 
      iprot.readFieldEnd()
9585 
    iprot.readStructEnd()
9586 
 
9587 
  def write(self, oprot):
9588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9590 
      return
9591 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 9592 
    if self.success is not None:
1845 vikas 9593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9594 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9595 
      for iter145 in self.success:
9596 
        iter145.write(oprot)
1845 vikas 9597 
      oprot.writeListEnd()
9598 
      oprot.writeFieldEnd()
3431 rajveer 9599 
    if self.utx is not None:
1845 vikas 9600 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9601 
      self.utx.write(oprot)
9602 
      oprot.writeFieldEnd()
9603 
    oprot.writeFieldStop()
9604 
    oprot.writeStructEnd()
9605 
 
3431 rajveer 9606 
  def validate(self):
9607 
    return
9608 
 
9609 
 
1845 vikas 9610 
  def __repr__(self):
9611 
    L = ['%s=%r' % (key, value)
9612 
      for key, value in self.__dict__.iteritems()]
9613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9614 
 
9615 
  def __eq__(self, other):
9616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9617 
 
9618 
  def __ne__(self, other):
9619 
    return not (self == other)
9620 
 
9621 
class getTrackLogs_args:
9622 
  """
9623 
  Attributes:
9624 
   - userId
9625 
   - event
9626 
   - url
9627 
  """
9628 
 
9629 
  thrift_spec = (
9630 
    None, # 0
1996 vikas 9631 
    (1, TType.I64, 'userId', None, None, ), # 1
9632 
    (2, TType.STRING, 'event', None, None, ), # 2
9633 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9634 
  )
9635 
 
1996 vikas 9636 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9637 
    self.userId = userId
9638 
    self.event = event
9639 
    self.url = url
9640 
 
9641 
  def read(self, iprot):
9642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9644 
      return
9645 
    iprot.readStructBegin()
9646 
    while True:
9647 
      (fname, ftype, fid) = iprot.readFieldBegin()
9648 
      if ftype == TType.STOP:
9649 
        break
9650 
      if fid == 1:
9651 
        if ftype == TType.I64:
1996 vikas 9652 
          self.userId = iprot.readI64();
1845 vikas 9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      elif fid == 2:
9656 
        if ftype == TType.STRING:
9657 
          self.event = iprot.readString();
9658 
        else:
9659 
          iprot.skip(ftype)
1996 vikas 9660 
      elif fid == 3:
1845 vikas 9661 
        if ftype == TType.STRING:
9662 
          self.url = iprot.readString();
9663 
        else:
9664 
          iprot.skip(ftype)
9665 
      else:
9666 
        iprot.skip(ftype)
9667 
      iprot.readFieldEnd()
9668 
    iprot.readStructEnd()
9669 
 
9670 
  def write(self, oprot):
9671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9673 
      return
9674 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 9675 
    if self.userId is not None:
1996 vikas 9676 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9677 
      oprot.writeI64(self.userId)
9678 
      oprot.writeFieldEnd()
3431 rajveer 9679 
    if self.event is not None:
1996 vikas 9680 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9681 
      oprot.writeString(self.event)
9682 
      oprot.writeFieldEnd()
3431 rajveer 9683 
    if self.url is not None:
1996 vikas 9684 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9685 
      oprot.writeString(self.url)
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 getTrackLogs_result:
9706 
  """
9707 
  Attributes:
9708 
   - success
9709 
   - utx
9710 
  """
9711 
 
9712 
  thrift_spec = (
9713 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9714 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9715 
  )
9716 
 
9717 
  def __init__(self, success=None, utx=None,):
9718 
    self.success = success
9719 
    self.utx = utx
9720 
 
9721 
  def read(self, iprot):
9722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9724 
      return
9725 
    iprot.readStructBegin()
9726 
    while True:
9727 
      (fname, ftype, fid) = iprot.readFieldBegin()
9728 
      if ftype == TType.STOP:
9729 
        break
9730 
      if fid == 0:
9731 
        if ftype == TType.LIST:
9732 
          self.success = []
11592 amit.gupta 9733 
          (_etype149, _size146) = iprot.readListBegin()
9734 
          for _i150 in xrange(_size146):
9735 
            _elem151 = TrackLog()
9736 
            _elem151.read(iprot)
9737 
            self.success.append(_elem151)
1845 vikas 9738 
          iprot.readListEnd()
9739 
        else:
9740 
          iprot.skip(ftype)
9741 
      elif fid == 1:
9742 
        if ftype == TType.STRUCT:
1996 vikas 9743 
          self.utx = UserAffiliateException()
1845 vikas 9744 
          self.utx.read(iprot)
9745 
        else:
9746 
          iprot.skip(ftype)
9747 
      else:
9748 
        iprot.skip(ftype)
9749 
      iprot.readFieldEnd()
9750 
    iprot.readStructEnd()
9751 
 
9752 
  def write(self, oprot):
9753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9755 
      return
9756 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 9757 
    if self.success is not None:
1845 vikas 9758 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9759 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9760 
      for iter152 in self.success:
9761 
        iter152.write(oprot)
1845 vikas 9762 
      oprot.writeListEnd()
9763 
      oprot.writeFieldEnd()
3431 rajveer 9764 
    if self.utx is not None:
1845 vikas 9765 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9766 
      self.utx.write(oprot)
9767 
      oprot.writeFieldEnd()
9768 
    oprot.writeFieldStop()
9769 
    oprot.writeStructEnd()
9770 
 
3431 rajveer 9771 
  def validate(self):
9772 
    return
9773 
 
9774 
 
1845 vikas 9775 
  def __repr__(self):
9776 
    L = ['%s=%r' % (key, value)
9777 
      for key, value in self.__dict__.iteritems()]
9778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9779 
 
9780 
  def __eq__(self, other):
9781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9782 
 
9783 
  def __ne__(self, other):
9784 
    return not (self == other)
9785 
 
559 chandransh 9786 
class getCurrentCart_args:
94 ashish 9787 
  """
9788 
  Attributes:
559 chandransh 9789 
   - userId
9790 
  """
9791 
 
9792 
  thrift_spec = (
9793 
    None, # 0
9794 
    (1, TType.I64, 'userId', None, None, ), # 1
9795 
  )
9796 
 
9797 
  def __init__(self, userId=None,):
9798 
    self.userId = userId
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      if fid == 1:
9810 
        if ftype == TType.I64:
9811 
          self.userId = iprot.readI64();
9812 
        else:
9813 
          iprot.skip(ftype)
9814 
      else:
9815 
        iprot.skip(ftype)
9816 
      iprot.readFieldEnd()
9817 
    iprot.readStructEnd()
9818 
 
9819 
  def write(self, oprot):
9820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9822 
      return
9823 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 9824 
    if self.userId is not None:
559 chandransh 9825 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9826 
      oprot.writeI64(self.userId)
9827 
      oprot.writeFieldEnd()
9828 
    oprot.writeFieldStop()
9829 
    oprot.writeStructEnd()
9830 
 
3431 rajveer 9831 
  def validate(self):
9832 
    return
9833 
 
9834 
 
559 chandransh 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 getCurrentCart_result:
9847 
  """
9848 
  Attributes:
94 ashish 9849 
   - success
559 chandransh 9850 
   - scx
94 ashish 9851 
  """
9852 
 
9853 
  thrift_spec = (
559 chandransh 9854 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9855 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9856 
  )
9857 
 
559 chandransh 9858 
  def __init__(self, success=None, scx=None,):
94 ashish 9859 
    self.success = success
559 chandransh 9860 
    self.scx = scx
94 ashish 9861 
 
9862 
  def read(self, iprot):
9863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9865 
      return
9866 
    iprot.readStructBegin()
9867 
    while True:
9868 
      (fname, ftype, fid) = iprot.readFieldBegin()
9869 
      if ftype == TType.STOP:
9870 
        break
9871 
      if fid == 0:
559 chandransh 9872 
        if ftype == TType.STRUCT:
9873 
          self.success = Cart()
9874 
          self.success.read(iprot)
94 ashish 9875 
        else:
9876 
          iprot.skip(ftype)
9877 
      elif fid == 1:
9878 
        if ftype == TType.STRUCT:
559 chandransh 9879 
          self.scx = ShoppingCartException()
9880 
          self.scx.read(iprot)
94 ashish 9881 
        else:
9882 
          iprot.skip(ftype)
9883 
      else:
9884 
        iprot.skip(ftype)
9885 
      iprot.readFieldEnd()
9886 
    iprot.readStructEnd()
9887 
 
9888 
  def write(self, oprot):
9889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9891 
      return
559 chandransh 9892 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 9893 
    if self.success is not None:
559 chandransh 9894 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9895 
      self.success.write(oprot)
94 ashish 9896 
      oprot.writeFieldEnd()
3431 rajveer 9897 
    if self.scx is not None:
559 chandransh 9898 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9899 
      self.scx.write(oprot)
94 ashish 9900 
      oprot.writeFieldEnd()
9901 
    oprot.writeFieldStop()
9902 
    oprot.writeStructEnd()
9903 
 
3431 rajveer 9904 
  def validate(self):
9905 
    return
9906 
 
9907 
 
94 ashish 9908 
  def __repr__(self):
9909 
    L = ['%s=%r' % (key, value)
9910 
      for key, value in self.__dict__.iteritems()]
9911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9912 
 
9913 
  def __eq__(self, other):
9914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9915 
 
9916 
  def __ne__(self, other):
9917 
    return not (self == other)
9918 
 
559 chandransh 9919 
class getCart_args:
504 rajveer 9920 
  """
9921 
  Attributes:
559 chandransh 9922 
   - cartId
504 rajveer 9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    None, # 0
559 chandransh 9927 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9928 
  )
9929 
 
559 chandransh 9930 
  def __init__(self, cartId=None,):
9931 
    self.cartId = cartId
504 rajveer 9932 
 
9933 
  def read(self, iprot):
9934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9936 
      return
9937 
    iprot.readStructBegin()
9938 
    while True:
9939 
      (fname, ftype, fid) = iprot.readFieldBegin()
9940 
      if ftype == TType.STOP:
9941 
        break
9942 
      if fid == 1:
9943 
        if ftype == TType.I64:
559 chandransh 9944 
          self.cartId = iprot.readI64();
504 rajveer 9945 
        else:
9946 
          iprot.skip(ftype)
9947 
      else:
9948 
        iprot.skip(ftype)
9949 
      iprot.readFieldEnd()
9950 
    iprot.readStructEnd()
9951 
 
9952 
  def write(self, oprot):
9953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9955 
      return
559 chandransh 9956 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 9957 
    if self.cartId is not None:
559 chandransh 9958 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9959 
      oprot.writeI64(self.cartId)
504 rajveer 9960 
      oprot.writeFieldEnd()
9961 
    oprot.writeFieldStop()
9962 
    oprot.writeStructEnd()
9963 
 
3431 rajveer 9964 
  def validate(self):
9965 
    return
9966 
 
9967 
 
504 rajveer 9968 
  def __repr__(self):
9969 
    L = ['%s=%r' % (key, value)
9970 
      for key, value in self.__dict__.iteritems()]
9971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9972 
 
9973 
  def __eq__(self, other):
9974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9975 
 
9976 
  def __ne__(self, other):
9977 
    return not (self == other)
9978 
 
559 chandransh 9979 
class getCart_result:
504 rajveer 9980 
  """
9981 
  Attributes:
9982 
   - success
559 chandransh 9983 
   - scx
504 rajveer 9984 
  """
9985 
 
9986 
  thrift_spec = (
559 chandransh 9987 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9988 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9989 
  )
9990 
 
559 chandransh 9991 
  def __init__(self, success=None, scx=None,):
504 rajveer 9992 
    self.success = success
559 chandransh 9993 
    self.scx = scx
504 rajveer 9994 
 
9995 
  def read(self, iprot):
9996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9998 
      return
9999 
    iprot.readStructBegin()
10000 
    while True:
10001 
      (fname, ftype, fid) = iprot.readFieldBegin()
10002 
      if ftype == TType.STOP:
10003 
        break
10004 
      if fid == 0:
559 chandransh 10005 
        if ftype == TType.STRUCT:
10006 
          self.success = Cart()
10007 
          self.success.read(iprot)
504 rajveer 10008 
        else:
10009 
          iprot.skip(ftype)
10010 
      elif fid == 1:
10011 
        if ftype == TType.STRUCT:
559 chandransh 10012 
          self.scx = ShoppingCartException()
10013 
          self.scx.read(iprot)
504 rajveer 10014 
        else:
10015 
          iprot.skip(ftype)
10016 
      else:
10017 
        iprot.skip(ftype)
10018 
      iprot.readFieldEnd()
10019 
    iprot.readStructEnd()
10020 
 
10021 
  def write(self, oprot):
10022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10024 
      return
559 chandransh 10025 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10026 
    if self.success is not None:
559 chandransh 10027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10028 
      self.success.write(oprot)
504 rajveer 10029 
      oprot.writeFieldEnd()
3431 rajveer 10030 
    if self.scx is not None:
559 chandransh 10031 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10032 
      self.scx.write(oprot)
504 rajveer 10033 
      oprot.writeFieldEnd()
10034 
    oprot.writeFieldStop()
10035 
    oprot.writeStructEnd()
10036 
 
3431 rajveer 10037 
  def validate(self):
10038 
    return
10039 
 
10040 
 
504 rajveer 10041 
  def __repr__(self):
10042 
    L = ['%s=%r' % (key, value)
10043 
      for key, value in self.__dict__.iteritems()]
10044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10045 
 
10046 
  def __eq__(self, other):
10047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10048 
 
10049 
  def __ne__(self, other):
10050 
    return not (self == other)
10051 
 
559 chandransh 10052 
class getCartsByTime_args:
10053 
  """
10054 
  Attributes:
10055 
   - from_time
10056 
   - to_time
10057 
   - status
10058 
  """
10059 
 
10060 
  thrift_spec = (
10061 
    None, # 0
10062 
    (1, TType.I64, 'from_time', None, None, ), # 1
10063 
    (2, TType.I64, 'to_time', None, None, ), # 2
10064 
    (3, TType.I32, 'status', None, None, ), # 3
10065 
  )
10066 
 
10067 
  def __init__(self, from_time=None, to_time=None, status=None,):
10068 
    self.from_time = from_time
10069 
    self.to_time = to_time
10070 
    self.status = status
10071 
 
10072 
  def read(self, iprot):
10073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10075 
      return
10076 
    iprot.readStructBegin()
10077 
    while True:
10078 
      (fname, ftype, fid) = iprot.readFieldBegin()
10079 
      if ftype == TType.STOP:
10080 
        break
10081 
      if fid == 1:
94 ashish 10082 
        if ftype == TType.I64:
559 chandransh 10083 
          self.from_time = iprot.readI64();
94 ashish 10084 
        else:
10085 
          iprot.skip(ftype)
122 ashish 10086 
      elif fid == 2:
559 chandransh 10087 
        if ftype == TType.I64:
10088 
          self.to_time = iprot.readI64();
122 ashish 10089 
        else:
10090 
          iprot.skip(ftype)
559 chandransh 10091 
      elif fid == 3:
10092 
        if ftype == TType.I32:
10093 
          self.status = iprot.readI32();
10094 
        else:
10095 
          iprot.skip(ftype)
94 ashish 10096 
      else:
10097 
        iprot.skip(ftype)
10098 
      iprot.readFieldEnd()
10099 
    iprot.readStructEnd()
10100 
 
10101 
  def write(self, oprot):
10102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10104 
      return
559 chandransh 10105 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10106 
    if self.from_time is not None:
559 chandransh 10107 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10108 
      oprot.writeI64(self.from_time)
94 ashish 10109 
      oprot.writeFieldEnd()
3431 rajveer 10110 
    if self.to_time is not None:
559 chandransh 10111 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10112 
      oprot.writeI64(self.to_time)
122 ashish 10113 
      oprot.writeFieldEnd()
3431 rajveer 10114 
    if self.status is not None:
559 chandransh 10115 
      oprot.writeFieldBegin('status', TType.I32, 3)
10116 
      oprot.writeI32(self.status)
10117 
      oprot.writeFieldEnd()
94 ashish 10118 
    oprot.writeFieldStop()
10119 
    oprot.writeStructEnd()
10120 
 
3431 rajveer 10121 
  def validate(self):
10122 
    return
10123 
 
10124 
 
94 ashish 10125 
  def __repr__(self):
10126 
    L = ['%s=%r' % (key, value)
10127 
      for key, value in self.__dict__.iteritems()]
10128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10129 
 
10130 
  def __eq__(self, other):
10131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10132 
 
10133 
  def __ne__(self, other):
10134 
    return not (self == other)
10135 
 
559 chandransh 10136 
class getCartsByTime_result:
94 ashish 10137 
  """
10138 
  Attributes:
10139 
   - success
559 chandransh 10140 
   - scx
94 ashish 10141 
  """
10142 
 
10143 
  thrift_spec = (
559 chandransh 10144 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10145 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10146 
  )
10147 
 
559 chandransh 10148 
  def __init__(self, success=None, scx=None,):
94 ashish 10149 
    self.success = success
559 chandransh 10150 
    self.scx = scx
94 ashish 10151 
 
10152 
  def read(self, iprot):
10153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10155 
      return
10156 
    iprot.readStructBegin()
10157 
    while True:
10158 
      (fname, ftype, fid) = iprot.readFieldBegin()
10159 
      if ftype == TType.STOP:
10160 
        break
10161 
      if fid == 0:
559 chandransh 10162 
        if ftype == TType.LIST:
10163 
          self.success = []
11592 amit.gupta 10164 
          (_etype156, _size153) = iprot.readListBegin()
10165 
          for _i157 in xrange(_size153):
10166 
            _elem158 = Cart()
10167 
            _elem158.read(iprot)
10168 
            self.success.append(_elem158)
559 chandransh 10169 
          iprot.readListEnd()
94 ashish 10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      elif fid == 1:
10173 
        if ftype == TType.STRUCT:
559 chandransh 10174 
          self.scx = ShoppingCartException()
10175 
          self.scx.read(iprot)
94 ashish 10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
559 chandransh 10187 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10188 
    if self.success is not None:
559 chandransh 10189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10191 
      for iter159 in self.success:
10192 
        iter159.write(oprot)
559 chandransh 10193 
      oprot.writeListEnd()
94 ashish 10194 
      oprot.writeFieldEnd()
3431 rajveer 10195 
    if self.scx is not None:
559 chandransh 10196 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10197 
      self.scx.write(oprot)
94 ashish 10198 
      oprot.writeFieldEnd()
10199 
    oprot.writeFieldStop()
10200 
    oprot.writeStructEnd()
10201 
 
3431 rajveer 10202 
  def validate(self):
10203 
    return
10204 
 
10205 
 
94 ashish 10206 
  def __repr__(self):
10207 
    L = ['%s=%r' % (key, value)
10208 
      for key, value in self.__dict__.iteritems()]
10209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10210 
 
10211 
  def __eq__(self, other):
10212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10213 
 
10214 
  def __ne__(self, other):
10215 
    return not (self == other)
10216 
 
559 chandransh 10217 
class addItemToCart_args:
10218 
  """
10219 
  Attributes:
10220 
   - cartId
10221 
   - itemId
10222 
   - quantity
3557 rajveer 10223 
   - sourceId
559 chandransh 10224 
  """
10225 
 
10226 
  thrift_spec = (
10227 
    None, # 0
10228 
    (1, TType.I64, 'cartId', None, None, ), # 1
10229 
    (2, TType.I64, 'itemId', None, None, ), # 2
10230 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10231 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10232 
  )
10233 
 
3557 rajveer 10234 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10235 
    self.cartId = cartId
10236 
    self.itemId = itemId
10237 
    self.quantity = quantity
3557 rajveer 10238 
    self.sourceId = sourceId
559 chandransh 10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 1:
10250 
        if ftype == TType.I64:
10251 
          self.cartId = iprot.readI64();
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 2:
10255 
        if ftype == TType.I64:
10256 
          self.itemId = iprot.readI64();
10257 
        else:
10258 
          iprot.skip(ftype)
10259 
      elif fid == 3:
10260 
        if ftype == TType.I64:
10261 
          self.quantity = iprot.readI64();
10262 
        else:
10263 
          iprot.skip(ftype)
3557 rajveer 10264 
      elif fid == 4:
10265 
        if ftype == TType.I64:
10266 
          self.sourceId = iprot.readI64();
10267 
        else:
10268 
          iprot.skip(ftype)
559 chandransh 10269 
      else:
10270 
        iprot.skip(ftype)
10271 
      iprot.readFieldEnd()
10272 
    iprot.readStructEnd()
10273 
 
10274 
  def write(self, oprot):
10275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10277 
      return
10278 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10279 
    if self.cartId is not None:
559 chandransh 10280 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10281 
      oprot.writeI64(self.cartId)
10282 
      oprot.writeFieldEnd()
3431 rajveer 10283 
    if self.itemId is not None:
559 chandransh 10284 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10285 
      oprot.writeI64(self.itemId)
10286 
      oprot.writeFieldEnd()
3431 rajveer 10287 
    if self.quantity is not None:
559 chandransh 10288 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10289 
      oprot.writeI64(self.quantity)
10290 
      oprot.writeFieldEnd()
3557 rajveer 10291 
    if self.sourceId is not None:
10292 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10293 
      oprot.writeI64(self.sourceId)
10294 
      oprot.writeFieldEnd()
559 chandransh 10295 
    oprot.writeFieldStop()
10296 
    oprot.writeStructEnd()
10297 
 
3431 rajveer 10298 
  def validate(self):
10299 
    return
10300 
 
10301 
 
559 chandransh 10302 
  def __repr__(self):
10303 
    L = ['%s=%r' % (key, value)
10304 
      for key, value in self.__dict__.iteritems()]
10305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10306 
 
10307 
  def __eq__(self, other):
10308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10309 
 
10310 
  def __ne__(self, other):
10311 
    return not (self == other)
10312 
 
10313 
class addItemToCart_result:
10314 
  """
10315 
  Attributes:
2035 rajveer 10316 
   - success
559 chandransh 10317 
   - scx
10318 
  """
10319 
 
10320 
  thrift_spec = (
2035 rajveer 10321 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10322 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10323 
  )
10324 
 
2035 rajveer 10325 
  def __init__(self, success=None, scx=None,):
10326 
    self.success = success
559 chandransh 10327 
    self.scx = scx
10328 
 
10329 
  def read(self, iprot):
10330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10332 
      return
10333 
    iprot.readStructBegin()
10334 
    while True:
10335 
      (fname, ftype, fid) = iprot.readFieldBegin()
10336 
      if ftype == TType.STOP:
10337 
        break
2035 rajveer 10338 
      if fid == 0:
10339 
        if ftype == TType.STRING:
10340 
          self.success = iprot.readString();
10341 
        else:
10342 
          iprot.skip(ftype)
10343 
      elif fid == 1:
559 chandransh 10344 
        if ftype == TType.STRUCT:
10345 
          self.scx = ShoppingCartException()
10346 
          self.scx.read(iprot)
10347 
        else:
10348 
          iprot.skip(ftype)
10349 
      else:
10350 
        iprot.skip(ftype)
10351 
      iprot.readFieldEnd()
10352 
    iprot.readStructEnd()
10353 
 
10354 
  def write(self, oprot):
10355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10357 
      return
10358 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10359 
    if self.success is not None:
2035 rajveer 10360 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10361 
      oprot.writeString(self.success)
10362 
      oprot.writeFieldEnd()
3431 rajveer 10363 
    if self.scx is not None:
559 chandransh 10364 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10365 
      self.scx.write(oprot)
10366 
      oprot.writeFieldEnd()
10367 
    oprot.writeFieldStop()
10368 
    oprot.writeStructEnd()
10369 
 
3431 rajveer 10370 
  def validate(self):
10371 
    return
10372 
 
10373 
 
559 chandransh 10374 
  def __repr__(self):
10375 
    L = ['%s=%r' % (key, value)
10376 
      for key, value in self.__dict__.iteritems()]
10377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10378 
 
10379 
  def __eq__(self, other):
10380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10381 
 
10382 
  def __ne__(self, other):
10383 
    return not (self == other)
10384 
 
10385 
class deleteItemFromCart_args:
10386 
  """
10387 
  Attributes:
10388 
   - cartId
10389 
   - itemId
10390 
  """
10391 
 
10392 
  thrift_spec = (
10393 
    None, # 0
10394 
    (1, TType.I64, 'cartId', None, None, ), # 1
10395 
    (2, TType.I64, 'itemId', None, None, ), # 2
10396 
  )
10397 
 
10398 
  def __init__(self, cartId=None, itemId=None,):
10399 
    self.cartId = cartId
10400 
    self.itemId = itemId
10401 
 
10402 
  def read(self, iprot):
10403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10405 
      return
10406 
    iprot.readStructBegin()
10407 
    while True:
10408 
      (fname, ftype, fid) = iprot.readFieldBegin()
10409 
      if ftype == TType.STOP:
10410 
        break
10411 
      if fid == 1:
10412 
        if ftype == TType.I64:
10413 
          self.cartId = iprot.readI64();
10414 
        else:
10415 
          iprot.skip(ftype)
10416 
      elif fid == 2:
10417 
        if ftype == TType.I64:
10418 
          self.itemId = iprot.readI64();
10419 
        else:
10420 
          iprot.skip(ftype)
10421 
      else:
10422 
        iprot.skip(ftype)
10423 
      iprot.readFieldEnd()
10424 
    iprot.readStructEnd()
10425 
 
10426 
  def write(self, oprot):
10427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10429 
      return
10430 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10431 
    if self.cartId is not None:
559 chandransh 10432 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10433 
      oprot.writeI64(self.cartId)
10434 
      oprot.writeFieldEnd()
3431 rajveer 10435 
    if self.itemId is not None:
559 chandransh 10436 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10437 
      oprot.writeI64(self.itemId)
10438 
      oprot.writeFieldEnd()
10439 
    oprot.writeFieldStop()
10440 
    oprot.writeStructEnd()
10441 
 
3431 rajveer 10442 
  def validate(self):
10443 
    return
10444 
 
10445 
 
559 chandransh 10446 
  def __repr__(self):
10447 
    L = ['%s=%r' % (key, value)
10448 
      for key, value in self.__dict__.iteritems()]
10449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10450 
 
10451 
  def __eq__(self, other):
10452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10453 
 
10454 
  def __ne__(self, other):
10455 
    return not (self == other)
10456 
 
10457 
class deleteItemFromCart_result:
10458 
  """
10459 
  Attributes:
10460 
   - scx
10461 
  """
10462 
 
10463 
  thrift_spec = (
10464 
    None, # 0
10465 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10466 
  )
10467 
 
10468 
  def __init__(self, scx=None,):
10469 
    self.scx = scx
10470 
 
10471 
  def read(self, iprot):
10472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10474 
      return
10475 
    iprot.readStructBegin()
10476 
    while True:
10477 
      (fname, ftype, fid) = iprot.readFieldBegin()
10478 
      if ftype == TType.STOP:
10479 
        break
10480 
      if fid == 1:
10481 
        if ftype == TType.STRUCT:
10482 
          self.scx = ShoppingCartException()
10483 
          self.scx.read(iprot)
10484 
        else:
10485 
          iprot.skip(ftype)
10486 
      else:
10487 
        iprot.skip(ftype)
10488 
      iprot.readFieldEnd()
10489 
    iprot.readStructEnd()
10490 
 
10491 
  def write(self, oprot):
10492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10494 
      return
10495 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10496 
    if self.scx is not None:
559 chandransh 10497 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10498 
      self.scx.write(oprot)
10499 
      oprot.writeFieldEnd()
10500 
    oprot.writeFieldStop()
10501 
    oprot.writeStructEnd()
10502 
 
3431 rajveer 10503 
  def validate(self):
10504 
    return
10505 
 
10506 
 
559 chandransh 10507 
  def __repr__(self):
10508 
    L = ['%s=%r' % (key, value)
10509 
      for key, value in self.__dict__.iteritems()]
10510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10511 
 
10512 
  def __eq__(self, other):
10513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10514 
 
10515 
  def __ne__(self, other):
10516 
    return not (self == other)
10517 
 
10518 
class addAddressToCart_args:
10519 
  """
10520 
  Attributes:
10521 
   - cartId
10522 
   - addressId
10523 
  """
10524 
 
10525 
  thrift_spec = (
10526 
    None, # 0
10527 
    (1, TType.I64, 'cartId', None, None, ), # 1
10528 
    (2, TType.I64, 'addressId', None, None, ), # 2
10529 
  )
10530 
 
10531 
  def __init__(self, cartId=None, addressId=None,):
10532 
    self.cartId = cartId
10533 
    self.addressId = addressId
10534 
 
10535 
  def read(self, iprot):
10536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10538 
      return
10539 
    iprot.readStructBegin()
10540 
    while True:
10541 
      (fname, ftype, fid) = iprot.readFieldBegin()
10542 
      if ftype == TType.STOP:
10543 
        break
10544 
      if fid == 1:
10545 
        if ftype == TType.I64:
10546 
          self.cartId = iprot.readI64();
10547 
        else:
10548 
          iprot.skip(ftype)
10549 
      elif fid == 2:
10550 
        if ftype == TType.I64:
10551 
          self.addressId = iprot.readI64();
10552 
        else:
10553 
          iprot.skip(ftype)
10554 
      else:
10555 
        iprot.skip(ftype)
10556 
      iprot.readFieldEnd()
10557 
    iprot.readStructEnd()
10558 
 
10559 
  def write(self, oprot):
10560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10562 
      return
10563 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 10564 
    if self.cartId is not None:
559 chandransh 10565 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10566 
      oprot.writeI64(self.cartId)
10567 
      oprot.writeFieldEnd()
3431 rajveer 10568 
    if self.addressId is not None:
559 chandransh 10569 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10570 
      oprot.writeI64(self.addressId)
10571 
      oprot.writeFieldEnd()
10572 
    oprot.writeFieldStop()
10573 
    oprot.writeStructEnd()
10574 
 
3431 rajveer 10575 
  def validate(self):
10576 
    return
10577 
 
10578 
 
559 chandransh 10579 
  def __repr__(self):
10580 
    L = ['%s=%r' % (key, value)
10581 
      for key, value in self.__dict__.iteritems()]
10582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10583 
 
10584 
  def __eq__(self, other):
10585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10586 
 
10587 
  def __ne__(self, other):
10588 
    return not (self == other)
10589 
 
10590 
class addAddressToCart_result:
575 chandransh 10591 
  """
10592 
  Attributes:
10593 
   - scx
10594 
  """
559 chandransh 10595 
 
10596 
  thrift_spec = (
575 chandransh 10597 
    None, # 0
10598 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10599 
  )
10600 
 
575 chandransh 10601 
  def __init__(self, scx=None,):
10602 
    self.scx = scx
10603 
 
559 chandransh 10604 
  def read(self, iprot):
10605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10607 
      return
10608 
    iprot.readStructBegin()
10609 
    while True:
10610 
      (fname, ftype, fid) = iprot.readFieldBegin()
10611 
      if ftype == TType.STOP:
10612 
        break
575 chandransh 10613 
      if fid == 1:
10614 
        if ftype == TType.STRUCT:
10615 
          self.scx = ShoppingCartException()
10616 
          self.scx.read(iprot)
10617 
        else:
10618 
          iprot.skip(ftype)
559 chandransh 10619 
      else:
10620 
        iprot.skip(ftype)
10621 
      iprot.readFieldEnd()
10622 
    iprot.readStructEnd()
10623 
 
10624 
  def write(self, oprot):
10625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10627 
      return
10628 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 10629 
    if self.scx is not None:
575 chandransh 10630 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10631 
      self.scx.write(oprot)
10632 
      oprot.writeFieldEnd()
559 chandransh 10633 
    oprot.writeFieldStop()
10634 
    oprot.writeStructEnd()
10635 
 
3431 rajveer 10636 
  def validate(self):
10637 
    return
10638 
 
10639 
 
559 chandransh 10640 
  def __repr__(self):
10641 
    L = ['%s=%r' % (key, value)
10642 
      for key, value in self.__dict__.iteritems()]
10643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10644 
 
10645 
  def __eq__(self, other):
10646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10647 
 
10648 
  def __ne__(self, other):
10649 
    return not (self == other)
10650 
 
5553 rajveer 10651 
class addStoreToCart_args:
10652 
  """
10653 
  Attributes:
10654 
   - cartId
10655 
   - storeId
10656 
  """
10657 
 
10658 
  thrift_spec = (
10659 
    None, # 0
10660 
    (1, TType.I64, 'cartId', None, None, ), # 1
10661 
    (2, TType.I64, 'storeId', None, None, ), # 2
10662 
  )
10663 
 
10664 
  def __init__(self, cartId=None, storeId=None,):
10665 
    self.cartId = cartId
10666 
    self.storeId = storeId
10667 
 
10668 
  def read(self, iprot):
10669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10671 
      return
10672 
    iprot.readStructBegin()
10673 
    while True:
10674 
      (fname, ftype, fid) = iprot.readFieldBegin()
10675 
      if ftype == TType.STOP:
10676 
        break
10677 
      if fid == 1:
10678 
        if ftype == TType.I64:
10679 
          self.cartId = iprot.readI64();
10680 
        else:
10681 
          iprot.skip(ftype)
10682 
      elif fid == 2:
10683 
        if ftype == TType.I64:
10684 
          self.storeId = iprot.readI64();
10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      else:
10688 
        iprot.skip(ftype)
10689 
      iprot.readFieldEnd()
10690 
    iprot.readStructEnd()
10691 
 
10692 
  def write(self, oprot):
10693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10695 
      return
10696 
    oprot.writeStructBegin('addStoreToCart_args')
10697 
    if self.cartId is not None:
10698 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10699 
      oprot.writeI64(self.cartId)
10700 
      oprot.writeFieldEnd()
10701 
    if self.storeId is not None:
10702 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
10703 
      oprot.writeI64(self.storeId)
10704 
      oprot.writeFieldEnd()
10705 
    oprot.writeFieldStop()
10706 
    oprot.writeStructEnd()
10707 
 
10708 
  def validate(self):
10709 
    return
10710 
 
10711 
 
10712 
  def __repr__(self):
10713 
    L = ['%s=%r' % (key, value)
10714 
      for key, value in self.__dict__.iteritems()]
10715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10716 
 
10717 
  def __eq__(self, other):
10718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10719 
 
10720 
  def __ne__(self, other):
10721 
    return not (self == other)
10722 
 
10723 
class addStoreToCart_result:
10724 
  """
10725 
  Attributes:
10726 
   - scx
10727 
  """
10728 
 
10729 
  thrift_spec = (
10730 
    None, # 0
10731 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10732 
  )
10733 
 
10734 
  def __init__(self, scx=None,):
10735 
    self.scx = scx
10736 
 
10737 
  def read(self, iprot):
10738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10740 
      return
10741 
    iprot.readStructBegin()
10742 
    while True:
10743 
      (fname, ftype, fid) = iprot.readFieldBegin()
10744 
      if ftype == TType.STOP:
10745 
        break
10746 
      if fid == 1:
10747 
        if ftype == TType.STRUCT:
10748 
          self.scx = ShoppingCartException()
10749 
          self.scx.read(iprot)
10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      else:
10753 
        iprot.skip(ftype)
10754 
      iprot.readFieldEnd()
10755 
    iprot.readStructEnd()
10756 
 
10757 
  def write(self, oprot):
10758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10760 
      return
10761 
    oprot.writeStructBegin('addStoreToCart_result')
10762 
    if self.scx is not None:
10763 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10764 
      self.scx.write(oprot)
10765 
      oprot.writeFieldEnd()
10766 
    oprot.writeFieldStop()
10767 
    oprot.writeStructEnd()
10768 
 
10769 
  def validate(self):
10770 
    return
10771 
 
10772 
 
10773 
  def __repr__(self):
10774 
    L = ['%s=%r' % (key, value)
10775 
      for key, value in self.__dict__.iteritems()]
10776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10777 
 
10778 
  def __eq__(self, other):
10779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10780 
 
10781 
  def __ne__(self, other):
10782 
    return not (self == other)
10783 
 
1976 varun.gupt 10784 
class applyCouponToCart_args:
10785 
  """
10786 
  Attributes:
6922 anupam.sin 10787 
   - cart
1976 varun.gupt 10788 
   - couponCode
10789 
  """
10790 
 
10791 
  thrift_spec = (
10792 
    None, # 0
6922 anupam.sin 10793 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 10794 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10795 
  )
10796 
 
6922 anupam.sin 10797 
  def __init__(self, cart=None, couponCode=None,):
10798 
    self.cart = cart
1976 varun.gupt 10799 
    self.couponCode = couponCode
10800 
 
10801 
  def read(self, iprot):
10802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10804 
      return
10805 
    iprot.readStructBegin()
10806 
    while True:
10807 
      (fname, ftype, fid) = iprot.readFieldBegin()
10808 
      if ftype == TType.STOP:
10809 
        break
10810 
      if fid == 1:
6922 anupam.sin 10811 
        if ftype == TType.STRUCT:
10812 
          self.cart = Cart()
10813 
          self.cart.read(iprot)
1976 varun.gupt 10814 
        else:
10815 
          iprot.skip(ftype)
10816 
      elif fid == 2:
10817 
        if ftype == TType.STRING:
10818 
          self.couponCode = iprot.readString();
10819 
        else:
10820 
          iprot.skip(ftype)
10821 
      else:
10822 
        iprot.skip(ftype)
10823 
      iprot.readFieldEnd()
10824 
    iprot.readStructEnd()
10825 
 
10826 
  def write(self, oprot):
10827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10829 
      return
10830 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 10831 
    if self.cart is not None:
10832 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
10833 
      self.cart.write(oprot)
1976 varun.gupt 10834 
      oprot.writeFieldEnd()
3431 rajveer 10835 
    if self.couponCode is not None:
1976 varun.gupt 10836 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10837 
      oprot.writeString(self.couponCode)
10838 
      oprot.writeFieldEnd()
10839 
    oprot.writeFieldStop()
10840 
    oprot.writeStructEnd()
10841 
 
3431 rajveer 10842 
  def validate(self):
10843 
    return
10844 
 
10845 
 
1976 varun.gupt 10846 
  def __repr__(self):
10847 
    L = ['%s=%r' % (key, value)
10848 
      for key, value in self.__dict__.iteritems()]
10849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10850 
 
10851 
  def __eq__(self, other):
10852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10853 
 
10854 
  def __ne__(self, other):
10855 
    return not (self == other)
10856 
 
10857 
class applyCouponToCart_result:
10858 
  """
10859 
  Attributes:
10860 
   - scx
10861 
  """
10862 
 
10863 
  thrift_spec = (
10864 
    None, # 0
10865 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10866 
  )
10867 
 
10868 
  def __init__(self, scx=None,):
10869 
    self.scx = scx
10870 
 
10871 
  def read(self, iprot):
10872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10874 
      return
10875 
    iprot.readStructBegin()
10876 
    while True:
10877 
      (fname, ftype, fid) = iprot.readFieldBegin()
10878 
      if ftype == TType.STOP:
10879 
        break
10880 
      if fid == 1:
10881 
        if ftype == TType.STRUCT:
10882 
          self.scx = ShoppingCartException()
10883 
          self.scx.read(iprot)
10884 
        else:
10885 
          iprot.skip(ftype)
10886 
      else:
10887 
        iprot.skip(ftype)
10888 
      iprot.readFieldEnd()
10889 
    iprot.readStructEnd()
10890 
 
10891 
  def write(self, oprot):
10892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10894 
      return
10895 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 10896 
    if self.scx is not None:
1976 varun.gupt 10897 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10898 
      self.scx.write(oprot)
10899 
      oprot.writeFieldEnd()
10900 
    oprot.writeFieldStop()
10901 
    oprot.writeStructEnd()
10902 
 
3431 rajveer 10903 
  def validate(self):
10904 
    return
10905 
 
10906 
 
1976 varun.gupt 10907 
  def __repr__(self):
10908 
    L = ['%s=%r' % (key, value)
10909 
      for key, value in self.__dict__.iteritems()]
10910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10911 
 
10912 
  def __eq__(self, other):
10913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10914 
 
10915 
  def __ne__(self, other):
10916 
    return not (self == other)
10917 
 
10918 
class removeCoupon_args:
10919 
  """
10920 
  Attributes:
10921 
   - cartId
10922 
  """
10923 
 
10924 
  thrift_spec = (
10925 
    None, # 0
10926 
    (1, TType.I64, 'cartId', None, None, ), # 1
10927 
  )
10928 
 
10929 
  def __init__(self, cartId=None,):
10930 
    self.cartId = cartId
10931 
 
10932 
  def read(self, iprot):
10933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10935 
      return
10936 
    iprot.readStructBegin()
10937 
    while True:
10938 
      (fname, ftype, fid) = iprot.readFieldBegin()
10939 
      if ftype == TType.STOP:
10940 
        break
10941 
      if fid == 1:
10942 
        if ftype == TType.I64:
10943 
          self.cartId = iprot.readI64();
10944 
        else:
10945 
          iprot.skip(ftype)
10946 
      else:
10947 
        iprot.skip(ftype)
10948 
      iprot.readFieldEnd()
10949 
    iprot.readStructEnd()
10950 
 
10951 
  def write(self, oprot):
10952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10954 
      return
10955 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 10956 
    if self.cartId is not None:
1976 varun.gupt 10957 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10958 
      oprot.writeI64(self.cartId)
10959 
      oprot.writeFieldEnd()
10960 
    oprot.writeFieldStop()
10961 
    oprot.writeStructEnd()
10962 
 
3431 rajveer 10963 
  def validate(self):
10964 
    return
10965 
 
10966 
 
1976 varun.gupt 10967 
  def __repr__(self):
10968 
    L = ['%s=%r' % (key, value)
10969 
      for key, value in self.__dict__.iteritems()]
10970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10971 
 
10972 
  def __eq__(self, other):
10973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10974 
 
10975 
  def __ne__(self, other):
10976 
    return not (self == other)
10977 
 
10978 
class removeCoupon_result:
10979 
  """
10980 
  Attributes:
10981 
   - scx
10982 
  """
10983 
 
10984 
  thrift_spec = (
10985 
    None, # 0
10986 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10987 
  )
10988 
 
10989 
  def __init__(self, scx=None,):
10990 
    self.scx = scx
10991 
 
10992 
  def read(self, iprot):
10993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10995 
      return
10996 
    iprot.readStructBegin()
10997 
    while True:
10998 
      (fname, ftype, fid) = iprot.readFieldBegin()
10999 
      if ftype == TType.STOP:
11000 
        break
11001 
      if fid == 1:
11002 
        if ftype == TType.STRUCT:
11003 
          self.scx = ShoppingCartException()
11004 
          self.scx.read(iprot)
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      else:
11008 
        iprot.skip(ftype)
11009 
      iprot.readFieldEnd()
11010 
    iprot.readStructEnd()
11011 
 
11012 
  def write(self, oprot):
11013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11015 
      return
11016 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11017 
    if self.scx is not None:
1976 varun.gupt 11018 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11019 
      self.scx.write(oprot)
11020 
      oprot.writeFieldEnd()
11021 
    oprot.writeFieldStop()
11022 
    oprot.writeStructEnd()
11023 
 
3431 rajveer 11024 
  def validate(self):
11025 
    return
11026 
 
11027 
 
1976 varun.gupt 11028 
  def __repr__(self):
11029 
    L = ['%s=%r' % (key, value)
11030 
      for key, value in self.__dict__.iteritems()]
11031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11032 
 
11033 
  def __eq__(self, other):
11034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11035 
 
11036 
  def __ne__(self, other):
11037 
    return not (self == other)
11038 
 
3554 varun.gupt 11039 
class deleteDiscountsFromCart_args:
11040 
  """
11041 
  Attributes:
11042 
   - cartId
11043 
  """
11044 
 
11045 
  thrift_spec = (
11046 
    None, # 0
11047 
    (1, TType.I64, 'cartId', None, None, ), # 1
11048 
  )
11049 
 
11050 
  def __init__(self, cartId=None,):
11051 
    self.cartId = cartId
11052 
 
11053 
  def read(self, iprot):
11054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11056 
      return
11057 
    iprot.readStructBegin()
11058 
    while True:
11059 
      (fname, ftype, fid) = iprot.readFieldBegin()
11060 
      if ftype == TType.STOP:
11061 
        break
11062 
      if fid == 1:
11063 
        if ftype == TType.I64:
11064 
          self.cartId = iprot.readI64();
11065 
        else:
11066 
          iprot.skip(ftype)
11067 
      else:
11068 
        iprot.skip(ftype)
11069 
      iprot.readFieldEnd()
11070 
    iprot.readStructEnd()
11071 
 
11072 
  def write(self, oprot):
11073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11075 
      return
11076 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11077 
    if self.cartId is not None:
11078 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11079 
      oprot.writeI64(self.cartId)
11080 
      oprot.writeFieldEnd()
11081 
    oprot.writeFieldStop()
11082 
    oprot.writeStructEnd()
11083 
 
11084 
  def validate(self):
11085 
    return
11086 
 
11087 
 
11088 
  def __repr__(self):
11089 
    L = ['%s=%r' % (key, value)
11090 
      for key, value in self.__dict__.iteritems()]
11091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11092 
 
11093 
  def __eq__(self, other):
11094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11095 
 
11096 
  def __ne__(self, other):
11097 
    return not (self == other)
11098 
 
11099 
class deleteDiscountsFromCart_result:
11100 
  """
11101 
  Attributes:
11102 
   - scx
11103 
  """
11104 
 
11105 
  thrift_spec = (
11106 
    None, # 0
11107 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11108 
  )
11109 
 
11110 
  def __init__(self, scx=None,):
11111 
    self.scx = scx
11112 
 
11113 
  def read(self, iprot):
11114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11116 
      return
11117 
    iprot.readStructBegin()
11118 
    while True:
11119 
      (fname, ftype, fid) = iprot.readFieldBegin()
11120 
      if ftype == TType.STOP:
11121 
        break
11122 
      if fid == 1:
11123 
        if ftype == TType.STRUCT:
11124 
          self.scx = ShoppingCartException()
11125 
          self.scx.read(iprot)
11126 
        else:
11127 
          iprot.skip(ftype)
11128 
      else:
11129 
        iprot.skip(ftype)
11130 
      iprot.readFieldEnd()
11131 
    iprot.readStructEnd()
11132 
 
11133 
  def write(self, oprot):
11134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11136 
      return
11137 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11138 
    if self.scx is not None:
11139 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11140 
      self.scx.write(oprot)
11141 
      oprot.writeFieldEnd()
11142 
    oprot.writeFieldStop()
11143 
    oprot.writeStructEnd()
11144 
 
11145 
  def validate(self):
11146 
    return
11147 
 
11148 
 
11149 
  def __repr__(self):
11150 
    L = ['%s=%r' % (key, value)
11151 
      for key, value in self.__dict__.iteritems()]
11152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11153 
 
11154 
  def __eq__(self, other):
11155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11156 
 
11157 
  def __ne__(self, other):
11158 
    return not (self == other)
11159 
 
11160 
class saveDiscounts_args:
11161 
  """
11162 
  Attributes:
11163 
   - discounts
11164 
  """
11165 
 
11166 
  thrift_spec = (
11167 
    None, # 0
11168 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11169 
  )
11170 
 
11171 
  def __init__(self, discounts=None,):
11172 
    self.discounts = discounts
11173 
 
11174 
  def read(self, iprot):
11175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11177 
      return
11178 
    iprot.readStructBegin()
11179 
    while True:
11180 
      (fname, ftype, fid) = iprot.readFieldBegin()
11181 
      if ftype == TType.STOP:
11182 
        break
11183 
      if fid == 1:
11184 
        if ftype == TType.LIST:
11185 
          self.discounts = []
11592 amit.gupta 11186 
          (_etype163, _size160) = iprot.readListBegin()
11187 
          for _i164 in xrange(_size160):
11188 
            _elem165 = Discount()
11189 
            _elem165.read(iprot)
11190 
            self.discounts.append(_elem165)
3554 varun.gupt 11191 
          iprot.readListEnd()
11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      else:
11195 
        iprot.skip(ftype)
11196 
      iprot.readFieldEnd()
11197 
    iprot.readStructEnd()
11198 
 
11199 
  def write(self, oprot):
11200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11202 
      return
11203 
    oprot.writeStructBegin('saveDiscounts_args')
11204 
    if self.discounts is not None:
11205 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11206 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11207 
      for iter166 in self.discounts:
11208 
        iter166.write(oprot)
3554 varun.gupt 11209 
      oprot.writeListEnd()
11210 
      oprot.writeFieldEnd()
11211 
    oprot.writeFieldStop()
11212 
    oprot.writeStructEnd()
11213 
 
11214 
  def validate(self):
11215 
    return
11216 
 
11217 
 
11218 
  def __repr__(self):
11219 
    L = ['%s=%r' % (key, value)
11220 
      for key, value in self.__dict__.iteritems()]
11221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11222 
 
11223 
  def __eq__(self, other):
11224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11225 
 
11226 
  def __ne__(self, other):
11227 
    return not (self == other)
11228 
 
11229 
class saveDiscounts_result:
11230 
  """
11231 
  Attributes:
11232 
   - scx
11233 
  """
11234 
 
11235 
  thrift_spec = (
11236 
    None, # 0
11237 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11238 
  )
11239 
 
11240 
  def __init__(self, scx=None,):
11241 
    self.scx = scx
11242 
 
11243 
  def read(self, iprot):
11244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11246 
      return
11247 
    iprot.readStructBegin()
11248 
    while True:
11249 
      (fname, ftype, fid) = iprot.readFieldBegin()
11250 
      if ftype == TType.STOP:
11251 
        break
11252 
      if fid == 1:
11253 
        if ftype == TType.STRUCT:
11254 
          self.scx = ShoppingCartException()
11255 
          self.scx.read(iprot)
11256 
        else:
11257 
          iprot.skip(ftype)
11258 
      else:
11259 
        iprot.skip(ftype)
11260 
      iprot.readFieldEnd()
11261 
    iprot.readStructEnd()
11262 
 
11263 
  def write(self, oprot):
11264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11266 
      return
11267 
    oprot.writeStructBegin('saveDiscounts_result')
11268 
    if self.scx is not None:
11269 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11270 
      self.scx.write(oprot)
11271 
      oprot.writeFieldEnd()
11272 
    oprot.writeFieldStop()
11273 
    oprot.writeStructEnd()
11274 
 
11275 
  def validate(self):
11276 
    return
11277 
 
11278 
 
11279 
  def __repr__(self):
11280 
    L = ['%s=%r' % (key, value)
11281 
      for key, value in self.__dict__.iteritems()]
11282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11283 
 
11284 
  def __eq__(self, other):
11285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11286 
 
11287 
  def __ne__(self, other):
11288 
    return not (self == other)
11289 
 
690 chandransh 11290 
class createOrders_args:
559 chandransh 11291 
  """
11292 
  Attributes:
11293 
   - cartId
2815 vikas 11294 
   - sessionSource
11295 
   - sessionStartTime
3858 vikas 11296 
   - firstSource
11297 
   - firstSourceTime
5326 rajveer 11298 
   - userId
6389 rajveer 11299 
   - schemeId
11526 amit.gupta 11300 
   - orderSource
559 chandransh 11301 
  """
11302 
 
11303 
  thrift_spec = (
11304 
    None, # 0
11305 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11306 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11307 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11308 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11309 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11310 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11311 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11312 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11313 
  )
11314 
 
11526 amit.gupta 11315 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11316 
    self.cartId = cartId
2815 vikas 11317 
    self.sessionSource = sessionSource
11318 
    self.sessionStartTime = sessionStartTime
3858 vikas 11319 
    self.firstSource = firstSource
11320 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11321 
    self.userId = userId
6389 rajveer 11322 
    self.schemeId = schemeId
11526 amit.gupta 11323 
    self.orderSource = orderSource
559 chandransh 11324 
 
11325 
  def read(self, iprot):
11326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11328 
      return
11329 
    iprot.readStructBegin()
11330 
    while True:
11331 
      (fname, ftype, fid) = iprot.readFieldBegin()
11332 
      if ftype == TType.STOP:
11333 
        break
11334 
      if fid == 1:
11335 
        if ftype == TType.I64:
11336 
          self.cartId = iprot.readI64();
11337 
        else:
11338 
          iprot.skip(ftype)
2815 vikas 11339 
      elif fid == 2:
11340 
        if ftype == TType.STRING:
11341 
          self.sessionSource = iprot.readString();
11342 
        else:
11343 
          iprot.skip(ftype)
11344 
      elif fid == 3:
11345 
        if ftype == TType.I64:
11346 
          self.sessionStartTime = iprot.readI64();
11347 
        else:
11348 
          iprot.skip(ftype)
3858 vikas 11349 
      elif fid == 4:
11350 
        if ftype == TType.STRING:
11351 
          self.firstSource = iprot.readString();
11352 
        else:
11353 
          iprot.skip(ftype)
11354 
      elif fid == 5:
11355 
        if ftype == TType.I64:
11356 
          self.firstSourceTime = iprot.readI64();
11357 
        else:
11358 
          iprot.skip(ftype)
5326 rajveer 11359 
      elif fid == 6:
11360 
        if ftype == TType.I64:
11361 
          self.userId = iprot.readI64();
11362 
        else:
11363 
          iprot.skip(ftype)
6389 rajveer 11364 
      elif fid == 7:
11365 
        if ftype == TType.I64:
11366 
          self.schemeId = iprot.readI64();
11367 
        else:
11368 
          iprot.skip(ftype)
11526 amit.gupta 11369 
      elif fid == 8:
11370 
        if ftype == TType.I64:
11371 
          self.orderSource = iprot.readI64();
11372 
        else:
11373 
          iprot.skip(ftype)
559 chandransh 11374 
      else:
11375 
        iprot.skip(ftype)
11376 
      iprot.readFieldEnd()
11377 
    iprot.readStructEnd()
11378 
 
11379 
  def write(self, oprot):
11380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11382 
      return
690 chandransh 11383 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11384 
    if self.cartId is not None:
559 chandransh 11385 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11386 
      oprot.writeI64(self.cartId)
11387 
      oprot.writeFieldEnd()
3431 rajveer 11388 
    if self.sessionSource is not None:
2815 vikas 11389 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11390 
      oprot.writeString(self.sessionSource)
11391 
      oprot.writeFieldEnd()
3431 rajveer 11392 
    if self.sessionStartTime is not None:
2815 vikas 11393 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11394 
      oprot.writeI64(self.sessionStartTime)
11395 
      oprot.writeFieldEnd()
3858 vikas 11396 
    if self.firstSource is not None:
11397 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11398 
      oprot.writeString(self.firstSource)
11399 
      oprot.writeFieldEnd()
11400 
    if self.firstSourceTime is not None:
11401 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11402 
      oprot.writeI64(self.firstSourceTime)
11403 
      oprot.writeFieldEnd()
5326 rajveer 11404 
    if self.userId is not None:
11405 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11406 
      oprot.writeI64(self.userId)
11407 
      oprot.writeFieldEnd()
6389 rajveer 11408 
    if self.schemeId is not None:
11409 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11410 
      oprot.writeI64(self.schemeId)
11411 
      oprot.writeFieldEnd()
11526 amit.gupta 11412 
    if self.orderSource is not None:
11413 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
11414 
      oprot.writeI64(self.orderSource)
11415 
      oprot.writeFieldEnd()
559 chandransh 11416 
    oprot.writeFieldStop()
11417 
    oprot.writeStructEnd()
11418 
 
3431 rajveer 11419 
  def validate(self):
11420 
    return
11421 
 
11422 
 
559 chandransh 11423 
  def __repr__(self):
11424 
    L = ['%s=%r' % (key, value)
11425 
      for key, value in self.__dict__.iteritems()]
11426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11427 
 
11428 
  def __eq__(self, other):
11429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11430 
 
11431 
  def __ne__(self, other):
11432 
    return not (self == other)
11433 
 
690 chandransh 11434 
class createOrders_result:
559 chandransh 11435 
  """
11436 
  Attributes:
94 ashish 11437 
   - success
559 chandransh 11438 
   - scx
94 ashish 11439 
  """
11440 
 
11441 
  thrift_spec = (
575 chandransh 11442 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11443 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11444 
  )
11445 
 
559 chandransh 11446 
  def __init__(self, success=None, scx=None,):
94 ashish 11447 
    self.success = success
559 chandransh 11448 
    self.scx = scx
94 ashish 11449 
 
11450 
  def read(self, iprot):
11451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11453 
      return
11454 
    iprot.readStructBegin()
11455 
    while True:
11456 
      (fname, ftype, fid) = iprot.readFieldBegin()
11457 
      if ftype == TType.STOP:
11458 
        break
11459 
      if fid == 0:
575 chandransh 11460 
        if ftype == TType.I64:
11461 
          self.success = iprot.readI64();
94 ashish 11462 
        else:
11463 
          iprot.skip(ftype)
11464 
      elif fid == 1:
11465 
        if ftype == TType.STRUCT:
559 chandransh 11466 
          self.scx = ShoppingCartException()
11467 
          self.scx.read(iprot)
94 ashish 11468 
        else:
11469 
          iprot.skip(ftype)
11470 
      else:
11471 
        iprot.skip(ftype)
11472 
      iprot.readFieldEnd()
11473 
    iprot.readStructEnd()
11474 
 
11475 
  def write(self, oprot):
11476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11478 
      return
690 chandransh 11479 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11480 
    if self.success is not None:
575 chandransh 11481 
      oprot.writeFieldBegin('success', TType.I64, 0)
11482 
      oprot.writeI64(self.success)
94 ashish 11483 
      oprot.writeFieldEnd()
3431 rajveer 11484 
    if self.scx is not None:
559 chandransh 11485 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11486 
      self.scx.write(oprot)
94 ashish 11487 
      oprot.writeFieldEnd()
11488 
    oprot.writeFieldStop()
11489 
    oprot.writeStructEnd()
11490 
 
3431 rajveer 11491 
  def validate(self):
11492 
    return
11493 
 
11494 
 
94 ashish 11495 
  def __repr__(self):
11496 
    L = ['%s=%r' % (key, value)
11497 
      for key, value in self.__dict__.iteritems()]
11498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11499 
 
11500 
  def __eq__(self, other):
11501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11502 
 
11503 
  def __ne__(self, other):
11504 
    return not (self == other)
11505 
 
559 chandransh 11506 
class validateCart_args:
94 ashish 11507 
  """
11508 
  Attributes:
559 chandransh 11509 
   - cartId
3557 rajveer 11510 
   - sourceId
94 ashish 11511 
  """
11512 
 
11513 
  thrift_spec = (
11514 
    None, # 0
559 chandransh 11515 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11516 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11517 
  )
11518 
 
3557 rajveer 11519 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11520 
    self.cartId = cartId
3557 rajveer 11521 
    self.sourceId = sourceId
94 ashish 11522 
 
11523 
  def read(self, iprot):
11524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11526 
      return
11527 
    iprot.readStructBegin()
11528 
    while True:
11529 
      (fname, ftype, fid) = iprot.readFieldBegin()
11530 
      if ftype == TType.STOP:
11531 
        break
11532 
      if fid == 1:
11533 
        if ftype == TType.I64:
559 chandransh 11534 
          self.cartId = iprot.readI64();
94 ashish 11535 
        else:
11536 
          iprot.skip(ftype)
3557 rajveer 11537 
      elif fid == 2:
11538 
        if ftype == TType.I64:
11539 
          self.sourceId = iprot.readI64();
11540 
        else:
11541 
          iprot.skip(ftype)
94 ashish 11542 
      else:
11543 
        iprot.skip(ftype)
11544 
      iprot.readFieldEnd()
11545 
    iprot.readStructEnd()
11546 
 
11547 
  def write(self, oprot):
11548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11550 
      return
559 chandransh 11551 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 11552 
    if self.cartId is not None:
559 chandransh 11553 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11554 
      oprot.writeI64(self.cartId)
94 ashish 11555 
      oprot.writeFieldEnd()
3557 rajveer 11556 
    if self.sourceId is not None:
11557 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11558 
      oprot.writeI64(self.sourceId)
11559 
      oprot.writeFieldEnd()
94 ashish 11560 
    oprot.writeFieldStop()
11561 
    oprot.writeStructEnd()
11562 
 
3431 rajveer 11563 
  def validate(self):
11564 
    return
11565 
 
11566 
 
94 ashish 11567 
  def __repr__(self):
11568 
    L = ['%s=%r' % (key, value)
11569 
      for key, value in self.__dict__.iteritems()]
11570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11571 
 
11572 
  def __eq__(self, other):
11573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11574 
 
11575 
  def __ne__(self, other):
11576 
    return not (self == other)
11577 
 
559 chandransh 11578 
class validateCart_result:
94 ashish 11579 
  """
11580 
  Attributes:
11581 
   - success
575 chandransh 11582 
   - scex
94 ashish 11583 
  """
11584 
 
11585 
  thrift_spec = (
6736 amit.gupta 11586 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 11587 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11588 
  )
11589 
 
575 chandransh 11590 
  def __init__(self, success=None, scex=None,):
94 ashish 11591 
    self.success = success
575 chandransh 11592 
    self.scex = scex
94 ashish 11593 
 
11594 
  def read(self, iprot):
11595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11597 
      return
11598 
    iprot.readStructBegin()
11599 
    while True:
11600 
      (fname, ftype, fid) = iprot.readFieldBegin()
11601 
      if ftype == TType.STOP:
11602 
        break
11603 
      if fid == 0:
6736 amit.gupta 11604 
        if ftype == TType.LIST:
11605 
          self.success = []
11592 amit.gupta 11606 
          (_etype170, _size167) = iprot.readListBegin()
11607 
          for _i171 in xrange(_size167):
11608 
            _elem172 = iprot.readString();
11609 
            self.success.append(_elem172)
6736 amit.gupta 11610 
          iprot.readListEnd()
94 ashish 11611 
        else:
11612 
          iprot.skip(ftype)
575 chandransh 11613 
      elif fid == 1:
11614 
        if ftype == TType.STRUCT:
11615 
          self.scex = ShoppingCartException()
11616 
          self.scex.read(iprot)
11617 
        else:
11618 
          iprot.skip(ftype)
94 ashish 11619 
      else:
11620 
        iprot.skip(ftype)
11621 
      iprot.readFieldEnd()
11622 
    iprot.readStructEnd()
11623 
 
11624 
  def write(self, oprot):
11625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11627 
      return
559 chandransh 11628 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 11629 
    if self.success is not None:
6736 amit.gupta 11630 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11631 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 11632 
      for iter173 in self.success:
11633 
        oprot.writeString(iter173)
6736 amit.gupta 11634 
      oprot.writeListEnd()
94 ashish 11635 
      oprot.writeFieldEnd()
3431 rajveer 11636 
    if self.scex is not None:
575 chandransh 11637 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11638 
      self.scex.write(oprot)
11639 
      oprot.writeFieldEnd()
559 chandransh 11640 
    oprot.writeFieldStop()
11641 
    oprot.writeStructEnd()
11642 
 
3431 rajveer 11643 
  def validate(self):
11644 
    return
11645 
 
11646 
 
559 chandransh 11647 
  def __repr__(self):
11648 
    L = ['%s=%r' % (key, value)
11649 
      for key, value in self.__dict__.iteritems()]
11650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11651 
 
11652 
  def __eq__(self, other):
11653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11654 
 
11655 
  def __ne__(self, other):
11656 
    return not (self == other)
11657 
 
690 chandransh 11658 
class mergeCart_args:
575 chandransh 11659 
  """
11660 
  Attributes:
690 chandransh 11661 
   - fromCartId
11662 
   - toCartId
11663 
  """
11664 
 
11665 
  thrift_spec = (
11666 
    None, # 0
11667 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11668 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11669 
  )
11670 
 
11671 
  def __init__(self, fromCartId=None, toCartId=None,):
11672 
    self.fromCartId = fromCartId
11673 
    self.toCartId = toCartId
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 == 1:
11685 
        if ftype == TType.I64:
11686 
          self.fromCartId = iprot.readI64();
11687 
        else:
11688 
          iprot.skip(ftype)
11689 
      elif fid == 2:
11690 
        if ftype == TType.I64:
11691 
          self.toCartId = iprot.readI64();
11692 
        else:
11693 
          iprot.skip(ftype)
11694 
      else:
11695 
        iprot.skip(ftype)
11696 
      iprot.readFieldEnd()
11697 
    iprot.readStructEnd()
11698 
 
11699 
  def write(self, oprot):
11700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11702 
      return
11703 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 11704 
    if self.fromCartId is not None:
690 chandransh 11705 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11706 
      oprot.writeI64(self.fromCartId)
11707 
      oprot.writeFieldEnd()
3431 rajveer 11708 
    if self.toCartId is not None:
690 chandransh 11709 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11710 
      oprot.writeI64(self.toCartId)
11711 
      oprot.writeFieldEnd()
11712 
    oprot.writeFieldStop()
11713 
    oprot.writeStructEnd()
11714 
 
3431 rajveer 11715 
  def validate(self):
11716 
    return
11717 
 
11718 
 
690 chandransh 11719 
  def __repr__(self):
11720 
    L = ['%s=%r' % (key, value)
11721 
      for key, value in self.__dict__.iteritems()]
11722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11723 
 
11724 
  def __eq__(self, other):
11725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11726 
 
11727 
  def __ne__(self, other):
11728 
    return not (self == other)
11729 
 
11730 
class mergeCart_result:
11731 
 
11732 
  thrift_spec = (
11733 
  )
11734 
 
11735 
  def read(self, iprot):
11736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11738 
      return
11739 
    iprot.readStructBegin()
11740 
    while True:
11741 
      (fname, ftype, fid) = iprot.readFieldBegin()
11742 
      if ftype == TType.STOP:
11743 
        break
11744 
      else:
11745 
        iprot.skip(ftype)
11746 
      iprot.readFieldEnd()
11747 
    iprot.readStructEnd()
11748 
 
11749 
  def write(self, oprot):
11750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11752 
      return
11753 
    oprot.writeStructBegin('mergeCart_result')
11754 
    oprot.writeFieldStop()
11755 
    oprot.writeStructEnd()
11756 
 
3431 rajveer 11757 
  def validate(self):
11758 
    return
11759 
 
11760 
 
690 chandransh 11761 
  def __repr__(self):
11762 
    L = ['%s=%r' % (key, value)
11763 
      for key, value in self.__dict__.iteritems()]
11764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11765 
 
11766 
  def __eq__(self, other):
11767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11768 
 
11769 
  def __ne__(self, other):
11770 
    return not (self == other)
11771 
 
11772 
class checkOut_args:
11773 
  """
11774 
  Attributes:
575 chandransh 11775 
   - cartId
11776 
  """
11777 
 
11778 
  thrift_spec = (
11779 
    None, # 0
11780 
    (1, TType.I64, 'cartId', None, None, ), # 1
11781 
  )
11782 
 
11783 
  def __init__(self, cartId=None,):
11784 
    self.cartId = cartId
11785 
 
11786 
  def read(self, iprot):
11787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11789 
      return
11790 
    iprot.readStructBegin()
11791 
    while True:
11792 
      (fname, ftype, fid) = iprot.readFieldBegin()
11793 
      if ftype == TType.STOP:
11794 
        break
11795 
      if fid == 1:
11796 
        if ftype == TType.I64:
11797 
          self.cartId = iprot.readI64();
11798 
        else:
11799 
          iprot.skip(ftype)
11800 
      else:
11801 
        iprot.skip(ftype)
11802 
      iprot.readFieldEnd()
11803 
    iprot.readStructEnd()
11804 
 
11805 
  def write(self, oprot):
11806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11808 
      return
690 chandransh 11809 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 11810 
    if self.cartId is not None:
575 chandransh 11811 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11812 
      oprot.writeI64(self.cartId)
11813 
      oprot.writeFieldEnd()
11814 
    oprot.writeFieldStop()
11815 
    oprot.writeStructEnd()
11816 
 
3431 rajveer 11817 
  def validate(self):
11818 
    return
11819 
 
11820 
 
575 chandransh 11821 
  def __repr__(self):
11822 
    L = ['%s=%r' % (key, value)
11823 
      for key, value in self.__dict__.iteritems()]
11824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11825 
 
11826 
  def __eq__(self, other):
11827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11828 
 
11829 
  def __ne__(self, other):
11830 
    return not (self == other)
11831 
 
690 chandransh 11832 
class checkOut_result:
575 chandransh 11833 
  """
11834 
  Attributes:
11835 
   - success
11836 
   - scex
11837 
  """
11838 
 
11839 
  thrift_spec = (
11840 
    (0, TType.BOOL, 'success', None, None, ), # 0
11841 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11842 
  )
11843 
 
11844 
  def __init__(self, success=None, scex=None,):
11845 
    self.success = success
11846 
    self.scex = scex
11847 
 
11848 
  def read(self, iprot):
11849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11851 
      return
11852 
    iprot.readStructBegin()
11853 
    while True:
11854 
      (fname, ftype, fid) = iprot.readFieldBegin()
11855 
      if ftype == TType.STOP:
11856 
        break
11857 
      if fid == 0:
11858 
        if ftype == TType.BOOL:
11859 
          self.success = iprot.readBool();
11860 
        else:
11861 
          iprot.skip(ftype)
11862 
      elif fid == 1:
11863 
        if ftype == TType.STRUCT:
11864 
          self.scex = ShoppingCartException()
11865 
          self.scex.read(iprot)
11866 
        else:
11867 
          iprot.skip(ftype)
11868 
      else:
11869 
        iprot.skip(ftype)
11870 
      iprot.readFieldEnd()
11871 
    iprot.readStructEnd()
11872 
 
11873 
  def write(self, oprot):
11874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11876 
      return
690 chandransh 11877 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 11878 
    if self.success is not None:
575 chandransh 11879 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11880 
      oprot.writeBool(self.success)
11881 
      oprot.writeFieldEnd()
3431 rajveer 11882 
    if self.scex is not None:
575 chandransh 11883 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11884 
      self.scex.write(oprot)
11885 
      oprot.writeFieldEnd()
11886 
    oprot.writeFieldStop()
11887 
    oprot.writeStructEnd()
11888 
 
3431 rajveer 11889 
  def validate(self):
11890 
    return
11891 
 
11892 
 
575 chandransh 11893 
  def __repr__(self):
11894 
    L = ['%s=%r' % (key, value)
11895 
      for key, value in self.__dict__.iteritems()]
11896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11897 
 
11898 
  def __eq__(self, other):
11899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11900 
 
11901 
  def __ne__(self, other):
11902 
    return not (self == other)
11903 
 
690 chandransh 11904 
class resetCart_args:
559 chandransh 11905 
  """
11906 
  Attributes:
690 chandransh 11907 
   - cartId
11908 
   - items
559 chandransh 11909 
  """
11910 
 
11911 
  thrift_spec = (
11912 
    None, # 0
690 chandransh 11913 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11914 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11915 
  )
11916 
 
690 chandransh 11917 
  def __init__(self, cartId=None, items=None,):
11918 
    self.cartId = cartId
11919 
    self.items = items
559 chandransh 11920 
 
11921 
  def read(self, iprot):
11922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11924 
      return
11925 
    iprot.readStructBegin()
11926 
    while True:
11927 
      (fname, ftype, fid) = iprot.readFieldBegin()
11928 
      if ftype == TType.STOP:
11929 
        break
11930 
      if fid == 1:
11931 
        if ftype == TType.I64:
690 chandransh 11932 
          self.cartId = iprot.readI64();
559 chandransh 11933 
        else:
11934 
          iprot.skip(ftype)
11935 
      elif fid == 2:
690 chandransh 11936 
        if ftype == TType.MAP:
11937 
          self.items = {}
11592 amit.gupta 11938 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11939 
          for _i178 in xrange(_size174):
11940 
            _key179 = iprot.readI64();
11941 
            _val180 = iprot.readDouble();
11942 
            self.items[_key179] = _val180
690 chandransh 11943 
          iprot.readMapEnd()
559 chandransh 11944 
        else:
11945 
          iprot.skip(ftype)
11946 
      else:
11947 
        iprot.skip(ftype)
11948 
      iprot.readFieldEnd()
11949 
    iprot.readStructEnd()
11950 
 
11951 
  def write(self, oprot):
11952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11954 
      return
690 chandransh 11955 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 11956 
    if self.cartId is not None:
690 chandransh 11957 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11958 
      oprot.writeI64(self.cartId)
94 ashish 11959 
      oprot.writeFieldEnd()
3431 rajveer 11960 
    if self.items is not None:
690 chandransh 11961 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11962 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11592 amit.gupta 11963 
      for kiter181,viter182 in self.items.items():
11964 
        oprot.writeI64(kiter181)
11965 
        oprot.writeDouble(viter182)
690 chandransh 11966 
      oprot.writeMapEnd()
559 chandransh 11967 
      oprot.writeFieldEnd()
94 ashish 11968 
    oprot.writeFieldStop()
11969 
    oprot.writeStructEnd()
11970 
 
3431 rajveer 11971 
  def validate(self):
11972 
    return
11973 
 
11974 
 
94 ashish 11975 
  def __repr__(self):
11976 
    L = ['%s=%r' % (key, value)
11977 
      for key, value in self.__dict__.iteritems()]
11978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11979 
 
11980 
  def __eq__(self, other):
11981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11982 
 
11983 
  def __ne__(self, other):
11984 
    return not (self == other)
11985 
 
690 chandransh 11986 
class resetCart_result:
11987 
  """
11988 
  Attributes:
11989 
   - success
11990 
   - scex
11991 
  """
559 chandransh 11992 
 
11993 
  thrift_spec = (
690 chandransh 11994 
    (0, TType.BOOL, 'success', None, None, ), # 0
11995 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11996 
  )
11997 
 
690 chandransh 11998 
  def __init__(self, success=None, scex=None,):
11999 
    self.success = success
12000 
    self.scex = scex
12001 
 
559 chandransh 12002 
  def read(self, iprot):
12003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12005 
      return
12006 
    iprot.readStructBegin()
12007 
    while True:
12008 
      (fname, ftype, fid) = iprot.readFieldBegin()
12009 
      if ftype == TType.STOP:
12010 
        break
690 chandransh 12011 
      if fid == 0:
12012 
        if ftype == TType.BOOL:
12013 
          self.success = iprot.readBool();
12014 
        else:
12015 
          iprot.skip(ftype)
12016 
      elif fid == 1:
12017 
        if ftype == TType.STRUCT:
12018 
          self.scex = ShoppingCartException()
12019 
          self.scex.read(iprot)
12020 
        else:
12021 
          iprot.skip(ftype)
559 chandransh 12022 
      else:
12023 
        iprot.skip(ftype)
12024 
      iprot.readFieldEnd()
12025 
    iprot.readStructEnd()
12026 
 
12027 
  def write(self, oprot):
12028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12030 
      return
690 chandransh 12031 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12032 
    if self.success is not None:
690 chandransh 12033 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12034 
      oprot.writeBool(self.success)
12035 
      oprot.writeFieldEnd()
3431 rajveer 12036 
    if self.scex is not None:
690 chandransh 12037 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12038 
      self.scex.write(oprot)
12039 
      oprot.writeFieldEnd()
559 chandransh 12040 
    oprot.writeFieldStop()
12041 
    oprot.writeStructEnd()
12042 
 
3431 rajveer 12043 
  def validate(self):
12044 
    return
12045 
 
12046 
 
559 chandransh 12047 
  def __repr__(self):
12048 
    L = ['%s=%r' % (key, value)
12049 
      for key, value in self.__dict__.iteritems()]
12050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12051 
 
12052 
  def __eq__(self, other):
12053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12054 
 
12055 
  def __ne__(self, other):
12056 
    return not (self == other)
12057 
 
2981 rajveer 12058 
class getUserCount_args:
94 ashish 12059 
  """
12060 
  Attributes:
2981 rajveer 12061 
   - userType
559 chandransh 12062 
  """
12063 
 
12064 
  thrift_spec = (
12065 
    None, # 0
2981 rajveer 12066 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12067 
  )
12068 
 
2981 rajveer 12069 
  def __init__(self, userType=None,):
12070 
    self.userType = userType
559 chandransh 12071 
 
12072 
  def read(self, iprot):
12073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12075 
      return
12076 
    iprot.readStructBegin()
12077 
    while True:
12078 
      (fname, ftype, fid) = iprot.readFieldBegin()
12079 
      if ftype == TType.STOP:
12080 
        break
12081 
      if fid == 1:
2981 rajveer 12082 
        if ftype == TType.I32:
12083 
          self.userType = iprot.readI32();
559 chandransh 12084 
        else:
12085 
          iprot.skip(ftype)
12086 
      else:
12087 
        iprot.skip(ftype)
12088 
      iprot.readFieldEnd()
12089 
    iprot.readStructEnd()
12090 
 
12091 
  def write(self, oprot):
12092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12094 
      return
2981 rajveer 12095 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12096 
    if self.userType is not None:
2981 rajveer 12097 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12098 
      oprot.writeI32(self.userType)
559 chandransh 12099 
      oprot.writeFieldEnd()
12100 
    oprot.writeFieldStop()
12101 
    oprot.writeStructEnd()
12102 
 
3431 rajveer 12103 
  def validate(self):
12104 
    return
12105 
 
12106 
 
559 chandransh 12107 
  def __repr__(self):
12108 
    L = ['%s=%r' % (key, value)
12109 
      for key, value in self.__dict__.iteritems()]
12110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12111 
 
12112 
  def __eq__(self, other):
12113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12114 
 
12115 
  def __ne__(self, other):
12116 
    return not (self == other)
12117 
 
2981 rajveer 12118 
class getUserCount_result:
94 ashish 12119 
  """
12120 
  Attributes:
12121 
   - success
12122 
  """
12123 
 
12124 
  thrift_spec = (
2981 rajveer 12125 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12126 
  )
12127 
 
2981 rajveer 12128 
  def __init__(self, success=None,):
94 ashish 12129 
    self.success = success
12130 
 
12131 
  def read(self, iprot):
12132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12134 
      return
12135 
    iprot.readStructBegin()
12136 
    while True:
12137 
      (fname, ftype, fid) = iprot.readFieldBegin()
12138 
      if ftype == TType.STOP:
12139 
        break
12140 
      if fid == 0:
2981 rajveer 12141 
        if ftype == TType.I64:
12142 
          self.success = iprot.readI64();
94 ashish 12143 
        else:
12144 
          iprot.skip(ftype)
12145 
      else:
12146 
        iprot.skip(ftype)
12147 
      iprot.readFieldEnd()
12148 
    iprot.readStructEnd()
12149 
 
12150 
  def write(self, oprot):
12151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12153 
      return
2981 rajveer 12154 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12155 
    if self.success is not None:
2981 rajveer 12156 
      oprot.writeFieldBegin('success', TType.I64, 0)
12157 
      oprot.writeI64(self.success)
94 ashish 12158 
      oprot.writeFieldEnd()
12159 
    oprot.writeFieldStop()
12160 
    oprot.writeStructEnd()
12161 
 
3431 rajveer 12162 
  def validate(self):
12163 
    return
12164 
 
12165 
 
94 ashish 12166 
  def __repr__(self):
12167 
    L = ['%s=%r' % (key, value)
12168 
      for key, value in self.__dict__.iteritems()]
12169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12170 
 
12171 
  def __eq__(self, other):
12172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12173 
 
12174 
  def __ne__(self, other):
12175 
    return not (self == other)
12176 
 
2981 rajveer 12177 
class getAllUsers_args:
94 ashish 12178 
  """
12179 
  Attributes:
2981 rajveer 12180 
   - userType
12181 
   - startDate
12182 
   - endDate
94 ashish 12183 
  """
12184 
 
12185 
  thrift_spec = (
12186 
    None, # 0
2981 rajveer 12187 
    (1, TType.I32, 'userType', None, None, ), # 1
12188 
    (2, TType.I64, 'startDate', None, None, ), # 2
12189 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12190 
  )
12191 
 
2981 rajveer 12192 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12193 
    self.userType = userType
12194 
    self.startDate = startDate
12195 
    self.endDate = endDate
94 ashish 12196 
 
12197 
  def read(self, iprot):
12198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12200 
      return
12201 
    iprot.readStructBegin()
12202 
    while True:
12203 
      (fname, ftype, fid) = iprot.readFieldBegin()
12204 
      if ftype == TType.STOP:
12205 
        break
12206 
      if fid == 1:
2981 rajveer 12207 
        if ftype == TType.I32:
12208 
          self.userType = iprot.readI32();
94 ashish 12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      elif fid == 2:
559 chandransh 12212 
        if ftype == TType.I64:
2981 rajveer 12213 
          self.startDate = iprot.readI64();
94 ashish 12214 
        else:
12215 
          iprot.skip(ftype)
2981 rajveer 12216 
      elif fid == 3:
12217 
        if ftype == TType.I64:
12218 
          self.endDate = iprot.readI64();
12219 
        else:
12220 
          iprot.skip(ftype)
94 ashish 12221 
      else:
12222 
        iprot.skip(ftype)
12223 
      iprot.readFieldEnd()
12224 
    iprot.readStructEnd()
12225 
 
12226 
  def write(self, oprot):
12227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12229 
      return
2981 rajveer 12230 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12231 
    if self.userType is not None:
2981 rajveer 12232 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12233 
      oprot.writeI32(self.userType)
94 ashish 12234 
      oprot.writeFieldEnd()
3431 rajveer 12235 
    if self.startDate is not None:
2981 rajveer 12236 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12237 
      oprot.writeI64(self.startDate)
94 ashish 12238 
      oprot.writeFieldEnd()
3431 rajveer 12239 
    if self.endDate is not None:
2981 rajveer 12240 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12241 
      oprot.writeI64(self.endDate)
12242 
      oprot.writeFieldEnd()
94 ashish 12243 
    oprot.writeFieldStop()
12244 
    oprot.writeStructEnd()
12245 
 
3431 rajveer 12246 
  def validate(self):
12247 
    return
12248 
 
12249 
 
94 ashish 12250 
  def __repr__(self):
12251 
    L = ['%s=%r' % (key, value)
12252 
      for key, value in self.__dict__.iteritems()]
12253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12254 
 
12255 
  def __eq__(self, other):
12256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12257 
 
12258 
  def __ne__(self, other):
12259 
    return not (self == other)
12260 
 
2981 rajveer 12261 
class getAllUsers_result:
94 ashish 12262 
  """
12263 
  Attributes:
12264 
   - success
12265 
  """
12266 
 
12267 
  thrift_spec = (
2981 rajveer 12268 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12269 
  )
12270 
 
2981 rajveer 12271 
  def __init__(self, success=None,):
94 ashish 12272 
    self.success = success
12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
12283 
      if fid == 0:
2981 rajveer 12284 
        if ftype == TType.LIST:
12285 
          self.success = []
11592 amit.gupta 12286 
          (_etype186, _size183) = iprot.readListBegin()
12287 
          for _i187 in xrange(_size183):
12288 
            _elem188 = User()
12289 
            _elem188.read(iprot)
12290 
            self.success.append(_elem188)
2981 rajveer 12291 
          iprot.readListEnd()
94 ashish 12292 
        else:
12293 
          iprot.skip(ftype)
12294 
      else:
12295 
        iprot.skip(ftype)
12296 
      iprot.readFieldEnd()
12297 
    iprot.readStructEnd()
12298 
 
12299 
  def write(self, oprot):
12300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12302 
      return
2981 rajveer 12303 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12304 
    if self.success is not None:
2981 rajveer 12305 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12306 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 12307 
      for iter189 in self.success:
12308 
        iter189.write(oprot)
2981 rajveer 12309 
      oprot.writeListEnd()
94 ashish 12310 
      oprot.writeFieldEnd()
12311 
    oprot.writeFieldStop()
12312 
    oprot.writeStructEnd()
12313 
 
3431 rajveer 12314 
  def validate(self):
12315 
    return
12316 
 
12317 
 
94 ashish 12318 
  def __repr__(self):
12319 
    L = ['%s=%r' % (key, value)
12320 
      for key, value in self.__dict__.iteritems()]
12321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12322 
 
12323 
  def __eq__(self, other):
12324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12325 
 
12326 
  def __ne__(self, other):
12327 
    return not (self == other)
12328 
 
2981 rajveer 12329 
class getMyResearchItems_args:
559 chandransh 12330 
  """
12331 
  Attributes:
772 rajveer 12332 
   - userId
559 chandransh 12333 
  """
12334 
 
12335 
  thrift_spec = (
12336 
    None, # 0
772 rajveer 12337 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12338 
  )
12339 
 
772 rajveer 12340 
  def __init__(self, userId=None,):
12341 
    self.userId = userId
559 chandransh 12342 
 
12343 
  def read(self, iprot):
12344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12346 
      return
12347 
    iprot.readStructBegin()
12348 
    while True:
12349 
      (fname, ftype, fid) = iprot.readFieldBegin()
12350 
      if ftype == TType.STOP:
12351 
        break
12352 
      if fid == 1:
12353 
        if ftype == TType.I64:
772 rajveer 12354 
          self.userId = iprot.readI64();
559 chandransh 12355 
        else:
12356 
          iprot.skip(ftype)
12357 
      else:
12358 
        iprot.skip(ftype)
12359 
      iprot.readFieldEnd()
12360 
    iprot.readStructEnd()
12361 
 
12362 
  def write(self, oprot):
12363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12365 
      return
2981 rajveer 12366 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 12367 
    if self.userId is not None:
772 rajveer 12368 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12369 
      oprot.writeI64(self.userId)
559 chandransh 12370 
      oprot.writeFieldEnd()
12371 
    oprot.writeFieldStop()
12372 
    oprot.writeStructEnd()
12373 
 
3431 rajveer 12374 
  def validate(self):
12375 
    return
12376 
 
12377 
 
559 chandransh 12378 
  def __repr__(self):
12379 
    L = ['%s=%r' % (key, value)
12380 
      for key, value in self.__dict__.iteritems()]
12381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12382 
 
12383 
  def __eq__(self, other):
12384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12385 
 
12386 
  def __ne__(self, other):
12387 
    return not (self == other)
12388 
 
2981 rajveer 12389 
class getMyResearchItems_result:
559 chandransh 12390 
  """
12391 
  Attributes:
130 ashish 12392 
   - success
559 chandransh 12393 
   - scx
130 ashish 12394 
  """
12395 
 
12396 
  thrift_spec = (
2981 rajveer 12397 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12398 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12399 
  )
12400 
 
559 chandransh 12401 
  def __init__(self, success=None, scx=None,):
130 ashish 12402 
    self.success = success
559 chandransh 12403 
    self.scx = scx
130 ashish 12404 
 
12405 
  def read(self, iprot):
12406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12408 
      return
12409 
    iprot.readStructBegin()
12410 
    while True:
12411 
      (fname, ftype, fid) = iprot.readFieldBegin()
12412 
      if ftype == TType.STOP:
12413 
        break
12414 
      if fid == 0:
2981 rajveer 12415 
        if ftype == TType.LIST:
12416 
          self.success = []
11592 amit.gupta 12417 
          (_etype193, _size190) = iprot.readListBegin()
12418 
          for _i194 in xrange(_size190):
12419 
            _elem195 = iprot.readI64();
12420 
            self.success.append(_elem195)
2981 rajveer 12421 
          iprot.readListEnd()
130 ashish 12422 
        else:
12423 
          iprot.skip(ftype)
12424 
      elif fid == 1:
12425 
        if ftype == TType.STRUCT:
559 chandransh 12426 
          self.scx = WidgetException()
12427 
          self.scx.read(iprot)
130 ashish 12428 
        else:
12429 
          iprot.skip(ftype)
12430 
      else:
12431 
        iprot.skip(ftype)
12432 
      iprot.readFieldEnd()
12433 
    iprot.readStructEnd()
12434 
 
12435 
  def write(self, oprot):
12436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12438 
      return
2981 rajveer 12439 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 12440 
    if self.success is not None:
2981 rajveer 12441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12442 
      oprot.writeListBegin(TType.I64, len(self.success))
11592 amit.gupta 12443 
      for iter196 in self.success:
12444 
        oprot.writeI64(iter196)
2981 rajveer 12445 
      oprot.writeListEnd()
130 ashish 12446 
      oprot.writeFieldEnd()
3431 rajveer 12447 
    if self.scx is not None:
559 chandransh 12448 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12449 
      self.scx.write(oprot)
130 ashish 12450 
      oprot.writeFieldEnd()
12451 
    oprot.writeFieldStop()
12452 
    oprot.writeStructEnd()
12453 
 
3431 rajveer 12454 
  def validate(self):
12455 
    return
12456 
 
12457 
 
130 ashish 12458 
  def __repr__(self):
12459 
    L = ['%s=%r' % (key, value)
12460 
      for key, value in self.__dict__.iteritems()]
12461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12462 
 
12463 
  def __eq__(self, other):
12464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12465 
 
12466 
  def __ne__(self, other):
12467 
    return not (self == other)
12468 
 
2981 rajveer 12469 
class updateMyResearch_args:
130 ashish 12470 
  """
12471 
  Attributes:
2981 rajveer 12472 
   - userId
12473 
   - itemId
130 ashish 12474 
  """
12475 
 
12476 
  thrift_spec = (
12477 
    None, # 0
2981 rajveer 12478 
    (1, TType.I64, 'userId', None, None, ), # 1
12479 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12480 
  )
12481 
 
2981 rajveer 12482 
  def __init__(self, userId=None, itemId=None,):
12483 
    self.userId = userId
12484 
    self.itemId = itemId
130 ashish 12485 
 
12486 
  def read(self, iprot):
12487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12489 
      return
12490 
    iprot.readStructBegin()
12491 
    while True:
12492 
      (fname, ftype, fid) = iprot.readFieldBegin()
12493 
      if ftype == TType.STOP:
12494 
        break
12495 
      if fid == 1:
559 chandransh 12496 
        if ftype == TType.I64:
2981 rajveer 12497 
          self.userId = iprot.readI64();
130 ashish 12498 
        else:
12499 
          iprot.skip(ftype)
12500 
      elif fid == 2:
559 chandransh 12501 
        if ftype == TType.I64:
2981 rajveer 12502 
          self.itemId = iprot.readI64();
559 chandransh 12503 
        else:
12504 
          iprot.skip(ftype)
130 ashish 12505 
      else:
12506 
        iprot.skip(ftype)
12507 
      iprot.readFieldEnd()
12508 
    iprot.readStructEnd()
12509 
 
12510 
  def write(self, oprot):
12511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12513 
      return
2981 rajveer 12514 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 12515 
    if self.userId is not None:
2981 rajveer 12516 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12517 
      oprot.writeI64(self.userId)
130 ashish 12518 
      oprot.writeFieldEnd()
3431 rajveer 12519 
    if self.itemId is not None:
2981 rajveer 12520 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12521 
      oprot.writeI64(self.itemId)
130 ashish 12522 
      oprot.writeFieldEnd()
12523 
    oprot.writeFieldStop()
12524 
    oprot.writeStructEnd()
12525 
 
3431 rajveer 12526 
  def validate(self):
12527 
    return
12528 
 
12529 
 
130 ashish 12530 
  def __repr__(self):
12531 
    L = ['%s=%r' % (key, value)
12532 
      for key, value in self.__dict__.iteritems()]
12533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12534 
 
12535 
  def __eq__(self, other):
12536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12537 
 
12538 
  def __ne__(self, other):
12539 
    return not (self == other)
12540 
 
2981 rajveer 12541 
class updateMyResearch_result:
12542 
  """
12543 
  Attributes:
12544 
   - success
12545 
   - scx
12546 
  """
559 chandransh 12547 
 
12548 
  thrift_spec = (
2981 rajveer 12549 
    (0, TType.BOOL, 'success', None, None, ), # 0
12550 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12551 
  )
12552 
 
2981 rajveer 12553 
  def __init__(self, success=None, scx=None,):
12554 
    self.success = success
12555 
    self.scx = scx
12556 
 
559 chandransh 12557 
  def read(self, iprot):
12558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12560 
      return
12561 
    iprot.readStructBegin()
12562 
    while True:
12563 
      (fname, ftype, fid) = iprot.readFieldBegin()
12564 
      if ftype == TType.STOP:
12565 
        break
2981 rajveer 12566 
      if fid == 0:
12567 
        if ftype == TType.BOOL:
12568 
          self.success = iprot.readBool();
12569 
        else:
12570 
          iprot.skip(ftype)
12571 
      elif fid == 1:
12572 
        if ftype == TType.STRUCT:
12573 
          self.scx = WidgetException()
12574 
          self.scx.read(iprot)
12575 
        else:
12576 
          iprot.skip(ftype)
559 chandransh 12577 
      else:
12578 
        iprot.skip(ftype)
12579 
      iprot.readFieldEnd()
12580 
    iprot.readStructEnd()
12581 
 
12582 
  def write(self, oprot):
12583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12585 
      return
2981 rajveer 12586 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 12587 
    if self.success is not None:
2981 rajveer 12588 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12589 
      oprot.writeBool(self.success)
12590 
      oprot.writeFieldEnd()
3431 rajveer 12591 
    if self.scx is not None:
2981 rajveer 12592 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12593 
      self.scx.write(oprot)
12594 
      oprot.writeFieldEnd()
559 chandransh 12595 
    oprot.writeFieldStop()
12596 
    oprot.writeStructEnd()
12597 
 
3431 rajveer 12598 
  def validate(self):
12599 
    return
12600 
 
12601 
 
559 chandransh 12602 
  def __repr__(self):
12603 
    L = ['%s=%r' % (key, value)
12604 
      for key, value in self.__dict__.iteritems()]
12605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12606 
 
12607 
  def __eq__(self, other):
12608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12609 
 
12610 
  def __ne__(self, other):
12611 
    return not (self == other)
12612 
 
2981 rajveer 12613 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12614 
  """
12615 
  Attributes:
2981 rajveer 12616 
   - userId
12617 
   - itemId
1596 ankur.sing 12618 
  """
559 chandransh 12619 
 
1596 ankur.sing 12620 
  thrift_spec = (
12621 
    None, # 0
2981 rajveer 12622 
    (1, TType.I64, 'userId', None, None, ), # 1
12623 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12624 
  )
12625 
 
2981 rajveer 12626 
  def __init__(self, userId=None, itemId=None,):
12627 
    self.userId = userId
12628 
    self.itemId = itemId
1596 ankur.sing 12629 
 
12630 
  def read(self, iprot):
12631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12633 
      return
12634 
    iprot.readStructBegin()
12635 
    while True:
12636 
      (fname, ftype, fid) = iprot.readFieldBegin()
12637 
      if ftype == TType.STOP:
12638 
        break
12639 
      if fid == 1:
2981 rajveer 12640 
        if ftype == TType.I64:
12641 
          self.userId = iprot.readI64();
1596 ankur.sing 12642 
        else:
12643 
          iprot.skip(ftype)
2981 rajveer 12644 
      elif fid == 2:
12645 
        if ftype == TType.I64:
12646 
          self.itemId = iprot.readI64();
12647 
        else:
12648 
          iprot.skip(ftype)
1596 ankur.sing 12649 
      else:
12650 
        iprot.skip(ftype)
12651 
      iprot.readFieldEnd()
12652 
    iprot.readStructEnd()
12653 
 
12654 
  def write(self, oprot):
12655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12657 
      return
2981 rajveer 12658 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 12659 
    if self.userId is not None:
2981 rajveer 12660 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12661 
      oprot.writeI64(self.userId)
1596 ankur.sing 12662 
      oprot.writeFieldEnd()
3431 rajveer 12663 
    if self.itemId is not None:
2981 rajveer 12664 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12665 
      oprot.writeI64(self.itemId)
12666 
      oprot.writeFieldEnd()
1596 ankur.sing 12667 
    oprot.writeFieldStop()
12668 
    oprot.writeStructEnd()
12669 
 
3431 rajveer 12670 
  def validate(self):
12671 
    return
12672 
 
12673 
 
1596 ankur.sing 12674 
  def __repr__(self):
12675 
    L = ['%s=%r' % (key, value)
12676 
      for key, value in self.__dict__.iteritems()]
12677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12678 
 
12679 
  def __eq__(self, other):
12680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12681 
 
12682 
  def __ne__(self, other):
12683 
    return not (self == other)
12684 
 
2981 rajveer 12685 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12686 
  """
12687 
  Attributes:
2981 rajveer 12688 
   - scx
1596 ankur.sing 12689 
  """
12690 
 
12691 
  thrift_spec = (
2981 rajveer 12692 
    None, # 0
12693 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12694 
  )
12695 
 
2981 rajveer 12696 
  def __init__(self, scx=None,):
12697 
    self.scx = scx
1596 ankur.sing 12698 
 
12699 
  def read(self, iprot):
12700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12702 
      return
12703 
    iprot.readStructBegin()
12704 
    while True:
12705 
      (fname, ftype, fid) = iprot.readFieldBegin()
12706 
      if ftype == TType.STOP:
12707 
        break
2981 rajveer 12708 
      if fid == 1:
12709 
        if ftype == TType.STRUCT:
12710 
          self.scx = WidgetException()
12711 
          self.scx.read(iprot)
1596 ankur.sing 12712 
        else:
12713 
          iprot.skip(ftype)
12714 
      else:
12715 
        iprot.skip(ftype)
12716 
      iprot.readFieldEnd()
12717 
    iprot.readStructEnd()
12718 
 
12719 
  def write(self, oprot):
12720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12722 
      return
2981 rajveer 12723 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 12724 
    if self.scx is not None:
2981 rajveer 12725 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12726 
      self.scx.write(oprot)
1596 ankur.sing 12727 
      oprot.writeFieldEnd()
12728 
    oprot.writeFieldStop()
12729 
    oprot.writeStructEnd()
12730 
 
3431 rajveer 12731 
  def validate(self):
12732 
    return
12733 
 
12734 
 
1596 ankur.sing 12735 
  def __repr__(self):
12736 
    L = ['%s=%r' % (key, value)
12737 
      for key, value in self.__dict__.iteritems()]
12738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12739 
 
12740 
  def __eq__(self, other):
12741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12742 
 
12743 
  def __ne__(self, other):
12744 
    return not (self == other)
12745 
 
2981 rajveer 12746 
class getBrowseHistoryItems_args:
1673 ankur.sing 12747 
  """
12748 
  Attributes:
2981 rajveer 12749 
   - userId
1673 ankur.sing 12750 
  """
1596 ankur.sing 12751 
 
1673 ankur.sing 12752 
  thrift_spec = (
12753 
    None, # 0
2981 rajveer 12754 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12755 
  )
12756 
 
2981 rajveer 12757 
  def __init__(self, userId=None,):
12758 
    self.userId = userId
1673 ankur.sing 12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      if fid == 1:
1891 ankur.sing 12770 
        if ftype == TType.I64:
2981 rajveer 12771 
          self.userId = iprot.readI64();
1891 ankur.sing 12772 
        else:
12773 
          iprot.skip(ftype)
1673 ankur.sing 12774 
      else:
12775 
        iprot.skip(ftype)
12776 
      iprot.readFieldEnd()
12777 
    iprot.readStructEnd()
12778 
 
12779 
  def write(self, oprot):
12780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12782 
      return
2981 rajveer 12783 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 12784 
    if self.userId is not None:
2981 rajveer 12785 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12786 
      oprot.writeI64(self.userId)
1673 ankur.sing 12787 
      oprot.writeFieldEnd()
12788 
    oprot.writeFieldStop()
12789 
    oprot.writeStructEnd()
12790 
 
3431 rajveer 12791 
  def validate(self):
12792 
    return
12793 
 
12794 
 
1673 ankur.sing 12795 
  def __repr__(self):
12796 
    L = ['%s=%r' % (key, value)
12797 
      for key, value in self.__dict__.iteritems()]
12798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12799 
 
12800 
  def __eq__(self, other):
12801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12802 
 
12803 
  def __ne__(self, other):
12804 
    return not (self == other)
12805 
 
2981 rajveer 12806 
class getBrowseHistoryItems_result:
1673 ankur.sing 12807 
  """
12808 
  Attributes:
12809 
   - success
2981 rajveer 12810 
   - scx
1673 ankur.sing 12811 
  """
12812 
 
12813 
  thrift_spec = (
2981 rajveer 12814 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12815 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12816 
  )
12817 
 
2981 rajveer 12818 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12819 
    self.success = success
2981 rajveer 12820 
    self.scx = scx
1673 ankur.sing 12821 
 
12822 
  def read(self, iprot):
12823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12825 
      return
12826 
    iprot.readStructBegin()
12827 
    while True:
12828 
      (fname, ftype, fid) = iprot.readFieldBegin()
12829 
      if ftype == TType.STOP:
12830 
        break
12831 
      if fid == 0:
12832 
        if ftype == TType.LIST:
12833 
          self.success = []
11592 amit.gupta 12834 
          (_etype200, _size197) = iprot.readListBegin()
12835 
          for _i201 in xrange(_size197):
12836 
            _elem202 = iprot.readI64();
12837 
            self.success.append(_elem202)
1673 ankur.sing 12838 
          iprot.readListEnd()
12839 
        else:
12840 
          iprot.skip(ftype)
2981 rajveer 12841 
      elif fid == 1:
12842 
        if ftype == TType.STRUCT:
12843 
          self.scx = WidgetException()
12844 
          self.scx.read(iprot)
12845 
        else:
12846 
          iprot.skip(ftype)
1673 ankur.sing 12847 
      else:
12848 
        iprot.skip(ftype)
12849 
      iprot.readFieldEnd()
12850 
    iprot.readStructEnd()
12851 
 
12852 
  def write(self, oprot):
12853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12855 
      return
2981 rajveer 12856 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 12857 
    if self.success is not None:
1673 ankur.sing 12858 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12859 
      oprot.writeListBegin(TType.I64, len(self.success))
11592 amit.gupta 12860 
      for iter203 in self.success:
12861 
        oprot.writeI64(iter203)
1673 ankur.sing 12862 
      oprot.writeListEnd()
12863 
      oprot.writeFieldEnd()
3431 rajveer 12864 
    if self.scx is not None:
2981 rajveer 12865 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12866 
      self.scx.write(oprot)
2642 varun.gupt 12867 
      oprot.writeFieldEnd()
12868 
    oprot.writeFieldStop()
12869 
    oprot.writeStructEnd()
12870 
 
3431 rajveer 12871 
  def validate(self):
12872 
    return
12873 
 
12874 
 
2642 varun.gupt 12875 
  def __repr__(self):
12876 
    L = ['%s=%r' % (key, value)
12877 
      for key, value in self.__dict__.iteritems()]
12878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12879 
 
12880 
  def __eq__(self, other):
12881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12882 
 
12883 
  def __ne__(self, other):
12884 
    return not (self == other)
12885 
 
2981 rajveer 12886 
class updateBrowseHistory_args:
2642 varun.gupt 12887 
  """
12888 
  Attributes:
2981 rajveer 12889 
   - userId
12890 
   - itemId
2642 varun.gupt 12891 
  """
12892 
 
12893 
  thrift_spec = (
12894 
    None, # 0
2981 rajveer 12895 
    (1, TType.I64, 'userId', None, None, ), # 1
12896 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12897 
  )
12898 
 
2981 rajveer 12899 
  def __init__(self, userId=None, itemId=None,):
12900 
    self.userId = userId
12901 
    self.itemId = itemId
2642 varun.gupt 12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      if fid == 1:
12913 
        if ftype == TType.I64:
2981 rajveer 12914 
          self.userId = iprot.readI64();
2642 varun.gupt 12915 
        else:
12916 
          iprot.skip(ftype)
12917 
      elif fid == 2:
12918 
        if ftype == TType.I64:
2981 rajveer 12919 
          self.itemId = iprot.readI64();
2642 varun.gupt 12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
2981 rajveer 12931 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 12932 
    if self.userId is not None:
2981 rajveer 12933 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12934 
      oprot.writeI64(self.userId)
2642 varun.gupt 12935 
      oprot.writeFieldEnd()
3431 rajveer 12936 
    if self.itemId is not None:
2981 rajveer 12937 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12938 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12939 
      oprot.writeFieldEnd()
12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
3431 rajveer 12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
2642 varun.gupt 12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
2981 rajveer 12958 
class updateBrowseHistory_result:
2642 varun.gupt 12959 
 
12960 
  thrift_spec = (
12961 
  )
12962 
 
12963 
  def read(self, iprot):
12964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12966 
      return
12967 
    iprot.readStructBegin()
12968 
    while True:
12969 
      (fname, ftype, fid) = iprot.readFieldBegin()
12970 
      if ftype == TType.STOP:
12971 
        break
12972 
      else:
12973 
        iprot.skip(ftype)
12974 
      iprot.readFieldEnd()
12975 
    iprot.readStructEnd()
12976 
 
12977 
  def write(self, oprot):
12978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12980 
      return
2981 rajveer 12981 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 12982 
    oprot.writeFieldStop()
12983 
    oprot.writeStructEnd()
12984 
 
3431 rajveer 12985 
  def validate(self):
12986 
    return
12987 
 
12988 
 
2642 varun.gupt 12989 
  def __repr__(self):
12990 
    L = ['%s=%r' % (key, value)
12991 
      for key, value in self.__dict__.iteritems()]
12992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12993 
 
12994 
  def __eq__(self, other):
12995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12996 
 
12997 
  def __ne__(self, other):
12998 
    return not (self == other)
12999 
 
3385 varun.gupt 13000 
class getCartsWithCouponCount_args:
13001 
  """
13002 
  Attributes:
13003 
   - couponCode
13004 
  """
2642 varun.gupt 13005 
 
3385 varun.gupt 13006 
  thrift_spec = (
13007 
    None, # 0
13008 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13009 
  )
13010 
 
13011 
  def __init__(self, couponCode=None,):
13012 
    self.couponCode = couponCode
13013 
 
13014 
  def read(self, iprot):
13015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13017 
      return
13018 
    iprot.readStructBegin()
13019 
    while True:
13020 
      (fname, ftype, fid) = iprot.readFieldBegin()
13021 
      if ftype == TType.STOP:
13022 
        break
13023 
      if fid == 1:
13024 
        if ftype == TType.STRING:
13025 
          self.couponCode = iprot.readString();
13026 
        else:
13027 
          iprot.skip(ftype)
13028 
      else:
13029 
        iprot.skip(ftype)
13030 
      iprot.readFieldEnd()
13031 
    iprot.readStructEnd()
13032 
 
13033 
  def write(self, oprot):
13034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13036 
      return
13037 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13038 
    if self.couponCode is not None:
3385 varun.gupt 13039 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13040 
      oprot.writeString(self.couponCode)
13041 
      oprot.writeFieldEnd()
13042 
    oprot.writeFieldStop()
13043 
    oprot.writeStructEnd()
13044 
 
3431 rajveer 13045 
  def validate(self):
13046 
    return
13047 
 
13048 
 
3385 varun.gupt 13049 
  def __repr__(self):
13050 
    L = ['%s=%r' % (key, value)
13051 
      for key, value in self.__dict__.iteritems()]
13052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13053 
 
13054 
  def __eq__(self, other):
13055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13056 
 
13057 
  def __ne__(self, other):
13058 
    return not (self == other)
13059 
 
13060 
class getCartsWithCouponCount_result:
13061 
  """
13062 
  Attributes:
13063 
   - success
13064 
  """
13065 
 
13066 
  thrift_spec = (
13067 
    (0, TType.I64, 'success', None, None, ), # 0
13068 
  )
13069 
 
13070 
  def __init__(self, success=None,):
13071 
    self.success = success
13072 
 
13073 
  def read(self, iprot):
13074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13076 
      return
13077 
    iprot.readStructBegin()
13078 
    while True:
13079 
      (fname, ftype, fid) = iprot.readFieldBegin()
13080 
      if ftype == TType.STOP:
13081 
        break
13082 
      if fid == 0:
13083 
        if ftype == TType.I64:
13084 
          self.success = iprot.readI64();
13085 
        else:
13086 
          iprot.skip(ftype)
13087 
      else:
13088 
        iprot.skip(ftype)
13089 
      iprot.readFieldEnd()
13090 
    iprot.readStructEnd()
13091 
 
13092 
  def write(self, oprot):
13093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13095 
      return
13096 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13097 
    if self.success is not None:
3385 varun.gupt 13098 
      oprot.writeFieldBegin('success', TType.I64, 0)
13099 
      oprot.writeI64(self.success)
13100 
      oprot.writeFieldEnd()
13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
3431 rajveer 13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
3385 varun.gupt 13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
3499 mandeep.dh 13118 
 
13119 
class increaseTrustLevel_args:
13120 
  """
13121 
  Attributes:
13122 
   - userId
13123 
   - trustLevelDelta
13124 
  """
13125 
 
13126 
  thrift_spec = (
13127 
    None, # 0
13128 
    (1, TType.I64, 'userId', None, None, ), # 1
13129 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13130 
  )
13131 
 
13132 
  def __init__(self, userId=None, trustLevelDelta=None,):
13133 
    self.userId = userId
13134 
    self.trustLevelDelta = trustLevelDelta
13135 
 
13136 
  def read(self, iprot):
13137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13139 
      return
13140 
    iprot.readStructBegin()
13141 
    while True:
13142 
      (fname, ftype, fid) = iprot.readFieldBegin()
13143 
      if ftype == TType.STOP:
13144 
        break
13145 
      if fid == 1:
13146 
        if ftype == TType.I64:
13147 
          self.userId = iprot.readI64();
13148 
        else:
13149 
          iprot.skip(ftype)
13150 
      elif fid == 2:
13151 
        if ftype == TType.DOUBLE:
13152 
          self.trustLevelDelta = iprot.readDouble();
13153 
        else:
13154 
          iprot.skip(ftype)
13155 
      else:
13156 
        iprot.skip(ftype)
13157 
      iprot.readFieldEnd()
13158 
    iprot.readStructEnd()
13159 
 
13160 
  def write(self, oprot):
13161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13163 
      return
13164 
    oprot.writeStructBegin('increaseTrustLevel_args')
13165 
    if self.userId is not None:
13166 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13167 
      oprot.writeI64(self.userId)
13168 
      oprot.writeFieldEnd()
13169 
    if self.trustLevelDelta is not None:
13170 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13171 
      oprot.writeDouble(self.trustLevelDelta)
13172 
      oprot.writeFieldEnd()
13173 
    oprot.writeFieldStop()
13174 
    oprot.writeStructEnd()
13175 
 
13176 
  def validate(self):
13177 
    return
13178 
 
13179 
 
13180 
  def __repr__(self):
13181 
    L = ['%s=%r' % (key, value)
13182 
      for key, value in self.__dict__.iteritems()]
13183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13184 
 
13185 
  def __eq__(self, other):
13186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13187 
 
13188 
  def __ne__(self, other):
13189 
    return not (self == other)
4668 varun.gupt 13190 
 
5407 amar.kumar 13191 
class getTrustLevel_args:
13192 
  """
13193 
  Attributes:
13194 
   - userId
13195 
  """
13196 
 
13197 
  thrift_spec = (
13198 
    None, # 0
13199 
    (1, TType.I64, 'userId', None, None, ), # 1
13200 
  )
13201 
 
13202 
  def __init__(self, userId=None,):
13203 
    self.userId = userId
13204 
 
13205 
  def read(self, iprot):
13206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13208 
      return
13209 
    iprot.readStructBegin()
13210 
    while True:
13211 
      (fname, ftype, fid) = iprot.readFieldBegin()
13212 
      if ftype == TType.STOP:
13213 
        break
13214 
      if fid == 1:
13215 
        if ftype == TType.I64:
13216 
          self.userId = iprot.readI64();
13217 
        else:
13218 
          iprot.skip(ftype)
13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
13228 
    oprot.writeStructBegin('getTrustLevel_args')
13229 
    if self.userId is not None:
13230 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13231 
      oprot.writeI64(self.userId)
13232 
      oprot.writeFieldEnd()
13233 
    oprot.writeFieldStop()
13234 
    oprot.writeStructEnd()
13235 
 
13236 
  def validate(self):
13237 
    return
13238 
 
13239 
 
13240 
  def __repr__(self):
13241 
    L = ['%s=%r' % (key, value)
13242 
      for key, value in self.__dict__.iteritems()]
13243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13244 
 
13245 
  def __eq__(self, other):
13246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13247 
 
13248 
  def __ne__(self, other):
13249 
    return not (self == other)
13250 
 
13251 
class getTrustLevel_result:
13252 
  """
13253 
  Attributes:
13254 
   - success
13255 
  """
13256 
 
13257 
  thrift_spec = (
13258 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13259 
  )
13260 
 
13261 
  def __init__(self, success=None,):
13262 
    self.success = success
13263 
 
13264 
  def read(self, iprot):
13265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13267 
      return
13268 
    iprot.readStructBegin()
13269 
    while True:
13270 
      (fname, ftype, fid) = iprot.readFieldBegin()
13271 
      if ftype == TType.STOP:
13272 
        break
13273 
      if fid == 0:
13274 
        if ftype == TType.DOUBLE:
13275 
          self.success = iprot.readDouble();
13276 
        else:
13277 
          iprot.skip(ftype)
13278 
      else:
13279 
        iprot.skip(ftype)
13280 
      iprot.readFieldEnd()
13281 
    iprot.readStructEnd()
13282 
 
13283 
  def write(self, oprot):
13284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13286 
      return
13287 
    oprot.writeStructBegin('getTrustLevel_result')
13288 
    if self.success is not None:
13289 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13290 
      oprot.writeDouble(self.success)
13291 
      oprot.writeFieldEnd()
13292 
    oprot.writeFieldStop()
13293 
    oprot.writeStructEnd()
13294 
 
13295 
  def validate(self):
13296 
    return
13297 
 
13298 
 
13299 
  def __repr__(self):
13300 
    L = ['%s=%r' % (key, value)
13301 
      for key, value in self.__dict__.iteritems()]
13302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13303 
 
13304 
  def __eq__(self, other):
13305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13306 
 
13307 
  def __ne__(self, other):
13308 
    return not (self == other)
13309 
 
4668 varun.gupt 13310 
class showCODOption_args:
13311 
  """
13312 
  Attributes:
13313 
   - cartId
13314 
   - sourceId
13315 
   - pincode
13316 
  """
13317 
 
13318 
  thrift_spec = (
13319 
    None, # 0
13320 
    (1, TType.I64, 'cartId', None, None, ), # 1
13321 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13322 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13323 
  )
13324 
 
13325 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13326 
    self.cartId = cartId
13327 
    self.sourceId = sourceId
13328 
    self.pincode = pincode
13329 
 
13330 
  def read(self, iprot):
13331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13333 
      return
13334 
    iprot.readStructBegin()
13335 
    while True:
13336 
      (fname, ftype, fid) = iprot.readFieldBegin()
13337 
      if ftype == TType.STOP:
13338 
        break
13339 
      if fid == 1:
13340 
        if ftype == TType.I64:
13341 
          self.cartId = iprot.readI64();
13342 
        else:
13343 
          iprot.skip(ftype)
13344 
      elif fid == 2:
13345 
        if ftype == TType.I64:
13346 
          self.sourceId = iprot.readI64();
13347 
        else:
13348 
          iprot.skip(ftype)
13349 
      elif fid == 3:
13350 
        if ftype == TType.STRING:
13351 
          self.pincode = iprot.readString();
13352 
        else:
13353 
          iprot.skip(ftype)
13354 
      else:
13355 
        iprot.skip(ftype)
13356 
      iprot.readFieldEnd()
13357 
    iprot.readStructEnd()
13358 
 
13359 
  def write(self, oprot):
13360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13362 
      return
13363 
    oprot.writeStructBegin('showCODOption_args')
13364 
    if self.cartId is not None:
13365 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13366 
      oprot.writeI64(self.cartId)
13367 
      oprot.writeFieldEnd()
13368 
    if self.sourceId is not None:
13369 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13370 
      oprot.writeI64(self.sourceId)
13371 
      oprot.writeFieldEnd()
13372 
    if self.pincode is not None:
13373 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
13374 
      oprot.writeString(self.pincode)
13375 
      oprot.writeFieldEnd()
13376 
    oprot.writeFieldStop()
13377 
    oprot.writeStructEnd()
13378 
 
13379 
  def validate(self):
13380 
    return
13381 
 
13382 
 
13383 
  def __repr__(self):
13384 
    L = ['%s=%r' % (key, value)
13385 
      for key, value in self.__dict__.iteritems()]
13386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13387 
 
13388 
  def __eq__(self, other):
13389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13390 
 
13391 
  def __ne__(self, other):
13392 
    return not (self == other)
13393 
 
13394 
class showCODOption_result:
13395 
  """
13396 
  Attributes:
13397 
   - success
13398 
  """
13399 
 
13400 
  thrift_spec = (
13401 
    (0, TType.BOOL, 'success', None, None, ), # 0
13402 
  )
13403 
 
13404 
  def __init__(self, success=None,):
13405 
    self.success = success
13406 
 
13407 
  def read(self, iprot):
13408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13410 
      return
13411 
    iprot.readStructBegin()
13412 
    while True:
13413 
      (fname, ftype, fid) = iprot.readFieldBegin()
13414 
      if ftype == TType.STOP:
13415 
        break
13416 
      if fid == 0:
13417 
        if ftype == TType.BOOL:
13418 
          self.success = iprot.readBool();
13419 
        else:
13420 
          iprot.skip(ftype)
13421 
      else:
13422 
        iprot.skip(ftype)
13423 
      iprot.readFieldEnd()
13424 
    iprot.readStructEnd()
13425 
 
13426 
  def write(self, oprot):
13427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13429 
      return
13430 
    oprot.writeStructBegin('showCODOption_result')
13431 
    if self.success is not None:
13432 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13433 
      oprot.writeBool(self.success)
13434 
      oprot.writeFieldEnd()
13435 
    oprot.writeFieldStop()
13436 
    oprot.writeStructEnd()
13437 
 
13438 
  def validate(self):
13439 
    return
13440 
 
13441 
 
13442 
  def __repr__(self):
13443 
    L = ['%s=%r' % (key, value)
13444 
      for key, value in self.__dict__.iteritems()]
13445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13446 
 
13447 
  def __eq__(self, other):
13448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13449 
 
13450 
  def __ne__(self, other):
13451 
    return not (self == other)
5623 anupam.sin 13452 
 
13453 
class getUserEmails_args:
13454 
  """
13455 
  Attributes:
13456 
   - startDate
13457 
   - endDate
13458 
  """
13459 
 
13460 
  thrift_spec = (
13461 
    None, # 0
13462 
    (1, TType.I64, 'startDate', None, None, ), # 1
13463 
    (2, TType.I64, 'endDate', None, None, ), # 2
13464 
  )
13465 
 
13466 
  def __init__(self, startDate=None, endDate=None,):
13467 
    self.startDate = startDate
13468 
    self.endDate = endDate
13469 
 
13470 
  def read(self, iprot):
13471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13473 
      return
13474 
    iprot.readStructBegin()
13475 
    while True:
13476 
      (fname, ftype, fid) = iprot.readFieldBegin()
13477 
      if ftype == TType.STOP:
13478 
        break
13479 
      if fid == 1:
13480 
        if ftype == TType.I64:
13481 
          self.startDate = iprot.readI64();
13482 
        else:
13483 
          iprot.skip(ftype)
13484 
      elif fid == 2:
13485 
        if ftype == TType.I64:
13486 
          self.endDate = iprot.readI64();
13487 
        else:
13488 
          iprot.skip(ftype)
13489 
      else:
13490 
        iprot.skip(ftype)
13491 
      iprot.readFieldEnd()
13492 
    iprot.readStructEnd()
13493 
 
13494 
  def write(self, oprot):
13495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13497 
      return
13498 
    oprot.writeStructBegin('getUserEmails_args')
13499 
    if self.startDate is not None:
13500 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
13501 
      oprot.writeI64(self.startDate)
13502 
      oprot.writeFieldEnd()
13503 
    if self.endDate is not None:
13504 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
13505 
      oprot.writeI64(self.endDate)
13506 
      oprot.writeFieldEnd()
13507 
    oprot.writeFieldStop()
13508 
    oprot.writeStructEnd()
13509 
 
13510 
  def validate(self):
13511 
    return
13512 
 
13513 
 
13514 
  def __repr__(self):
13515 
    L = ['%s=%r' % (key, value)
13516 
      for key, value in self.__dict__.iteritems()]
13517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13518 
 
13519 
  def __eq__(self, other):
13520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13521 
 
13522 
  def __ne__(self, other):
13523 
    return not (self == other)
13524 
 
13525 
class getUserEmails_result:
13526 
  """
13527 
  Attributes:
13528 
   - success
13529 
  """
13530 
 
13531 
  thrift_spec = (
13532 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13533 
  )
13534 
 
13535 
  def __init__(self, success=None,):
13536 
    self.success = success
13537 
 
13538 
  def read(self, iprot):
13539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13541 
      return
13542 
    iprot.readStructBegin()
13543 
    while True:
13544 
      (fname, ftype, fid) = iprot.readFieldBegin()
13545 
      if ftype == TType.STOP:
13546 
        break
13547 
      if fid == 0:
13548 
        if ftype == TType.LIST:
13549 
          self.success = []
11592 amit.gupta 13550 
          (_etype207, _size204) = iprot.readListBegin()
13551 
          for _i208 in xrange(_size204):
13552 
            _elem209 = iprot.readString();
13553 
            self.success.append(_elem209)
5623 anupam.sin 13554 
          iprot.readListEnd()
13555 
        else:
13556 
          iprot.skip(ftype)
13557 
      else:
13558 
        iprot.skip(ftype)
13559 
      iprot.readFieldEnd()
13560 
    iprot.readStructEnd()
13561 
 
13562 
  def write(self, oprot):
13563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13565 
      return
13566 
    oprot.writeStructBegin('getUserEmails_result')
13567 
    if self.success is not None:
13568 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13569 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 13570 
      for iter210 in self.success:
13571 
        oprot.writeString(iter210)
5623 anupam.sin 13572 
      oprot.writeListEnd()
13573 
      oprot.writeFieldEnd()
13574 
    oprot.writeFieldStop()
13575 
    oprot.writeStructEnd()
13576 
 
13577 
  def validate(self):
13578 
    return
13579 
 
13580 
 
13581 
  def __repr__(self):
13582 
    L = ['%s=%r' % (key, value)
13583 
      for key, value in self.__dict__.iteritems()]
13584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13585 
 
13586 
  def __eq__(self, other):
13587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13588 
 
13589 
  def __ne__(self, other):
13590 
    return not (self == other)
6821 amar.kumar 13591 
 
6903 anupam.sin 13592 
class insureItem_args:
13593 
  """
13594 
  Attributes:
13595 
   - itemId
13596 
   - cartId
13597 
   - toInsure
9299 kshitij.so 13598 
   - insurerType
6903 anupam.sin 13599 
  """
13600 
 
13601 
  thrift_spec = (
13602 
    None, # 0
13603 
    (1, TType.I64, 'itemId', None, None, ), # 1
13604 
    (2, TType.I64, 'cartId', None, None, ), # 2
13605 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 13606 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 13607 
  )
13608 
 
9299 kshitij.so 13609 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 13610 
    self.itemId = itemId
13611 
    self.cartId = cartId
13612 
    self.toInsure = toInsure
9299 kshitij.so 13613 
    self.insurerType = insurerType
6903 anupam.sin 13614 
 
13615 
  def read(self, iprot):
13616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13618 
      return
13619 
    iprot.readStructBegin()
13620 
    while True:
13621 
      (fname, ftype, fid) = iprot.readFieldBegin()
13622 
      if ftype == TType.STOP:
13623 
        break
13624 
      if fid == 1:
13625 
        if ftype == TType.I64:
13626 
          self.itemId = iprot.readI64();
13627 
        else:
13628 
          iprot.skip(ftype)
13629 
      elif fid == 2:
13630 
        if ftype == TType.I64:
13631 
          self.cartId = iprot.readI64();
13632 
        else:
13633 
          iprot.skip(ftype)
13634 
      elif fid == 3:
13635 
        if ftype == TType.BOOL:
13636 
          self.toInsure = iprot.readBool();
13637 
        else:
13638 
          iprot.skip(ftype)
9299 kshitij.so 13639 
      elif fid == 4:
13640 
        if ftype == TType.I32:
13641 
          self.insurerType = iprot.readI32();
13642 
        else:
13643 
          iprot.skip(ftype)
6903 anupam.sin 13644 
      else:
13645 
        iprot.skip(ftype)
13646 
      iprot.readFieldEnd()
13647 
    iprot.readStructEnd()
13648 
 
13649 
  def write(self, oprot):
13650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13652 
      return
13653 
    oprot.writeStructBegin('insureItem_args')
13654 
    if self.itemId is not None:
13655 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13656 
      oprot.writeI64(self.itemId)
13657 
      oprot.writeFieldEnd()
13658 
    if self.cartId is not None:
13659 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
13660 
      oprot.writeI64(self.cartId)
13661 
      oprot.writeFieldEnd()
13662 
    if self.toInsure is not None:
13663 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
13664 
      oprot.writeBool(self.toInsure)
13665 
      oprot.writeFieldEnd()
9299 kshitij.so 13666 
    if self.insurerType is not None:
13667 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
13668 
      oprot.writeI32(self.insurerType)
13669 
      oprot.writeFieldEnd()
6903 anupam.sin 13670 
    oprot.writeFieldStop()
13671 
    oprot.writeStructEnd()
13672 
 
13673 
  def validate(self):
13674 
    return
13675 
 
13676 
 
13677 
  def __repr__(self):
13678 
    L = ['%s=%r' % (key, value)
13679 
      for key, value in self.__dict__.iteritems()]
13680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13681 
 
13682 
  def __eq__(self, other):
13683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13684 
 
13685 
  def __ne__(self, other):
13686 
    return not (self == other)
13687 
 
13688 
class insureItem_result:
13689 
  """
13690 
  Attributes:
13691 
   - success
13692 
  """
13693 
 
13694 
  thrift_spec = (
13695 
    (0, TType.BOOL, 'success', None, None, ), # 0
13696 
  )
13697 
 
13698 
  def __init__(self, success=None,):
13699 
    self.success = success
13700 
 
13701 
  def read(self, iprot):
13702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13704 
      return
13705 
    iprot.readStructBegin()
13706 
    while True:
13707 
      (fname, ftype, fid) = iprot.readFieldBegin()
13708 
      if ftype == TType.STOP:
13709 
        break
13710 
      if fid == 0:
13711 
        if ftype == TType.BOOL:
13712 
          self.success = iprot.readBool();
13713 
        else:
13714 
          iprot.skip(ftype)
13715 
      else:
13716 
        iprot.skip(ftype)
13717 
      iprot.readFieldEnd()
13718 
    iprot.readStructEnd()
13719 
 
13720 
  def write(self, oprot):
13721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13723 
      return
13724 
    oprot.writeStructBegin('insureItem_result')
13725 
    if self.success is not None:
13726 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13727 
      oprot.writeBool(self.success)
13728 
      oprot.writeFieldEnd()
13729 
    oprot.writeFieldStop()
13730 
    oprot.writeStructEnd()
13731 
 
13732 
  def validate(self):
13733 
    return
13734 
 
13735 
 
13736 
  def __repr__(self):
13737 
    L = ['%s=%r' % (key, value)
13738 
      for key, value in self.__dict__.iteritems()]
13739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13740 
 
13741 
  def __eq__(self, other):
13742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13743 
 
13744 
  def __ne__(self, other):
13745 
    return not (self == other)
13746 
 
13747 
class cancelInsurance_args:
13748 
  """
13749 
  Attributes:
13750 
   - cartId
13751 
  """
13752 
 
13753 
  thrift_spec = (
13754 
    None, # 0
13755 
    (1, TType.I64, 'cartId', None, None, ), # 1
13756 
  )
13757 
 
13758 
  def __init__(self, cartId=None,):
13759 
    self.cartId = cartId
13760 
 
13761 
  def read(self, iprot):
13762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13764 
      return
13765 
    iprot.readStructBegin()
13766 
    while True:
13767 
      (fname, ftype, fid) = iprot.readFieldBegin()
13768 
      if ftype == TType.STOP:
13769 
        break
13770 
      if fid == 1:
13771 
        if ftype == TType.I64:
13772 
          self.cartId = iprot.readI64();
13773 
        else:
13774 
          iprot.skip(ftype)
13775 
      else:
13776 
        iprot.skip(ftype)
13777 
      iprot.readFieldEnd()
13778 
    iprot.readStructEnd()
13779 
 
13780 
  def write(self, oprot):
13781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13783 
      return
13784 
    oprot.writeStructBegin('cancelInsurance_args')
13785 
    if self.cartId is not None:
13786 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13787 
      oprot.writeI64(self.cartId)
13788 
      oprot.writeFieldEnd()
13789 
    oprot.writeFieldStop()
13790 
    oprot.writeStructEnd()
13791 
 
13792 
  def validate(self):
13793 
    return
13794 
 
13795 
 
13796 
  def __repr__(self):
13797 
    L = ['%s=%r' % (key, value)
13798 
      for key, value in self.__dict__.iteritems()]
13799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13800 
 
13801 
  def __eq__(self, other):
13802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13803 
 
13804 
  def __ne__(self, other):
13805 
    return not (self == other)
13806 
 
13807 
class cancelInsurance_result:
13808 
  """
13809 
  Attributes:
13810 
   - success
13811 
  """
13812 
 
13813 
  thrift_spec = (
13814 
    (0, TType.BOOL, 'success', None, None, ), # 0
13815 
  )
13816 
 
13817 
  def __init__(self, success=None,):
13818 
    self.success = success
13819 
 
13820 
  def read(self, iprot):
13821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13823 
      return
13824 
    iprot.readStructBegin()
13825 
    while True:
13826 
      (fname, ftype, fid) = iprot.readFieldBegin()
13827 
      if ftype == TType.STOP:
13828 
        break
13829 
      if fid == 0:
13830 
        if ftype == TType.BOOL:
13831 
          self.success = iprot.readBool();
13832 
        else:
13833 
          iprot.skip(ftype)
13834 
      else:
13835 
        iprot.skip(ftype)
13836 
      iprot.readFieldEnd()
13837 
    iprot.readStructEnd()
13838 
 
13839 
  def write(self, oprot):
13840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13842 
      return
13843 
    oprot.writeStructBegin('cancelInsurance_result')
13844 
    if self.success is not None:
13845 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13846 
      oprot.writeBool(self.success)
13847 
      oprot.writeFieldEnd()
13848 
    oprot.writeFieldStop()
13849 
    oprot.writeStructEnd()
13850 
 
13851 
  def validate(self):
13852 
    return
13853 
 
13854 
 
13855 
  def __repr__(self):
13856 
    L = ['%s=%r' % (key, value)
13857 
      for key, value in self.__dict__.iteritems()]
13858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13859 
 
13860 
  def __eq__(self, other):
13861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13862 
 
13863 
  def __ne__(self, other):
13864 
    return not (self == other)
13865 
 
13866 
class storeInsuranceSpecificDetails_args:
13867 
  """
13868 
  Attributes:
13869 
   - addressId
13870 
   - dob
13871 
   - guardianName
13872 
  """
13873 
 
13874 
  thrift_spec = (
13875 
    None, # 0
13876 
    (1, TType.I64, 'addressId', None, None, ), # 1
13877 
    (2, TType.STRING, 'dob', None, None, ), # 2
13878 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
13879 
  )
13880 
 
13881 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
13882 
    self.addressId = addressId
13883 
    self.dob = dob
13884 
    self.guardianName = guardianName
13885 
 
13886 
  def read(self, iprot):
13887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13889 
      return
13890 
    iprot.readStructBegin()
13891 
    while True:
13892 
      (fname, ftype, fid) = iprot.readFieldBegin()
13893 
      if ftype == TType.STOP:
13894 
        break
13895 
      if fid == 1:
13896 
        if ftype == TType.I64:
13897 
          self.addressId = iprot.readI64();
13898 
        else:
13899 
          iprot.skip(ftype)
13900 
      elif fid == 2:
13901 
        if ftype == TType.STRING:
13902 
          self.dob = iprot.readString();
13903 
        else:
13904 
          iprot.skip(ftype)
13905 
      elif fid == 3:
13906 
        if ftype == TType.STRING:
13907 
          self.guardianName = iprot.readString();
13908 
        else:
13909 
          iprot.skip(ftype)
13910 
      else:
13911 
        iprot.skip(ftype)
13912 
      iprot.readFieldEnd()
13913 
    iprot.readStructEnd()
13914 
 
13915 
  def write(self, oprot):
13916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13918 
      return
13919 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
13920 
    if self.addressId is not None:
13921 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
13922 
      oprot.writeI64(self.addressId)
13923 
      oprot.writeFieldEnd()
13924 
    if self.dob is not None:
13925 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
13926 
      oprot.writeString(self.dob)
13927 
      oprot.writeFieldEnd()
13928 
    if self.guardianName is not None:
13929 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
13930 
      oprot.writeString(self.guardianName)
13931 
      oprot.writeFieldEnd()
13932 
    oprot.writeFieldStop()
13933 
    oprot.writeStructEnd()
13934 
 
13935 
  def validate(self):
13936 
    return
13937 
 
13938 
 
13939 
  def __repr__(self):
13940 
    L = ['%s=%r' % (key, value)
13941 
      for key, value in self.__dict__.iteritems()]
13942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13943 
 
13944 
  def __eq__(self, other):
13945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13946 
 
13947 
  def __ne__(self, other):
13948 
    return not (self == other)
13949 
 
13950 
class storeInsuranceSpecificDetails_result:
13951 
  """
13952 
  Attributes:
13953 
   - success
13954 
  """
13955 
 
13956 
  thrift_spec = (
13957 
    (0, TType.BOOL, 'success', None, None, ), # 0
13958 
  )
13959 
 
13960 
  def __init__(self, success=None,):
13961 
    self.success = success
13962 
 
13963 
  def read(self, iprot):
13964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13966 
      return
13967 
    iprot.readStructBegin()
13968 
    while True:
13969 
      (fname, ftype, fid) = iprot.readFieldBegin()
13970 
      if ftype == TType.STOP:
13971 
        break
13972 
      if fid == 0:
13973 
        if ftype == TType.BOOL:
13974 
          self.success = iprot.readBool();
13975 
        else:
13976 
          iprot.skip(ftype)
13977 
      else:
13978 
        iprot.skip(ftype)
13979 
      iprot.readFieldEnd()
13980 
    iprot.readStructEnd()
13981 
 
13982 
  def write(self, oprot):
13983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13985 
      return
13986 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
13987 
    if self.success is not None:
13988 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13989 
      oprot.writeBool(self.success)
13990 
      oprot.writeFieldEnd()
13991 
    oprot.writeFieldStop()
13992 
    oprot.writeStructEnd()
13993 
 
13994 
  def validate(self):
13995 
    return
13996 
 
13997 
 
13998 
  def __repr__(self):
13999 
    L = ['%s=%r' % (key, value)
14000 
      for key, value in self.__dict__.iteritems()]
14001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14002 
 
14003 
  def __eq__(self, other):
14004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14005 
 
14006 
  def __ne__(self, other):
14007 
    return not (self == other)
14008 
 
14009 
class isInsuranceDetailPresent_args:
14010 
  """
14011 
  Attributes:
14012 
   - addressId
14013 
  """
14014 
 
14015 
  thrift_spec = (
14016 
    None, # 0
14017 
    (1, TType.I64, 'addressId', None, None, ), # 1
14018 
  )
14019 
 
14020 
  def __init__(self, addressId=None,):
14021 
    self.addressId = addressId
14022 
 
14023 
  def read(self, iprot):
14024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14026 
      return
14027 
    iprot.readStructBegin()
14028 
    while True:
14029 
      (fname, ftype, fid) = iprot.readFieldBegin()
14030 
      if ftype == TType.STOP:
14031 
        break
14032 
      if fid == 1:
14033 
        if ftype == TType.I64:
14034 
          self.addressId = iprot.readI64();
14035 
        else:
14036 
          iprot.skip(ftype)
14037 
      else:
14038 
        iprot.skip(ftype)
14039 
      iprot.readFieldEnd()
14040 
    iprot.readStructEnd()
14041 
 
14042 
  def write(self, oprot):
14043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14045 
      return
14046 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14047 
    if self.addressId is not None:
14048 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14049 
      oprot.writeI64(self.addressId)
14050 
      oprot.writeFieldEnd()
14051 
    oprot.writeFieldStop()
14052 
    oprot.writeStructEnd()
14053 
 
14054 
  def validate(self):
14055 
    return
14056 
 
14057 
 
14058 
  def __repr__(self):
14059 
    L = ['%s=%r' % (key, value)
14060 
      for key, value in self.__dict__.iteritems()]
14061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14062 
 
14063 
  def __eq__(self, other):
14064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14065 
 
14066 
  def __ne__(self, other):
14067 
    return not (self == other)
14068 
 
14069 
class isInsuranceDetailPresent_result:
14070 
  """
14071 
  Attributes:
14072 
   - success
14073 
  """
14074 
 
14075 
  thrift_spec = (
14076 
    (0, TType.BOOL, 'success', None, None, ), # 0
14077 
  )
14078 
 
14079 
  def __init__(self, success=None,):
14080 
    self.success = success
14081 
 
14082 
  def read(self, iprot):
14083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14085 
      return
14086 
    iprot.readStructBegin()
14087 
    while True:
14088 
      (fname, ftype, fid) = iprot.readFieldBegin()
14089 
      if ftype == TType.STOP:
14090 
        break
14091 
      if fid == 0:
14092 
        if ftype == TType.BOOL:
14093 
          self.success = iprot.readBool();
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      else:
14097 
        iprot.skip(ftype)
14098 
      iprot.readFieldEnd()
14099 
    iprot.readStructEnd()
14100 
 
14101 
  def write(self, oprot):
14102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14104 
      return
14105 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14106 
    if self.success is not None:
14107 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14108 
      oprot.writeBool(self.success)
14109 
      oprot.writeFieldEnd()
14110 
    oprot.writeFieldStop()
14111 
    oprot.writeStructEnd()
14112 
 
14113 
  def validate(self):
14114 
    return
14115 
 
14116 
 
14117 
  def __repr__(self):
14118 
    L = ['%s=%r' % (key, value)
14119 
      for key, value in self.__dict__.iteritems()]
14120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14121 
 
14122 
  def __eq__(self, other):
14123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14124 
 
14125 
  def __ne__(self, other):
14126 
    return not (self == other)
14127 
 
9791 rajveer 14128 
class getProductsAddedToCart_args:
6821 amar.kumar 14129 
  """
14130 
  Attributes:
14131 
   - startDate
14132 
   - endDate
14133 
  """
14134 
 
14135 
  thrift_spec = (
14136 
    None, # 0
9791 rajveer 14137 
    (1, TType.I64, 'startDate', None, None, ), # 1
14138 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14139 
  )
14140 
 
9791 rajveer 14141 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14142 
    self.startDate = startDate
14143 
    self.endDate = endDate
14144 
 
14145 
  def read(self, iprot):
14146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14148 
      return
14149 
    iprot.readStructBegin()
14150 
    while True:
14151 
      (fname, ftype, fid) = iprot.readFieldBegin()
14152 
      if ftype == TType.STOP:
14153 
        break
14154 
      if fid == 1:
14155 
        if ftype == TType.I64:
9791 rajveer 14156 
          self.startDate = iprot.readI64();
6821 amar.kumar 14157 
        else:
14158 
          iprot.skip(ftype)
14159 
      elif fid == 2:
14160 
        if ftype == TType.I64:
14161 
          self.endDate = 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
9791 rajveer 14173 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14174 
    if self.startDate is not None:
9791 rajveer 14175 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14176 
      oprot.writeI64(self.startDate)
14177 
      oprot.writeFieldEnd()
14178 
    if self.endDate is not None:
9791 rajveer 14179 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14180 
      oprot.writeI64(self.endDate)
14181 
      oprot.writeFieldEnd()
14182 
    oprot.writeFieldStop()
14183 
    oprot.writeStructEnd()
14184 
 
14185 
  def validate(self):
14186 
    return
14187 
 
14188 
 
14189 
  def __repr__(self):
14190 
    L = ['%s=%r' % (key, value)
14191 
      for key, value in self.__dict__.iteritems()]
14192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14193 
 
14194 
  def __eq__(self, other):
14195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14196 
 
14197 
  def __ne__(self, other):
14198 
    return not (self == other)
14199 
 
9791 rajveer 14200 
class getProductsAddedToCart_result:
6821 amar.kumar 14201 
  """
14202 
  Attributes:
14203 
   - success
14204 
  """
14205 
 
14206 
  thrift_spec = (
9791 rajveer 14207 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14208 
  )
14209 
 
14210 
  def __init__(self, success=None,):
14211 
    self.success = success
14212 
 
14213 
  def read(self, iprot):
14214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14216 
      return
14217 
    iprot.readStructBegin()
14218 
    while True:
14219 
      (fname, ftype, fid) = iprot.readFieldBegin()
14220 
      if ftype == TType.STOP:
14221 
        break
14222 
      if fid == 0:
9791 rajveer 14223 
        if ftype == TType.LIST:
14224 
          self.success = []
11592 amit.gupta 14225 
          (_etype214, _size211) = iprot.readListBegin()
14226 
          for _i215 in xrange(_size211):
14227 
            _elem216 = iprot.readI64();
14228 
            self.success.append(_elem216)
9791 rajveer 14229 
          iprot.readListEnd()
6821 amar.kumar 14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      else:
14233 
        iprot.skip(ftype)
14234 
      iprot.readFieldEnd()
14235 
    iprot.readStructEnd()
14236 
 
14237 
  def write(self, oprot):
14238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14240 
      return
9791 rajveer 14241 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14242 
    if self.success is not None:
9791 rajveer 14243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14244 
      oprot.writeListBegin(TType.I64, len(self.success))
11592 amit.gupta 14245 
      for iter217 in self.success:
14246 
        oprot.writeI64(iter217)
9791 rajveer 14247 
      oprot.writeListEnd()
6821 amar.kumar 14248 
      oprot.writeFieldEnd()
14249 
    oprot.writeFieldStop()
14250 
    oprot.writeStructEnd()
14251 
 
14252 
  def validate(self):
14253 
    return
14254 
 
14255 
 
14256 
  def __repr__(self):
14257 
    L = ['%s=%r' % (key, value)
14258 
      for key, value in self.__dict__.iteritems()]
14259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14260 
 
14261 
  def __eq__(self, other):
14262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14263 
 
14264 
  def __ne__(self, other):
14265 
    return not (self == other)
11592 amit.gupta 14266 
 
14267 
class validateCartPlus_args:
14268 
  """
14269 
  Attributes:
14270 
   - cartId
14271 
   - sourceId
14272 
  """
14273 
 
14274 
  thrift_spec = (
14275 
    None, # 0
14276 
    (1, TType.I64, 'cartId', None, None, ), # 1
14277 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14278 
  )
14279 
 
14280 
  def __init__(self, cartId=None, sourceId=None,):
14281 
    self.cartId = cartId
14282 
    self.sourceId = sourceId
14283 
 
14284 
  def read(self, iprot):
14285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14287 
      return
14288 
    iprot.readStructBegin()
14289 
    while True:
14290 
      (fname, ftype, fid) = iprot.readFieldBegin()
14291 
      if ftype == TType.STOP:
14292 
        break
14293 
      if fid == 1:
14294 
        if ftype == TType.I64:
14295 
          self.cartId = iprot.readI64();
14296 
        else:
14297 
          iprot.skip(ftype)
14298 
      elif fid == 2:
14299 
        if ftype == TType.I64:
14300 
          self.sourceId = iprot.readI64();
14301 
        else:
14302 
          iprot.skip(ftype)
14303 
      else:
14304 
        iprot.skip(ftype)
14305 
      iprot.readFieldEnd()
14306 
    iprot.readStructEnd()
14307 
 
14308 
  def write(self, oprot):
14309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14311 
      return
14312 
    oprot.writeStructBegin('validateCartPlus_args')
14313 
    if self.cartId is not None:
14314 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14315 
      oprot.writeI64(self.cartId)
14316 
      oprot.writeFieldEnd()
14317 
    if self.sourceId is not None:
14318 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14319 
      oprot.writeI64(self.sourceId)
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 validateCartPlus_result:
14340 
  """
14341 
  Attributes:
14342 
   - success
14343 
   - scex
14344 
  """
14345 
 
14346 
  thrift_spec = (
14347 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
14348 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
14349 
  )
14350 
 
14351 
  def __init__(self, success=None, scex=None,):
14352 
    self.success = success
14353 
    self.scex = scex
14354 
 
14355 
  def read(self, iprot):
14356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14358 
      return
14359 
    iprot.readStructBegin()
14360 
    while True:
14361 
      (fname, ftype, fid) = iprot.readFieldBegin()
14362 
      if ftype == TType.STOP:
14363 
        break
14364 
      if fid == 0:
14365 
        if ftype == TType.STRUCT:
14366 
          self.success = CartPlus()
14367 
          self.success.read(iprot)
14368 
        else:
14369 
          iprot.skip(ftype)
14370 
      elif fid == 1:
14371 
        if ftype == TType.STRUCT:
14372 
          self.scex = ShoppingCartException()
14373 
          self.scex.read(iprot)
14374 
        else:
14375 
          iprot.skip(ftype)
14376 
      else:
14377 
        iprot.skip(ftype)
14378 
      iprot.readFieldEnd()
14379 
    iprot.readStructEnd()
14380 
 
14381 
  def write(self, oprot):
14382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14384 
      return
14385 
    oprot.writeStructBegin('validateCartPlus_result')
14386 
    if self.success is not None:
14387 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14388 
      self.success.write(oprot)
14389 
      oprot.writeFieldEnd()
14390 
    if self.scex is not None:
14391 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
14392 
      self.scex.write(oprot)
14393 
      oprot.writeFieldEnd()
14394 
    oprot.writeFieldStop()
14395 
    oprot.writeStructEnd()
14396 
 
14397 
  def validate(self):
14398 
    return
14399 
 
14400 
 
14401 
  def __repr__(self):
14402 
    L = ['%s=%r' % (key, value)
14403 
      for key, value in self.__dict__.iteritems()]
14404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14405 
 
14406 
  def __eq__(self, other):
14407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14408 
 
14409 
  def __ne__(self, other):
14410 
    return not (self == other)
11679 vikram.rag 14411 
 
14412 
class isPrivateDealUser_args:
14413 
  """
14414 
  Attributes:
14415 
   - userId
14416 
  """
14417 
 
14418 
  thrift_spec = (
14419 
    None, # 0
14420 
    (1, TType.I64, 'userId', None, None, ), # 1
14421 
  )
14422 
 
14423 
  def __init__(self, userId=None,):
14424 
    self.userId = userId
14425 
 
14426 
  def read(self, iprot):
14427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14429 
      return
14430 
    iprot.readStructBegin()
14431 
    while True:
14432 
      (fname, ftype, fid) = iprot.readFieldBegin()
14433 
      if ftype == TType.STOP:
14434 
        break
14435 
      if fid == 1:
14436 
        if ftype == TType.I64:
14437 
          self.userId = iprot.readI64();
14438 
        else:
14439 
          iprot.skip(ftype)
14440 
      else:
14441 
        iprot.skip(ftype)
14442 
      iprot.readFieldEnd()
14443 
    iprot.readStructEnd()
14444 
 
14445 
  def write(self, oprot):
14446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14448 
      return
14449 
    oprot.writeStructBegin('isPrivateDealUser_args')
14450 
    if self.userId is not None:
14451 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14452 
      oprot.writeI64(self.userId)
14453 
      oprot.writeFieldEnd()
14454 
    oprot.writeFieldStop()
14455 
    oprot.writeStructEnd()
14456 
 
14457 
  def validate(self):
14458 
    return
14459 
 
14460 
 
14461 
  def __repr__(self):
14462 
    L = ['%s=%r' % (key, value)
14463 
      for key, value in self.__dict__.iteritems()]
14464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14465 
 
14466 
  def __eq__(self, other):
14467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14468 
 
14469 
  def __ne__(self, other):
14470 
    return not (self == other)
14471 
 
14472 
class isPrivateDealUser_result:
14473 
  """
14474 
  Attributes:
14475 
   - success
14476 
  """
14477 
 
14478 
  thrift_spec = (
14479 
    (0, TType.BOOL, 'success', None, None, ), # 0
14480 
  )
14481 
 
14482 
  def __init__(self, success=None,):
14483 
    self.success = success
14484 
 
14485 
  def read(self, iprot):
14486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14488 
      return
14489 
    iprot.readStructBegin()
14490 
    while True:
14491 
      (fname, ftype, fid) = iprot.readFieldBegin()
14492 
      if ftype == TType.STOP:
14493 
        break
14494 
      if fid == 0:
14495 
        if ftype == TType.BOOL:
14496 
          self.success = iprot.readBool();
14497 
        else:
14498 
          iprot.skip(ftype)
14499 
      else:
14500 
        iprot.skip(ftype)
14501 
      iprot.readFieldEnd()
14502 
    iprot.readStructEnd()
14503 
 
14504 
  def write(self, oprot):
14505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14507 
      return
14508 
    oprot.writeStructBegin('isPrivateDealUser_result')
14509 
    if self.success is not None:
14510 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14511 
      oprot.writeBool(self.success)
14512 
      oprot.writeFieldEnd()
14513 
    oprot.writeFieldStop()
14514 
    oprot.writeStructEnd()
14515 
 
14516 
  def validate(self):
14517 
    return
14518 
 
14519 
 
14520 
  def __repr__(self):
14521 
    L = ['%s=%r' % (key, value)
14522 
      for key, value in self.__dict__.iteritems()]
14523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14524 
 
14525 
  def __eq__(self, other):
14526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14527 
 
14528 
  def __ne__(self, other):
14529 
    return not (self == other)