Subversion Repositories SmartDukaan

Rev

Rev 7039 | Rev 9299 | 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 
 
6389 rajveer 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId):
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
559 chandransh 420 
    """
421 
    pass
422 
 
3557 rajveer 423 
  def validateCart(self, cartId, sourceId):
559 chandransh 424 
    """
690 chandransh 425 
    Validates that:
426 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 427 
    2. All of the lines in the cart are active items.
690 chandransh 428 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 429 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 430 
 
559 chandransh 431 
    Parameters:
432 
     - cartId
3557 rajveer 433 
     - sourceId
559 chandransh 434 
    """
435 
    pass
436 
 
690 chandransh 437 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 438 
    """
690 chandransh 439 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 440 
 
575 chandransh 441 
    Parameters:
690 chandransh 442 
     - fromCartId
443 
     - toCartId
444 
    """
445 
    pass
446 
 
447 
  def checkOut(self, cartId):
448 
    """
449 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 450 
 
690 chandransh 451 
    Parameters:
575 chandransh 452 
     - cartId
453 
    """
454 
    pass
455 
 
690 chandransh 456 
  def resetCart(self, cartId, items):
559 chandransh 457 
    """
690 chandransh 458 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
459 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 460 
 
559 chandransh 461 
    Parameters:
690 chandransh 462 
     - cartId
463 
     - items
559 chandransh 464 
    """
465 
    pass
466 
 
2981 rajveer 467 
  def getUserCount(self, userType):
559 chandransh 468 
    """
2981 rajveer 469 
    Returns number of registered users.
470 
    If userType = null, then it returns count of all users, including anonymous
471 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
472 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 473 
 
559 chandransh 474 
    Parameters:
2981 rajveer 475 
     - userType
559 chandransh 476 
    """
477 
    pass
478 
 
2981 rajveer 479 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 480 
    """
2981 rajveer 481 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
482 
    If any of startDate or endDate is -1, then that filter is ignored.
483 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 484 
 
485 
 
559 chandransh 486 
    Parameters:
2981 rajveer 487 
     - userType
488 
     - startDate
489 
     - endDate
559 chandransh 490 
    """
491 
    pass
492 
 
2981 rajveer 493 
  def getMyResearchItems(self, userId):
559 chandransh 494 
    """
2981 rajveer 495 
    Returns list of item ids in myresearch for the user
3431 rajveer 496 
 
559 chandransh 497 
    Parameters:
498 
     - userId
499 
    """
500 
    pass
501 
 
2981 rajveer 502 
  def updateMyResearch(self, userId, itemId):
559 chandransh 503 
    """
2981 rajveer 504 
    add item to my research for a user
3431 rajveer 505 
 
559 chandransh 506 
    Parameters:
2981 rajveer 507 
     - userId
508 
     - itemId
559 chandransh 509 
    """
510 
    pass
511 
 
2981 rajveer 512 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 513 
    """
2981 rajveer 514 
    delete item from my research for a user
3431 rajveer 515 
 
1596 ankur.sing 516 
    Parameters:
2981 rajveer 517 
     - userId
518 
     - itemId
1596 ankur.sing 519 
    """
520 
    pass
559 chandransh 521 
 
2981 rajveer 522 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 523 
    """
2981 rajveer 524 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 525 
 
1673 ankur.sing 526 
    Parameters:
2981 rajveer 527 
     - userId
1673 ankur.sing 528 
    """
529 
    pass
1596 ankur.sing 530 
 
2981 rajveer 531 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 532 
    """
2981 rajveer 533 
    add item to browse history for a user
3431 rajveer 534 
 
2642 varun.gupt 535 
    Parameters:
2981 rajveer 536 
     - userId
537 
     - itemId
2642 varun.gupt 538 
    """
539 
    pass
1673 ankur.sing 540 
 
3385 varun.gupt 541 
  def getCartsWithCouponCount(self, couponCode):
542 
    """
543 
    Returns count of Carts with given coupon applied
3431 rajveer 544 
 
3385 varun.gupt 545 
    Parameters:
546 
     - couponCode
547 
    """
548 
    pass
2642 varun.gupt 549 
 
3499 mandeep.dh 550 
  def increaseTrustLevel(self, userId, trustLevelDelta):
551 
    """
552 
    Updates COD trust level of a user
3385 varun.gupt 553 
 
3499 mandeep.dh 554 
    Parameters:
555 
     - userId
556 
     - trustLevelDelta
557 
    """
558 
    pass
559 
 
5407 amar.kumar 560 
  def getTrustLevel(self, userId):
561 
    """
562 
    Get trust level of a user
563 
 
564 
    Parameters:
565 
     - userId
566 
    """
567 
    pass
568 
 
4668 varun.gupt 569 
  def showCODOption(self, cartId, sourceId, pincode):
570 
    """
571 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 572 
 
4668 varun.gupt 573 
    Parameters:
574 
     - cartId
575 
     - sourceId
576 
     - pincode
577 
    """
578 
    pass
579 
 
5623 anupam.sin 580 
  def getUserEmails(self, startDate, endDate):
581 
    """
582 
    Get email addresses for users activated within a given date range
4668 varun.gupt 583 
 
5623 anupam.sin 584 
    Parameters:
585 
     - startDate
586 
     - endDate
587 
    """
588 
    pass
589 
 
6903 anupam.sin 590 
  def insureItem(self, itemId, cartId, toInsure):
591 
    """
592 
    Mark a cart lineitem as insured. Returns true/false.
593 
 
594 
    Parameters:
595 
     - itemId
596 
     - cartId
597 
     - toInsure
598 
    """
599 
    pass
600 
 
601 
  def cancelInsurance(self, cartId):
602 
    """
603 
    Cancel insurance for all items in the cart
604 
 
605 
    Parameters:
606 
     - cartId
607 
    """
608 
    pass
609 
 
610 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
611 
    """
612 
    Stores insurance specific details like date of birth and guardianName
613 
 
614 
    Parameters:
615 
     - addressId
616 
     - dob
617 
     - guardianName
618 
    """
619 
    pass
620 
 
621 
  def isInsuranceDetailPresent(self, addressId):
622 
    """
623 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
624 
 
625 
    Parameters:
626 
     - addressId
627 
    """
628 
    pass
629 
 
6821 amar.kumar 630 
  def isProductAddedToCart(self, itemId, startDate, endDate):
631 
    """
632 
    Returns whether product is added to cart from startDate to endDate
5623 anupam.sin 633 
 
6821 amar.kumar 634 
    Parameters:
635 
     - itemId
636 
     - startDate
637 
     - endDate
638 
    """
639 
    pass
640 
 
641 
 
3376 rajveer 642 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 643 
  """
644 
  service
645 
  """
646 
  def __init__(self, iprot, oprot=None):
3376 rajveer 647 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 648 
 
559 chandransh 649 
  def createAnonymousUser(self, jsessionId):
94 ashish 650 
    """
651 
    Parameters:
559 chandransh 652 
     - jsessionId
94 ashish 653 
    """
559 chandransh 654 
    self.send_createAnonymousUser(jsessionId)
655 
    return self.recv_createAnonymousUser()
94 ashish 656 
 
559 chandransh 657 
  def send_createAnonymousUser(self, jsessionId):
658 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
659 
    args = createAnonymousUser_args()
660 
    args.jsessionId = jsessionId
94 ashish 661 
    args.write(self._oprot)
662 
    self._oprot.writeMessageEnd()
663 
    self._oprot.trans.flush()
664 
 
559 chandransh 665 
  def recv_createAnonymousUser(self, ):
94 ashish 666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
667 
    if mtype == TMessageType.EXCEPTION:
668 
      x = TApplicationException()
669 
      x.read(self._iprot)
670 
      self._iprot.readMessageEnd()
671 
      raise x
559 chandransh 672 
    result = createAnonymousUser_result()
94 ashish 673 
    result.read(self._iprot)
674 
    self._iprot.readMessageEnd()
3431 rajveer 675 
    if result.success is not None:
94 ashish 676 
      return result.success
3431 rajveer 677 
    if result.ucex is not None:
559 chandransh 678 
      raise result.ucex
679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 680 
 
559 chandransh 681 
  def getUserById(self, userId):
94 ashish 682 
    """
683 
    Parameters:
684 
     - userId
685 
    """
559 chandransh 686 
    self.send_getUserById(userId)
687 
    return self.recv_getUserById()
94 ashish 688 
 
559 chandransh 689 
  def send_getUserById(self, userId):
690 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
691 
    args = getUserById_args()
94 ashish 692 
    args.userId = userId
693 
    args.write(self._oprot)
694 
    self._oprot.writeMessageEnd()
695 
    self._oprot.trans.flush()
696 
 
559 chandransh 697 
  def recv_getUserById(self, ):
94 ashish 698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
699 
    if mtype == TMessageType.EXCEPTION:
700 
      x = TApplicationException()
701 
      x.read(self._iprot)
702 
      self._iprot.readMessageEnd()
703 
      raise x
559 chandransh 704 
    result = getUserById_result()
94 ashish 705 
    result.read(self._iprot)
706 
    self._iprot.readMessageEnd()
3431 rajveer 707 
    if result.success is not None:
94 ashish 708 
      return result.success
3431 rajveer 709 
    if result.ucex is not None:
559 chandransh 710 
      raise result.ucex
711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 712 
 
5326 rajveer 713 
  def getUserByCartId(self, cartId):
714 
    """
715 
    Parameters:
716 
     - cartId
717 
    """
718 
    self.send_getUserByCartId(cartId)
719 
    return self.recv_getUserByCartId()
720 
 
721 
  def send_getUserByCartId(self, cartId):
722 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
723 
    args = getUserByCartId_args()
724 
    args.cartId = cartId
725 
    args.write(self._oprot)
726 
    self._oprot.writeMessageEnd()
727 
    self._oprot.trans.flush()
728 
 
729 
  def recv_getUserByCartId(self, ):
730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
731 
    if mtype == TMessageType.EXCEPTION:
732 
      x = TApplicationException()
733 
      x.read(self._iprot)
734 
      self._iprot.readMessageEnd()
735 
      raise x
736 
    result = getUserByCartId_result()
737 
    result.read(self._iprot)
738 
    self._iprot.readMessageEnd()
739 
    if result.success is not None:
740 
      return result.success
741 
    if result.ucex is not None:
742 
      raise result.ucex
743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
744 
 
1491 vikas 745 
  def getUserByEmail(self, email):
746 
    """
747 
    Parameters:
748 
     - email
749 
    """
750 
    self.send_getUserByEmail(email)
751 
    return self.recv_getUserByEmail()
752 
 
753 
  def send_getUserByEmail(self, email):
754 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
755 
    args = getUserByEmail_args()
756 
    args.email = email
757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
761 
  def recv_getUserByEmail(self, ):
762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
768 
    result = getUserByEmail_result()
769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
3431 rajveer 771 
    if result.success is not None:
1491 vikas 772 
      return result.success
3431 rajveer 773 
    if result.ucex is not None:
1491 vikas 774 
      raise result.ucex
775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
776 
 
3032 mandeep.dh 777 
  def getUserByMobileNumber(self, mobileNumber):
778 
    """
779 
    Parameters:
780 
     - mobileNumber
781 
    """
782 
    self.send_getUserByMobileNumber(mobileNumber)
783 
    return self.recv_getUserByMobileNumber()
784 
 
785 
  def send_getUserByMobileNumber(self, mobileNumber):
786 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
787 
    args = getUserByMobileNumber_args()
788 
    args.mobileNumber = mobileNumber
789 
    args.write(self._oprot)
790 
    self._oprot.writeMessageEnd()
791 
    self._oprot.trans.flush()
792 
 
793 
  def recv_getUserByMobileNumber(self, ):
794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
795 
    if mtype == TMessageType.EXCEPTION:
796 
      x = TApplicationException()
797 
      x.read(self._iprot)
798 
      self._iprot.readMessageEnd()
799 
      raise x
800 
    result = getUserByMobileNumber_result()
801 
    result.read(self._iprot)
802 
    self._iprot.readMessageEnd()
3431 rajveer 803 
    if result.success is not None:
3032 mandeep.dh 804 
      return result.success
3431 rajveer 805 
    if result.ucex is not None:
3032 mandeep.dh 806 
      raise result.ucex
807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
808 
 
559 chandransh 809 
  def createUser(self, user):
94 ashish 810 
    """
811 
    Parameters:
559 chandransh 812 
     - user
94 ashish 813 
    """
559 chandransh 814 
    self.send_createUser(user)
815 
    return self.recv_createUser()
94 ashish 816 
 
559 chandransh 817 
  def send_createUser(self, user):
818 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
819 
    args = createUser_args()
820 
    args.user = user
94 ashish 821 
    args.write(self._oprot)
822 
    self._oprot.writeMessageEnd()
823 
    self._oprot.trans.flush()
824 
 
559 chandransh 825 
  def recv_createUser(self, ):
94 ashish 826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
827 
    if mtype == TMessageType.EXCEPTION:
828 
      x = TApplicationException()
829 
      x.read(self._iprot)
830 
      self._iprot.readMessageEnd()
831 
      raise x
559 chandransh 832 
    result = createUser_result()
94 ashish 833 
    result.read(self._iprot)
834 
    self._iprot.readMessageEnd()
3431 rajveer 835 
    if result.success is not None:
94 ashish 836 
      return result.success
3431 rajveer 837 
    if result.ucex is not None:
559 chandransh 838 
      raise result.ucex
839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 840 
 
559 chandransh 841 
  def updateUser(self, user):
94 ashish 842 
    """
843 
    Parameters:
559 chandransh 844 
     - user
94 ashish 845 
    """
559 chandransh 846 
    self.send_updateUser(user)
847 
    return self.recv_updateUser()
94 ashish 848 
 
559 chandransh 849 
  def send_updateUser(self, user):
850 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
851 
    args = updateUser_args()
852 
    args.user = user
94 ashish 853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
559 chandransh 857 
  def recv_updateUser(self, ):
94 ashish 858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
559 chandransh 864 
    result = updateUser_result()
94 ashish 865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
3431 rajveer 867 
    if result.success is not None:
94 ashish 868 
      return result.success
3431 rajveer 869 
    if result.ucex is not None:
559 chandransh 870 
      raise result.ucex
871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 872 
 
559 chandransh 873 
  def authenticateUser(self, email, password):
94 ashish 874 
    """
875 
    Parameters:
876 
     - email
877 
     - password
878 
    """
559 chandransh 879 
    self.send_authenticateUser(email, password)
122 ashish 880 
    return self.recv_authenticateUser()
881 
 
559 chandransh 882 
  def send_authenticateUser(self, email, password):
122 ashish 883 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
884 
    args = authenticateUser_args()
559 chandransh 885 
    args.email = email
122 ashish 886 
    args.password = password
887 
    args.write(self._oprot)
888 
    self._oprot.writeMessageEnd()
889 
    self._oprot.trans.flush()
890 
 
891 
  def recv_authenticateUser(self, ):
892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
893 
    if mtype == TMessageType.EXCEPTION:
894 
      x = TApplicationException()
895 
      x.read(self._iprot)
896 
      self._iprot.readMessageEnd()
897 
      raise x
898 
    result = authenticateUser_result()
899 
    result.read(self._iprot)
900 
    self._iprot.readMessageEnd()
3431 rajveer 901 
    if result.success is not None:
122 ashish 902 
      return result.success
3431 rajveer 903 
    if result.auex is not None:
559 chandransh 904 
      raise result.auex
122 ashish 905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
906 
 
94 ashish 907 
  def userExists(self, email):
908 
    """
909 
    Parameters:
910 
     - email
911 
    """
912 
    self.send_userExists(email)
913 
    return self.recv_userExists()
914 
 
915 
  def send_userExists(self, email):
916 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
917 
    args = userExists_args()
918 
    args.email = email
919 
    args.write(self._oprot)
920 
    self._oprot.writeMessageEnd()
921 
    self._oprot.trans.flush()
922 
 
923 
  def recv_userExists(self, ):
924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
925 
    if mtype == TMessageType.EXCEPTION:
926 
      x = TApplicationException()
927 
      x.read(self._iprot)
928 
      self._iprot.readMessageEnd()
929 
      raise x
930 
    result = userExists_result()
931 
    result.read(self._iprot)
932 
    self._iprot.readMessageEnd()
3431 rajveer 933 
    if result.success is not None:
94 ashish 934 
      return result.success
3431 rajveer 935 
    if result.ucx is not None:
94 ashish 936 
      raise result.ucx
937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
938 
 
567 rajveer 939 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 940 
    """
941 
    Parameters:
942 
     - userId
943 
     - address
513 rajveer 944 
     - setDefault
94 ashish 945 
    """
567 rajveer 946 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 947 
    return self.recv_addAddressForUser()
948 
 
567 rajveer 949 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 950 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
951 
    args = addAddressForUser_args()
559 chandransh 952 
    args.userId = userId
94 ashish 953 
    args.address = address
513 rajveer 954 
    args.setDefault = setDefault
94 ashish 955 
    args.write(self._oprot)
956 
    self._oprot.writeMessageEnd()
957 
    self._oprot.trans.flush()
958 
 
959 
  def recv_addAddressForUser(self, ):
960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
961 
    if mtype == TMessageType.EXCEPTION:
962 
      x = TApplicationException()
963 
      x.read(self._iprot)
964 
      self._iprot.readMessageEnd()
965 
      raise x
966 
    result = addAddressForUser_result()
967 
    result.read(self._iprot)
968 
    self._iprot.readMessageEnd()
3431 rajveer 969 
    if result.success is not None:
94 ashish 970 
      return result.success
3431 rajveer 971 
    if result.ucx is not None:
94 ashish 972 
      raise result.ucx
973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
974 
 
975 
  def removeAddressForUser(self, userid, addressId):
976 
    """
977 
    Parameters:
978 
     - userid
979 
     - addressId
980 
    """
981 
    self.send_removeAddressForUser(userid, addressId)
982 
    return self.recv_removeAddressForUser()
983 
 
984 
  def send_removeAddressForUser(self, userid, addressId):
985 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
986 
    args = removeAddressForUser_args()
987 
    args.userid = userid
988 
    args.addressId = addressId
989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
993 
  def recv_removeAddressForUser(self, ):
994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
1000 
    result = removeAddressForUser_result()
1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
3431 rajveer 1003 
    if result.success is not None:
94 ashish 1004 
      return result.success
3431 rajveer 1005 
    if result.ucx is not None:
94 ashish 1006 
      raise result.ucx
1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1008 
 
1009 
  def setUserAsLoggedIn(self, userId, timestamp):
1010 
    """
1011 
    Parameters:
1012 
     - userId
1013 
     - timestamp
1014 
    """
1015 
    self.send_setUserAsLoggedIn(userId, timestamp)
1016 
    return self.recv_setUserAsLoggedIn()
1017 
 
1018 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1019 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1020 
    args = setUserAsLoggedIn_args()
1021 
    args.userId = userId
1022 
    args.timestamp = timestamp
1023 
    args.write(self._oprot)
1024 
    self._oprot.writeMessageEnd()
1025 
    self._oprot.trans.flush()
1026 
 
1027 
  def recv_setUserAsLoggedIn(self, ):
1028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1029 
    if mtype == TMessageType.EXCEPTION:
1030 
      x = TApplicationException()
1031 
      x.read(self._iprot)
1032 
      self._iprot.readMessageEnd()
1033 
      raise x
1034 
    result = setUserAsLoggedIn_result()
1035 
    result.read(self._iprot)
1036 
    self._iprot.readMessageEnd()
3431 rajveer 1037 
    if result.success is not None:
94 ashish 1038 
      return result.success
3431 rajveer 1039 
    if result.ucx is not None:
94 ashish 1040 
      raise result.ucx
1041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1042 
 
1043 
  def setUserAsLoggedOut(self, userid, timestamp):
1044 
    """
1045 
    Parameters:
1046 
     - userid
1047 
     - timestamp
1048 
    """
1049 
    self.send_setUserAsLoggedOut(userid, timestamp)
1050 
    return self.recv_setUserAsLoggedOut()
1051 
 
1052 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1053 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1054 
    args = setUserAsLoggedOut_args()
1055 
    args.userid = userid
1056 
    args.timestamp = timestamp
1057 
    args.write(self._oprot)
1058 
    self._oprot.writeMessageEnd()
1059 
    self._oprot.trans.flush()
1060 
 
1061 
  def recv_setUserAsLoggedOut(self, ):
1062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1063 
    if mtype == TMessageType.EXCEPTION:
1064 
      x = TApplicationException()
1065 
      x.read(self._iprot)
1066 
      self._iprot.readMessageEnd()
1067 
      raise x
1068 
    result = setUserAsLoggedOut_result()
1069 
    result.read(self._iprot)
1070 
    self._iprot.readMessageEnd()
3431 rajveer 1071 
    if result.success is not None:
94 ashish 1072 
      return result.success
3431 rajveer 1073 
    if result.ucx is not None:
94 ashish 1074 
      raise result.ucx
1075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1076 
 
504 rajveer 1077 
  def setDefaultAddress(self, userid, addressId):
1078 
    """
1079 
    Parameters:
1080 
     - userid
1081 
     - addressId
1082 
    """
1083 
    self.send_setDefaultAddress(userid, addressId)
1084 
    return self.recv_setDefaultAddress()
1085 
 
1086 
  def send_setDefaultAddress(self, userid, addressId):
1087 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1088 
    args = setDefaultAddress_args()
1089 
    args.userid = userid
1090 
    args.addressId = addressId
1091 
    args.write(self._oprot)
1092 
    self._oprot.writeMessageEnd()
1093 
    self._oprot.trans.flush()
1094 
 
1095 
  def recv_setDefaultAddress(self, ):
1096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1097 
    if mtype == TMessageType.EXCEPTION:
1098 
      x = TApplicationException()
1099 
      x.read(self._iprot)
1100 
      self._iprot.readMessageEnd()
1101 
      raise x
1102 
    result = setDefaultAddress_result()
1103 
    result.read(self._iprot)
1104 
    self._iprot.readMessageEnd()
3431 rajveer 1105 
    if result.success is not None:
504 rajveer 1106 
      return result.success
3431 rajveer 1107 
    if result.ucx is not None:
504 rajveer 1108 
      raise result.ucx
1109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1110 
 
594 rajveer 1111 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1112 
    """
1113 
    Parameters:
1114 
     - userid
594 rajveer 1115 
     - oldPassword
1116 
     - newPassword
94 ashish 1117 
    """
594 rajveer 1118 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1119 
    return self.recv_updatePassword()
1120 
 
594 rajveer 1121 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1122 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1123 
    args = updatePassword_args()
1124 
    args.userid = userid
594 rajveer 1125 
    args.oldPassword = oldPassword
1126 
    args.newPassword = newPassword
94 ashish 1127 
    args.write(self._oprot)
1128 
    self._oprot.writeMessageEnd()
1129 
    self._oprot.trans.flush()
1130 
 
1131 
  def recv_updatePassword(self, ):
1132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1133 
    if mtype == TMessageType.EXCEPTION:
1134 
      x = TApplicationException()
1135 
      x.read(self._iprot)
1136 
      self._iprot.readMessageEnd()
1137 
      raise x
1138 
    result = updatePassword_result()
1139 
    result.read(self._iprot)
1140 
    self._iprot.readMessageEnd()
3431 rajveer 1141 
    if result.success is not None:
94 ashish 1142 
      return result.success
3431 rajveer 1143 
    if result.ucx is not None:
94 ashish 1144 
      raise result.ucx
1145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1146 
 
884 rajveer 1147 
  def forgotPassword(self, email, newPassword):
581 rajveer 1148 
    """
1149 
    Parameters:
1150 
     - email
884 rajveer 1151 
     - newPassword
581 rajveer 1152 
    """
884 rajveer 1153 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1154 
    return self.recv_forgotPassword()
1155 
 
884 rajveer 1156 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1157 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1158 
    args = forgotPassword_args()
1159 
    args.email = email
884 rajveer 1160 
    args.newPassword = newPassword
581 rajveer 1161 
    args.write(self._oprot)
1162 
    self._oprot.writeMessageEnd()
1163 
    self._oprot.trans.flush()
1164 
 
1165 
  def recv_forgotPassword(self, ):
1166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1167 
    if mtype == TMessageType.EXCEPTION:
1168 
      x = TApplicationException()
1169 
      x.read(self._iprot)
1170 
      self._iprot.readMessageEnd()
1171 
      raise x
1172 
    result = forgotPassword_result()
1173 
    result.read(self._iprot)
1174 
    self._iprot.readMessageEnd()
3431 rajveer 1175 
    if result.success is not None:
581 rajveer 1176 
      return result.success
3431 rajveer 1177 
    if result.ucx is not None:
581 rajveer 1178 
      raise result.ucx
1179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1180 
 
594 rajveer 1181 
  def getAllAddressesForUser(self, userId):
1182 
    """
1183 
    Parameters:
1184 
     - userId
1185 
    """
1186 
    self.send_getAllAddressesForUser(userId)
1187 
    return self.recv_getAllAddressesForUser()
1188 
 
1189 
  def send_getAllAddressesForUser(self, userId):
1190 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1191 
    args = getAllAddressesForUser_args()
1192 
    args.userId = userId
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_getAllAddressesForUser(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = getAllAddressesForUser_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
3431 rajveer 1207 
    if result.success is not None:
594 rajveer 1208 
      return result.success
3431 rajveer 1209 
    if result.ucx is not None:
594 rajveer 1210 
      raise result.ucx
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1212 
 
1894 vikas 1213 
  def getAddressById(self, addressId):
1214 
    """
1215 
    Parameters:
1216 
     - addressId
1217 
    """
1218 
    self.send_getAddressById(addressId)
1219 
    return self.recv_getAddressById()
1220 
 
1221 
  def send_getAddressById(self, addressId):
1222 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1223 
    args = getAddressById_args()
1224 
    args.addressId = addressId
1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_getAddressById(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = getAddressById_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
3431 rajveer 1239 
    if result.success is not None:
1894 vikas 1240 
      return result.success
3431 rajveer 1241 
    if result.ucx is not None:
1894 vikas 1242 
      raise result.ucx
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1244 
 
594 rajveer 1245 
  def getDefaultAddressId(self, userId):
1246 
    """
1247 
    Parameters:
1248 
     - userId
1249 
    """
1250 
    self.send_getDefaultAddressId(userId)
1251 
    return self.recv_getDefaultAddressId()
1252 
 
1253 
  def send_getDefaultAddressId(self, userId):
1254 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1255 
    args = getDefaultAddressId_args()
1256 
    args.userId = userId
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_getDefaultAddressId(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = getDefaultAddressId_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
3431 rajveer 1271 
    if result.success is not None:
594 rajveer 1272 
      return result.success
3431 rajveer 1273 
    if result.ucx is not None:
594 rajveer 1274 
      raise result.ucx
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1276 
 
785 rajveer 1277 
  def getDefaultPincode(self, userId):
1278 
    """
1279 
    Parameters:
1280 
     - userId
1281 
    """
1282 
    self.send_getDefaultPincode(userId)
1283 
    return self.recv_getDefaultPincode()
1284 
 
1285 
  def send_getDefaultPincode(self, userId):
1286 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1287 
    args = getDefaultPincode_args()
1288 
    args.userId = userId
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getDefaultPincode(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getDefaultPincode_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
3431 rajveer 1303 
    if result.success is not None:
785 rajveer 1304 
      return result.success
3431 rajveer 1305 
    if result.ucx is not None:
785 rajveer 1306 
      raise result.ucx
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1308 
 
1274 varun.gupt 1309 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1310 
    """
1311 
    Parameters:
1312 
     - userId
1313 
     - replyTo
1314 
     - communicationType
1315 
     - orderId
1316 
     - airwaybillNo
1317 
     - productName
1318 
     - subject
1319 
     - message
1320 
    """
1321 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1322 
    return self.recv_saveUserCommunication()
1323 
 
1324 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1325 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1326 
    args = saveUserCommunication_args()
1327 
    args.userId = userId
1328 
    args.replyTo = replyTo
1329 
    args.communicationType = communicationType
1330 
    args.orderId = orderId
1331 
    args.airwaybillNo = airwaybillNo
1332 
    args.productName = productName
1333 
    args.subject = subject
1334 
    args.message = message
1335 
    args.write(self._oprot)
1336 
    self._oprot.writeMessageEnd()
1337 
    self._oprot.trans.flush()
1338 
 
1339 
  def recv_saveUserCommunication(self, ):
1340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1341 
    if mtype == TMessageType.EXCEPTION:
1342 
      x = TApplicationException()
1343 
      x.read(self._iprot)
1344 
      self._iprot.readMessageEnd()
1345 
      raise x
1346 
    result = saveUserCommunication_result()
1347 
    result.read(self._iprot)
1348 
    self._iprot.readMessageEnd()
3431 rajveer 1349 
    if result.success is not None:
1274 varun.gupt 1350 
      return result.success
3431 rajveer 1351 
    if result.ucx is not None:
1274 varun.gupt 1352 
      raise result.ucx
1353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1354 
 
1590 varun.gupt 1355 
  def getUserCommunicationById(self, id):
1356 
    """
1357 
    Parameters:
1358 
     - id
1359 
    """
1360 
    self.send_getUserCommunicationById(id)
1361 
    return self.recv_getUserCommunicationById()
1362 
 
1363 
  def send_getUserCommunicationById(self, id):
1364 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1365 
    args = getUserCommunicationById_args()
1366 
    args.id = id
1367 
    args.write(self._oprot)
1368 
    self._oprot.writeMessageEnd()
1369 
    self._oprot.trans.flush()
1370 
 
1371 
  def recv_getUserCommunicationById(self, ):
1372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1373 
    if mtype == TMessageType.EXCEPTION:
1374 
      x = TApplicationException()
1375 
      x.read(self._iprot)
1376 
      self._iprot.readMessageEnd()
1377 
      raise x
1378 
    result = getUserCommunicationById_result()
1379 
    result.read(self._iprot)
1380 
    self._iprot.readMessageEnd()
3431 rajveer 1381 
    if result.success is not None:
1590 varun.gupt 1382 
      return result.success
3431 rajveer 1383 
    if result.ucx is not None:
1590 varun.gupt 1384 
      raise result.ucx
1385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1386 
 
1387 
  def getUserCommunicationByUser(self, userId):
1388 
    """
1389 
    Parameters:
1390 
     - userId
1391 
    """
1392 
    self.send_getUserCommunicationByUser(userId)
1393 
    return self.recv_getUserCommunicationByUser()
1394 
 
1395 
  def send_getUserCommunicationByUser(self, userId):
1396 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1397 
    args = getUserCommunicationByUser_args()
1398 
    args.userId = userId
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_getUserCommunicationByUser(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = getUserCommunicationByUser_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
1590 varun.gupt 1414 
      return result.success
3431 rajveer 1415 
    if result.ucx is not None:
1590 varun.gupt 1416 
      raise result.ucx
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1418 
 
1419 
  def getAllUserCommunications(self, ):
1420 
    self.send_getAllUserCommunications()
1421 
    return self.recv_getAllUserCommunications()
1422 
 
1423 
  def send_getAllUserCommunications(self, ):
1424 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1425 
    args = getAllUserCommunications_args()
1426 
    args.write(self._oprot)
1427 
    self._oprot.writeMessageEnd()
1428 
    self._oprot.trans.flush()
1429 
 
1430 
  def recv_getAllUserCommunications(self, ):
1431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1432 
    if mtype == TMessageType.EXCEPTION:
1433 
      x = TApplicationException()
1434 
      x.read(self._iprot)
1435 
      self._iprot.readMessageEnd()
1436 
      raise x
1437 
    result = getAllUserCommunications_result()
1438 
    result.read(self._iprot)
1439 
    self._iprot.readMessageEnd()
3431 rajveer 1440 
    if result.success is not None:
1590 varun.gupt 1441 
      return result.success
3431 rajveer 1442 
    if result.ucx is not None:
1590 varun.gupt 1443 
      raise result.ucx
1444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1445 
 
5407 amar.kumar 1446 
  def removeUserCommunication(self, id):
1447 
    """
1448 
    Parameters:
1449 
     - id
1450 
    """
1451 
    self.send_removeUserCommunication(id)
1452 
    self.recv_removeUserCommunication()
1453 
 
1454 
  def send_removeUserCommunication(self, id):
1455 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1456 
    args = removeUserCommunication_args()
1457 
    args.id = id
1458 
    args.write(self._oprot)
1459 
    self._oprot.writeMessageEnd()
1460 
    self._oprot.trans.flush()
1461 
 
1462 
  def recv_removeUserCommunication(self, ):
1463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1464 
    if mtype == TMessageType.EXCEPTION:
1465 
      x = TApplicationException()
1466 
      x.read(self._iprot)
1467 
      self._iprot.readMessageEnd()
1468 
      raise x
1469 
    result = removeUserCommunication_result()
1470 
    result.read(self._iprot)
1471 
    self._iprot.readMessageEnd()
1472 
    if result.ucx is not None:
1473 
      raise result.ucx
1474 
    return
1475 
 
1859 vikas 1476 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1477 
    """
1478 
    Parameters:
1479 
     - name
1859 vikas 1480 
     - addedOn
1845 vikas 1481 
    """
1859 vikas 1482 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1483 
    return self.recv_createMasterAffiliate()
1484 
 
1859 vikas 1485 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1486 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1487 
    args = createMasterAffiliate_args()
1488 
    args.name = name
1859 vikas 1489 
    args.addedOn = addedOn
1845 vikas 1490 
    args.write(self._oprot)
1491 
    self._oprot.writeMessageEnd()
1492 
    self._oprot.trans.flush()
1493 
 
1494 
  def recv_createMasterAffiliate(self, ):
1495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1496 
    if mtype == TMessageType.EXCEPTION:
1497 
      x = TApplicationException()
1498 
      x.read(self._iprot)
1499 
      self._iprot.readMessageEnd()
1500 
      raise x
1501 
    result = createMasterAffiliate_result()
1502 
    result.read(self._iprot)
1503 
    self._iprot.readMessageEnd()
3431 rajveer 1504 
    if result.success is not None:
1845 vikas 1505 
      return result.success
3431 rajveer 1506 
    if result.utx is not None:
1845 vikas 1507 
      raise result.utx
1508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1509 
 
1899 vikas 1510 
  def getAllMasterAffiliates(self, ):
1511 
    self.send_getAllMasterAffiliates()
1512 
    return self.recv_getAllMasterAffiliates()
1513 
 
1514 
  def send_getAllMasterAffiliates(self, ):
1515 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1516 
    args = getAllMasterAffiliates_args()
1517 
    args.write(self._oprot)
1518 
    self._oprot.writeMessageEnd()
1519 
    self._oprot.trans.flush()
1520 
 
1521 
  def recv_getAllMasterAffiliates(self, ):
1522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1523 
    if mtype == TMessageType.EXCEPTION:
1524 
      x = TApplicationException()
1525 
      x.read(self._iprot)
1526 
      self._iprot.readMessageEnd()
1527 
      raise x
1528 
    result = getAllMasterAffiliates_result()
1529 
    result.read(self._iprot)
1530 
    self._iprot.readMessageEnd()
3431 rajveer 1531 
    if result.success is not None:
1899 vikas 1532 
      return result.success
3431 rajveer 1533 
    if result.utx is not None:
1899 vikas 1534 
      raise result.utx
1535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1536 
 
1845 vikas 1537 
  def getMasterAffiliateById(self, id):
1538 
    """
1539 
    Parameters:
1540 
     - id
1541 
    """
1542 
    self.send_getMasterAffiliateById(id)
1543 
    return self.recv_getMasterAffiliateById()
1544 
 
1545 
  def send_getMasterAffiliateById(self, id):
1546 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1547 
    args = getMasterAffiliateById_args()
1548 
    args.id = id
1549 
    args.write(self._oprot)
1550 
    self._oprot.writeMessageEnd()
1551 
    self._oprot.trans.flush()
1552 
 
1553 
  def recv_getMasterAffiliateById(self, ):
1554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1555 
    if mtype == TMessageType.EXCEPTION:
1556 
      x = TApplicationException()
1557 
      x.read(self._iprot)
1558 
      self._iprot.readMessageEnd()
1559 
      raise x
1560 
    result = getMasterAffiliateById_result()
1561 
    result.read(self._iprot)
1562 
    self._iprot.readMessageEnd()
3431 rajveer 1563 
    if result.success is not None:
1845 vikas 1564 
      return result.success
3431 rajveer 1565 
    if result.utx is not None:
1845 vikas 1566 
      raise result.utx
1567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1568 
 
1569 
  def getMasterAffiliateByName(self, name):
1570 
    """
1571 
    Parameters:
1572 
     - name
1573 
    """
1574 
    self.send_getMasterAffiliateByName(name)
1575 
    return self.recv_getMasterAffiliateByName()
1576 
 
1577 
  def send_getMasterAffiliateByName(self, name):
1578 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1579 
    args = getMasterAffiliateByName_args()
1580 
    args.name = name
1581 
    args.write(self._oprot)
1582 
    self._oprot.writeMessageEnd()
1583 
    self._oprot.trans.flush()
1584 
 
1585 
  def recv_getMasterAffiliateByName(self, ):
1586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1587 
    if mtype == TMessageType.EXCEPTION:
1588 
      x = TApplicationException()
1589 
      x.read(self._iprot)
1590 
      self._iprot.readMessageEnd()
1591 
      raise x
1592 
    result = getMasterAffiliateByName_result()
1593 
    result.read(self._iprot)
1594 
    self._iprot.readMessageEnd()
3431 rajveer 1595 
    if result.success is not None:
1845 vikas 1596 
      return result.success
3431 rajveer 1597 
    if result.utx is not None:
1845 vikas 1598 
      raise result.utx
1599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1600 
 
1859 vikas 1601 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1602 
    """
1603 
    Parameters:
1604 
     - name
1605 
     - url
1606 
     - masterAffiliateId
1859 vikas 1607 
     - addedOn
1845 vikas 1608 
    """
1859 vikas 1609 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1610 
    return self.recv_createAffiliate()
1611 
 
1859 vikas 1612 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1613 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1614 
    args = createAffiliate_args()
1615 
    args.name = name
1616 
    args.url = url
1617 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1618 
    args.addedOn = addedOn
1845 vikas 1619 
    args.write(self._oprot)
1620 
    self._oprot.writeMessageEnd()
1621 
    self._oprot.trans.flush()
1622 
 
1623 
  def recv_createAffiliate(self, ):
1624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1625 
    if mtype == TMessageType.EXCEPTION:
1626 
      x = TApplicationException()
1627 
      x.read(self._iprot)
1628 
      self._iprot.readMessageEnd()
1629 
      raise x
1630 
    result = createAffiliate_result()
1631 
    result.read(self._iprot)
1632 
    self._iprot.readMessageEnd()
3431 rajveer 1633 
    if result.success is not None:
1845 vikas 1634 
      return result.success
3431 rajveer 1635 
    if result.utx is not None:
1845 vikas 1636 
      raise result.utx
1637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1638 
 
1639 
  def getAffiliateById(self, id):
1640 
    """
1641 
    Parameters:
1642 
     - id
1643 
    """
1644 
    self.send_getAffiliateById(id)
1645 
    return self.recv_getAffiliateById()
1646 
 
1647 
  def send_getAffiliateById(self, id):
1648 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1649 
    args = getAffiliateById_args()
1650 
    args.id = id
1651 
    args.write(self._oprot)
1652 
    self._oprot.writeMessageEnd()
1653 
    self._oprot.trans.flush()
1654 
 
1655 
  def recv_getAffiliateById(self, ):
1656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1657 
    if mtype == TMessageType.EXCEPTION:
1658 
      x = TApplicationException()
1659 
      x.read(self._iprot)
1660 
      self._iprot.readMessageEnd()
1661 
      raise x
1662 
    result = getAffiliateById_result()
1663 
    result.read(self._iprot)
1664 
    self._iprot.readMessageEnd()
3431 rajveer 1665 
    if result.success is not None:
1845 vikas 1666 
      return result.success
3431 rajveer 1667 
    if result.utx is not None:
1845 vikas 1668 
      raise result.utx
1669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1670 
 
1671 
  def getAffiliateByName(self, name):
1672 
    """
1673 
    Parameters:
1674 
     - name
1675 
    """
1676 
    self.send_getAffiliateByName(name)
1677 
    return self.recv_getAffiliateByName()
1678 
 
1679 
  def send_getAffiliateByName(self, name):
1680 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1681 
    args = getAffiliateByName_args()
1682 
    args.name = name
1683 
    args.write(self._oprot)
1684 
    self._oprot.writeMessageEnd()
1685 
    self._oprot.trans.flush()
1686 
 
1687 
  def recv_getAffiliateByName(self, ):
1688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1689 
    if mtype == TMessageType.EXCEPTION:
1690 
      x = TApplicationException()
1691 
      x.read(self._iprot)
1692 
      self._iprot.readMessageEnd()
1693 
      raise x
1694 
    result = getAffiliateByName_result()
1695 
    result.read(self._iprot)
1696 
    self._iprot.readMessageEnd()
3431 rajveer 1697 
    if result.success is not None:
1845 vikas 1698 
      return result.success
3431 rajveer 1699 
    if result.utx is not None:
1845 vikas 1700 
      raise result.utx
1701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1702 
 
1996 vikas 1703 
  def getTrackerById(self, id):
1845 vikas 1704 
    """
1705 
    Parameters:
1706 
     - id
1707 
    """
1996 vikas 1708 
    self.send_getTrackerById(id)
1845 vikas 1709 
    return self.recv_getTrackerById()
1710 
 
1996 vikas 1711 
  def send_getTrackerById(self, id):
1845 vikas 1712 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1713 
    args = getTrackerById_args()
1996 vikas 1714 
    args.id = id
1845 vikas 1715 
    args.write(self._oprot)
1716 
    self._oprot.writeMessageEnd()
1717 
    self._oprot.trans.flush()
1718 
 
1719 
  def recv_getTrackerById(self, ):
1720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1721 
    if mtype == TMessageType.EXCEPTION:
1722 
      x = TApplicationException()
1723 
      x.read(self._iprot)
1724 
      self._iprot.readMessageEnd()
1725 
      raise x
1726 
    result = getTrackerById_result()
1727 
    result.read(self._iprot)
1728 
    self._iprot.readMessageEnd()
3431 rajveer 1729 
    if result.success is not None:
1845 vikas 1730 
      return result.success
3431 rajveer 1731 
    if result.utx is not None:
1845 vikas 1732 
      raise result.utx
1733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1734 
 
1996 vikas 1735 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1736 
    """
1737 
    Parameters:
1996 vikas 1738 
     - id
1845 vikas 1739 
    """
1996 vikas 1740 
    self.send_getAffiliatesByMasterAffiliate(id)
1741 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1742 
 
1996 vikas 1743 
  def send_getAffiliatesByMasterAffiliate(self, id):
1744 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1745 
    args = getAffiliatesByMasterAffiliate_args()
1746 
    args.id = id
1845 vikas 1747 
    args.write(self._oprot)
1748 
    self._oprot.writeMessageEnd()
1749 
    self._oprot.trans.flush()
1750 
 
1996 vikas 1751 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1753 
    if mtype == TMessageType.EXCEPTION:
1754 
      x = TApplicationException()
1755 
      x.read(self._iprot)
1756 
      self._iprot.readMessageEnd()
1757 
      raise x
1996 vikas 1758 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1759 
    result.read(self._iprot)
1760 
    self._iprot.readMessageEnd()
3431 rajveer 1761 
    if result.success is not None:
1845 vikas 1762 
      return result.success
3431 rajveer 1763 
    if result.utx is not None:
1845 vikas 1764 
      raise result.utx
1996 vikas 1765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1766 
 
1996 vikas 1767 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1768 
    """
1769 
    Parameters:
1996 vikas 1770 
     - affiliateId
1845 vikas 1771 
     - userId
1772 
     - event
1773 
     - url
1774 
     - data
1859 vikas 1775 
     - addedOn
1845 vikas 1776 
    """
1996 vikas 1777 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1778 
    return self.recv_addTrackLog()
1779 
 
1996 vikas 1780 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1781 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1782 
    args = addTrackLog_args()
1996 vikas 1783 
    args.affiliateId = affiliateId
1845 vikas 1784 
    args.userId = userId
1785 
    args.event = event
1786 
    args.url = url
1787 
    args.data = data
1859 vikas 1788 
    args.addedOn = addedOn
1845 vikas 1789 
    args.write(self._oprot)
1790 
    self._oprot.writeMessageEnd()
1791 
    self._oprot.trans.flush()
1792 
 
1793 
  def recv_addTrackLog(self, ):
1794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1795 
    if mtype == TMessageType.EXCEPTION:
1796 
      x = TApplicationException()
1797 
      x.read(self._iprot)
1798 
      self._iprot.readMessageEnd()
1799 
      raise x
1800 
    result = addTrackLog_result()
1801 
    result.read(self._iprot)
1802 
    self._iprot.readMessageEnd()
3431 rajveer 1803 
    if result.success is not None:
1845 vikas 1804 
      return result.success
3431 rajveer 1805 
    if result.utx is not None:
1845 vikas 1806 
      raise result.utx
1807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1808 
 
1809 
  def getTrackLogById(self, id):
1810 
    """
1811 
    Parameters:
1812 
     - id
1813 
    """
1814 
    self.send_getTrackLogById(id)
1815 
    return self.recv_getTrackLogById()
1816 
 
1817 
  def send_getTrackLogById(self, id):
1818 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1819 
    args = getTrackLogById_args()
1820 
    args.id = id
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_getTrackLogById(self, ):
1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
1832 
    result = getTrackLogById_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
3431 rajveer 1835 
    if result.success is not None:
1845 vikas 1836 
      return result.success
3431 rajveer 1837 
    if result.utx is not None:
1845 vikas 1838 
      raise result.utx
1839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1840 
 
3293 vikas 1841 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1842 
    """
1843 
    Parameters:
1996 vikas 1844 
     - affiliateId
3293 vikas 1845 
     - startDate
1846 
     - endDate
1845 vikas 1847 
    """
3293 vikas 1848 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1849 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1850 
 
3293 vikas 1851 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1852 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1853 
    args = getTrackLogsByAffiliate_args()
1854 
    args.affiliateId = affiliateId
3293 vikas 1855 
    args.startDate = startDate
1856 
    args.endDate = endDate
1845 vikas 1857 
    args.write(self._oprot)
1858 
    self._oprot.writeMessageEnd()
1859 
    self._oprot.trans.flush()
1860 
 
1996 vikas 1861 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1863 
    if mtype == TMessageType.EXCEPTION:
1864 
      x = TApplicationException()
1865 
      x.read(self._iprot)
1866 
      self._iprot.readMessageEnd()
1867 
      raise x
1996 vikas 1868 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1869 
    result.read(self._iprot)
1870 
    self._iprot.readMessageEnd()
3431 rajveer 1871 
    if result.success is not None:
1845 vikas 1872 
      return result.success
3431 rajveer 1873 
    if result.utx is not None:
1845 vikas 1874 
      raise result.utx
1996 vikas 1875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1876 
 
1877 
  def getTrackLogsByUser(self, userId):
1878 
    """
1879 
    Parameters:
1880 
     - userId
1881 
    """
1882 
    self.send_getTrackLogsByUser(userId)
1883 
    return self.recv_getTrackLogsByUser()
1884 
 
1885 
  def send_getTrackLogsByUser(self, userId):
1886 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1887 
    args = getTrackLogsByUser_args()
1888 
    args.userId = userId
1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
1893 
  def recv_getTrackLogsByUser(self, ):
1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
1900 
    result = getTrackLogsByUser_result()
1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
3431 rajveer 1903 
    if result.success is not None:
1845 vikas 1904 
      return result.success
3431 rajveer 1905 
    if result.utx is not None:
1845 vikas 1906 
      raise result.utx
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1908 
 
1996 vikas 1909 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1910 
    """
1911 
    Parameters:
1912 
     - userId
1913 
     - event
1914 
     - url
1915 
    """
1996 vikas 1916 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1917 
    return self.recv_getTrackLogs()
1918 
 
1996 vikas 1919 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1920 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1921 
    args = getTrackLogs_args()
1922 
    args.userId = userId
1923 
    args.event = event
1924 
    args.url = url
1925 
    args.write(self._oprot)
1926 
    self._oprot.writeMessageEnd()
1927 
    self._oprot.trans.flush()
1928 
 
1929 
  def recv_getTrackLogs(self, ):
1930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1931 
    if mtype == TMessageType.EXCEPTION:
1932 
      x = TApplicationException()
1933 
      x.read(self._iprot)
1934 
      self._iprot.readMessageEnd()
1935 
      raise x
1936 
    result = getTrackLogs_result()
1937 
    result.read(self._iprot)
1938 
    self._iprot.readMessageEnd()
3431 rajveer 1939 
    if result.success is not None:
1845 vikas 1940 
      return result.success
3431 rajveer 1941 
    if result.utx is not None:
1845 vikas 1942 
      raise result.utx
1943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1944 
 
559 chandransh 1945 
  def getCurrentCart(self, userId):
94 ashish 1946 
    """
1947 
    Parameters:
559 chandransh 1948 
     - userId
94 ashish 1949 
    """
559 chandransh 1950 
    self.send_getCurrentCart(userId)
1951 
    return self.recv_getCurrentCart()
94 ashish 1952 
 
559 chandransh 1953 
  def send_getCurrentCart(self, userId):
1954 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1955 
    args = getCurrentCart_args()
1956 
    args.userId = userId
94 ashish 1957 
    args.write(self._oprot)
1958 
    self._oprot.writeMessageEnd()
1959 
    self._oprot.trans.flush()
1960 
 
559 chandransh 1961 
  def recv_getCurrentCart(self, ):
94 ashish 1962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1963 
    if mtype == TMessageType.EXCEPTION:
1964 
      x = TApplicationException()
1965 
      x.read(self._iprot)
1966 
      self._iprot.readMessageEnd()
1967 
      raise x
559 chandransh 1968 
    result = getCurrentCart_result()
94 ashish 1969 
    result.read(self._iprot)
1970 
    self._iprot.readMessageEnd()
3431 rajveer 1971 
    if result.success is not None:
94 ashish 1972 
      return result.success
3431 rajveer 1973 
    if result.scx is not None:
559 chandransh 1974 
      raise result.scx
1975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1976 
 
559 chandransh 1977 
  def getCart(self, cartId):
94 ashish 1978 
    """
1979 
    Parameters:
559 chandransh 1980 
     - cartId
94 ashish 1981 
    """
559 chandransh 1982 
    self.send_getCart(cartId)
1983 
    return self.recv_getCart()
94 ashish 1984 
 
559 chandransh 1985 
  def send_getCart(self, cartId):
1986 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1987 
    args = getCart_args()
1988 
    args.cartId = cartId
94 ashish 1989 
    args.write(self._oprot)
1990 
    self._oprot.writeMessageEnd()
1991 
    self._oprot.trans.flush()
1992 
 
559 chandransh 1993 
  def recv_getCart(self, ):
94 ashish 1994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1995 
    if mtype == TMessageType.EXCEPTION:
1996 
      x = TApplicationException()
1997 
      x.read(self._iprot)
1998 
      self._iprot.readMessageEnd()
1999 
      raise x
559 chandransh 2000 
    result = getCart_result()
94 ashish 2001 
    result.read(self._iprot)
2002 
    self._iprot.readMessageEnd()
3431 rajveer 2003 
    if result.success is not None:
94 ashish 2004 
      return result.success
3431 rajveer 2005 
    if result.scx is not None:
559 chandransh 2006 
      raise result.scx
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2008 
 
559 chandransh 2009 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2010 
    """
2011 
    Parameters:
559 chandransh 2012 
     - from_time
2013 
     - to_time
2014 
     - status
94 ashish 2015 
    """
559 chandransh 2016 
    self.send_getCartsByTime(from_time, to_time, status)
2017 
    return self.recv_getCartsByTime()
94 ashish 2018 
 
559 chandransh 2019 
  def send_getCartsByTime(self, from_time, to_time, status):
2020 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2021 
    args = getCartsByTime_args()
2022 
    args.from_time = from_time
2023 
    args.to_time = to_time
2024 
    args.status = status
94 ashish 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
559 chandransh 2029 
  def recv_getCartsByTime(self, ):
94 ashish 2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
559 chandransh 2036 
    result = getCartsByTime_result()
94 ashish 2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
94 ashish 2040 
      return result.success
3431 rajveer 2041 
    if result.scx is not None:
559 chandransh 2042 
      raise result.scx
2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2044 
 
3557 rajveer 2045 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2046 
    """
2047 
    Parameters:
2048 
     - cartId
2049 
     - itemId
2050 
     - quantity
3557 rajveer 2051 
     - sourceId
559 chandransh 2052 
    """
3557 rajveer 2053 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2054 
    return self.recv_addItemToCart()
559 chandransh 2055 
 
3557 rajveer 2056 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2057 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2058 
    args = addItemToCart_args()
2059 
    args.cartId = cartId
2060 
    args.itemId = itemId
2061 
    args.quantity = quantity
3557 rajveer 2062 
    args.sourceId = sourceId
559 chandransh 2063 
    args.write(self._oprot)
2064 
    self._oprot.writeMessageEnd()
2065 
    self._oprot.trans.flush()
2066 
 
2067 
  def recv_addItemToCart(self, ):
2068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2069 
    if mtype == TMessageType.EXCEPTION:
2070 
      x = TApplicationException()
2071 
      x.read(self._iprot)
2072 
      self._iprot.readMessageEnd()
2073 
      raise x
2074 
    result = addItemToCart_result()
2075 
    result.read(self._iprot)
2076 
    self._iprot.readMessageEnd()
3431 rajveer 2077 
    if result.success is not None:
2035 rajveer 2078 
      return result.success
3431 rajveer 2079 
    if result.scx is not None:
559 chandransh 2080 
      raise result.scx
2035 rajveer 2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2082 
 
2083 
  def deleteItemFromCart(self, cartId, itemId):
2084 
    """
2085 
    Parameters:
2086 
     - cartId
2087 
     - itemId
2088 
    """
2089 
    self.send_deleteItemFromCart(cartId, itemId)
2090 
    self.recv_deleteItemFromCart()
2091 
 
2092 
  def send_deleteItemFromCart(self, cartId, itemId):
2093 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2094 
    args = deleteItemFromCart_args()
2095 
    args.cartId = cartId
2096 
    args.itemId = itemId
2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
2101 
  def recv_deleteItemFromCart(self, ):
2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
2108 
    result = deleteItemFromCart_result()
2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
3431 rajveer 2111 
    if result.scx is not None:
559 chandransh 2112 
      raise result.scx
2113 
    return
2114 
 
2115 
  def addAddressToCart(self, cartId, addressId):
2116 
    """
2117 
    Parameters:
2118 
     - cartId
2119 
     - addressId
2120 
    """
2121 
    self.send_addAddressToCart(cartId, addressId)
2122 
    self.recv_addAddressToCart()
2123 
 
2124 
  def send_addAddressToCart(self, cartId, addressId):
2125 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2126 
    args = addAddressToCart_args()
2127 
    args.cartId = cartId
2128 
    args.addressId = addressId
2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
2133 
  def recv_addAddressToCart(self, ):
2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
2140 
    result = addAddressToCart_result()
2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
3431 rajveer 2143 
    if result.scx is not None:
575 chandransh 2144 
      raise result.scx
559 chandransh 2145 
    return
2146 
 
5553 rajveer 2147 
  def addStoreToCart(self, cartId, storeId):
2148 
    """
2149 
    Parameters:
2150 
     - cartId
2151 
     - storeId
2152 
    """
2153 
    self.send_addStoreToCart(cartId, storeId)
2154 
    self.recv_addStoreToCart()
2155 
 
2156 
  def send_addStoreToCart(self, cartId, storeId):
2157 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2158 
    args = addStoreToCart_args()
2159 
    args.cartId = cartId
2160 
    args.storeId = storeId
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_addStoreToCart(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = addStoreToCart_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
2175 
    if result.scx is not None:
2176 
      raise result.scx
2177 
    return
2178 
 
6922 anupam.sin 2179 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2180 
    """
2181 
    Parameters:
6922 anupam.sin 2182 
     - cart
1976 varun.gupt 2183 
     - couponCode
2184 
    """
6922 anupam.sin 2185 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2186 
    self.recv_applyCouponToCart()
2187 
 
6922 anupam.sin 2188 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2189 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2190 
    args = applyCouponToCart_args()
6922 anupam.sin 2191 
    args.cart = cart
1976 varun.gupt 2192 
    args.couponCode = couponCode
2193 
    args.write(self._oprot)
2194 
    self._oprot.writeMessageEnd()
2195 
    self._oprot.trans.flush()
2196 
 
2197 
  def recv_applyCouponToCart(self, ):
2198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2199 
    if mtype == TMessageType.EXCEPTION:
2200 
      x = TApplicationException()
2201 
      x.read(self._iprot)
2202 
      self._iprot.readMessageEnd()
2203 
      raise x
2204 
    result = applyCouponToCart_result()
2205 
    result.read(self._iprot)
2206 
    self._iprot.readMessageEnd()
3431 rajveer 2207 
    if result.scx is not None:
1976 varun.gupt 2208 
      raise result.scx
2209 
    return
2210 
 
2211 
  def removeCoupon(self, cartId):
2212 
    """
2213 
    Parameters:
2214 
     - cartId
2215 
    """
2216 
    self.send_removeCoupon(cartId)
2217 
    self.recv_removeCoupon()
2218 
 
2219 
  def send_removeCoupon(self, cartId):
2220 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2221 
    args = removeCoupon_args()
2222 
    args.cartId = cartId
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_removeCoupon(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = removeCoupon_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.scx is not None:
1976 varun.gupt 2238 
      raise result.scx
2239 
    return
2240 
 
3554 varun.gupt 2241 
  def deleteDiscountsFromCart(self, cartId):
2242 
    """
2243 
    Deletes all the discounts associated with the cart
2244 
 
2245 
    Parameters:
2246 
     - cartId
2247 
    """
2248 
    self.send_deleteDiscountsFromCart(cartId)
2249 
    self.recv_deleteDiscountsFromCart()
2250 
 
2251 
  def send_deleteDiscountsFromCart(self, cartId):
2252 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2253 
    args = deleteDiscountsFromCart_args()
2254 
    args.cartId = cartId
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_deleteDiscountsFromCart(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = deleteDiscountsFromCart_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
2269 
    if result.scx is not None:
2270 
      raise result.scx
2271 
    return
2272 
 
2273 
  def saveDiscounts(self, discounts):
2274 
    """
2275 
    Accepts a list of thrift objects of Discount type and saves them
2276 
 
2277 
    Parameters:
2278 
     - discounts
2279 
    """
2280 
    self.send_saveDiscounts(discounts)
2281 
    self.recv_saveDiscounts()
2282 
 
2283 
  def send_saveDiscounts(self, discounts):
2284 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2285 
    args = saveDiscounts_args()
2286 
    args.discounts = discounts
2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_saveDiscounts(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = saveDiscounts_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
2301 
    if result.scx is not None:
2302 
      raise result.scx
2303 
    return
2304 
 
6389 rajveer 2305 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId):
559 chandransh 2306 
    """
690 chandransh 2307 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2308 
 
559 chandransh 2309 
    Parameters:
2310 
     - cartId
2815 vikas 2311 
     - sessionSource
2312 
     - sessionStartTime
3858 vikas 2313 
     - firstSource
2314 
     - firstSourceTime
5326 rajveer 2315 
     - userId
6389 rajveer 2316 
     - schemeId
559 chandransh 2317 
    """
6389 rajveer 2318 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId)
690 chandransh 2319 
    return self.recv_createOrders()
559 chandransh 2320 
 
6389 rajveer 2321 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId):
690 chandransh 2322 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2323 
    args = createOrders_args()
559 chandransh 2324 
    args.cartId = cartId
2815 vikas 2325 
    args.sessionSource = sessionSource
2326 
    args.sessionStartTime = sessionStartTime
3858 vikas 2327 
    args.firstSource = firstSource
2328 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2329 
    args.userId = userId
6389 rajveer 2330 
    args.schemeId = schemeId
559 chandransh 2331 
    args.write(self._oprot)
2332 
    self._oprot.writeMessageEnd()
2333 
    self._oprot.trans.flush()
2334 
 
690 chandransh 2335 
  def recv_createOrders(self, ):
559 chandransh 2336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2337 
    if mtype == TMessageType.EXCEPTION:
2338 
      x = TApplicationException()
2339 
      x.read(self._iprot)
2340 
      self._iprot.readMessageEnd()
2341 
      raise x
690 chandransh 2342 
    result = createOrders_result()
559 chandransh 2343 
    result.read(self._iprot)
2344 
    self._iprot.readMessageEnd()
3431 rajveer 2345 
    if result.success is not None:
130 ashish 2346 
      return result.success
3431 rajveer 2347 
    if result.scx is not None:
559 chandransh 2348 
      raise result.scx
690 chandransh 2349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2350 
 
3557 rajveer 2351 
  def validateCart(self, cartId, sourceId):
130 ashish 2352 
    """
690 chandransh 2353 
    Validates that:
2354 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2355 
    2. All of the lines in the cart are active items.
690 chandransh 2356 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2357 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2358 
 
130 ashish 2359 
    Parameters:
559 chandransh 2360 
     - cartId
3557 rajveer 2361 
     - sourceId
130 ashish 2362 
    """
3557 rajveer 2363 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2364 
    return self.recv_validateCart()
130 ashish 2365 
 
3557 rajveer 2366 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2367 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2368 
    args = validateCart_args()
2369 
    args.cartId = cartId
3557 rajveer 2370 
    args.sourceId = sourceId
130 ashish 2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
559 chandransh 2375 
  def recv_validateCart(self, ):
130 ashish 2376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2377 
    if mtype == TMessageType.EXCEPTION:
2378 
      x = TApplicationException()
2379 
      x.read(self._iprot)
2380 
      self._iprot.readMessageEnd()
2381 
      raise x
559 chandransh 2382 
    result = validateCart_result()
130 ashish 2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
3431 rajveer 2385 
    if result.success is not None:
130 ashish 2386 
      return result.success
3431 rajveer 2387 
    if result.scex is not None:
575 chandransh 2388 
      raise result.scex
559 chandransh 2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2390 
 
690 chandransh 2391 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2392 
    """
690 chandransh 2393 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2394 
 
575 chandransh 2395 
    Parameters:
690 chandransh 2396 
     - fromCartId
2397 
     - toCartId
2398 
    """
2399 
    self.send_mergeCart(fromCartId, toCartId)
2400 
    self.recv_mergeCart()
2401 
 
2402 
  def send_mergeCart(self, fromCartId, toCartId):
2403 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2404 
    args = mergeCart_args()
2405 
    args.fromCartId = fromCartId
2406 
    args.toCartId = toCartId
2407 
    args.write(self._oprot)
2408 
    self._oprot.writeMessageEnd()
2409 
    self._oprot.trans.flush()
2410 
 
2411 
  def recv_mergeCart(self, ):
2412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2413 
    if mtype == TMessageType.EXCEPTION:
2414 
      x = TApplicationException()
2415 
      x.read(self._iprot)
2416 
      self._iprot.readMessageEnd()
2417 
      raise x
2418 
    result = mergeCart_result()
2419 
    result.read(self._iprot)
2420 
    self._iprot.readMessageEnd()
2421 
    return
2422 
 
2423 
  def checkOut(self, cartId):
2424 
    """
2425 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2426 
 
690 chandransh 2427 
    Parameters:
575 chandransh 2428 
     - cartId
2429 
    """
690 chandransh 2430 
    self.send_checkOut(cartId)
2431 
    return self.recv_checkOut()
575 chandransh 2432 
 
690 chandransh 2433 
  def send_checkOut(self, cartId):
2434 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2435 
    args = checkOut_args()
575 chandransh 2436 
    args.cartId = cartId
2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
690 chandransh 2441 
  def recv_checkOut(self, ):
575 chandransh 2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
690 chandransh 2448 
    result = checkOut_result()
575 chandransh 2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
3431 rajveer 2451 
    if result.success is not None:
575 chandransh 2452 
      return result.success
3431 rajveer 2453 
    if result.scex is not None:
575 chandransh 2454 
      raise result.scex
690 chandransh 2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2456 
 
690 chandransh 2457 
  def resetCart(self, cartId, items):
559 chandransh 2458 
    """
690 chandransh 2459 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2460 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2461 
 
559 chandransh 2462 
    Parameters:
690 chandransh 2463 
     - cartId
2464 
     - items
559 chandransh 2465 
    """
690 chandransh 2466 
    self.send_resetCart(cartId, items)
2467 
    return self.recv_resetCart()
130 ashish 2468 
 
690 chandransh 2469 
  def send_resetCart(self, cartId, items):
2470 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2471 
    args = resetCart_args()
2472 
    args.cartId = cartId
2473 
    args.items = items
559 chandransh 2474 
    args.write(self._oprot)
2475 
    self._oprot.writeMessageEnd()
2476 
    self._oprot.trans.flush()
2477 
 
690 chandransh 2478 
  def recv_resetCart(self, ):
559 chandransh 2479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2480 
    if mtype == TMessageType.EXCEPTION:
2481 
      x = TApplicationException()
2482 
      x.read(self._iprot)
2483 
      self._iprot.readMessageEnd()
2484 
      raise x
690 chandransh 2485 
    result = resetCart_result()
559 chandransh 2486 
    result.read(self._iprot)
2487 
    self._iprot.readMessageEnd()
3431 rajveer 2488 
    if result.success is not None:
690 chandransh 2489 
      return result.success
3431 rajveer 2490 
    if result.scex is not None:
690 chandransh 2491 
      raise result.scex
2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2493 
 
2981 rajveer 2494 
  def getUserCount(self, userType):
559 chandransh 2495 
    """
2981 rajveer 2496 
    Returns number of registered users.
2497 
    If userType = null, then it returns count of all users, including anonymous
2498 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2499 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2500 
 
559 chandransh 2501 
    Parameters:
2981 rajveer 2502 
     - userType
559 chandransh 2503 
    """
2981 rajveer 2504 
    self.send_getUserCount(userType)
2505 
    return self.recv_getUserCount()
559 chandransh 2506 
 
2981 rajveer 2507 
  def send_getUserCount(self, userType):
2508 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2509 
    args = getUserCount_args()
2510 
    args.userType = userType
559 chandransh 2511 
    args.write(self._oprot)
2512 
    self._oprot.writeMessageEnd()
2513 
    self._oprot.trans.flush()
2514 
 
2981 rajveer 2515 
  def recv_getUserCount(self, ):
559 chandransh 2516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2517 
    if mtype == TMessageType.EXCEPTION:
2518 
      x = TApplicationException()
2519 
      x.read(self._iprot)
2520 
      self._iprot.readMessageEnd()
2521 
      raise x
2981 rajveer 2522 
    result = getUserCount_result()
559 chandransh 2523 
    result.read(self._iprot)
2524 
    self._iprot.readMessageEnd()
3431 rajveer 2525 
    if result.success is not None:
559 chandransh 2526 
      return result.success
2981 rajveer 2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2528 
 
2981 rajveer 2529 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2530 
    """
2981 rajveer 2531 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2532 
    If any of startDate or endDate is -1, then that filter is ignored.
2533 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2534 
 
2535 
 
559 chandransh 2536 
    Parameters:
2981 rajveer 2537 
     - userType
2538 
     - startDate
2539 
     - endDate
559 chandransh 2540 
    """
2981 rajveer 2541 
    self.send_getAllUsers(userType, startDate, endDate)
2542 
    return self.recv_getAllUsers()
559 chandransh 2543 
 
2981 rajveer 2544 
  def send_getAllUsers(self, userType, startDate, endDate):
2545 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2546 
    args = getAllUsers_args()
2547 
    args.userType = userType
2548 
    args.startDate = startDate
2549 
    args.endDate = endDate
559 chandransh 2550 
    args.write(self._oprot)
2551 
    self._oprot.writeMessageEnd()
2552 
    self._oprot.trans.flush()
2553 
 
2981 rajveer 2554 
  def recv_getAllUsers(self, ):
559 chandransh 2555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2556 
    if mtype == TMessageType.EXCEPTION:
2557 
      x = TApplicationException()
2558 
      x.read(self._iprot)
2559 
      self._iprot.readMessageEnd()
2560 
      raise x
2981 rajveer 2561 
    result = getAllUsers_result()
559 chandransh 2562 
    result.read(self._iprot)
2563 
    self._iprot.readMessageEnd()
3431 rajveer 2564 
    if result.success is not None:
559 chandransh 2565 
      return result.success
2981 rajveer 2566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2567 
 
2981 rajveer 2568 
  def getMyResearchItems(self, userId):
559 chandransh 2569 
    """
2981 rajveer 2570 
    Returns list of item ids in myresearch for the user
3431 rajveer 2571 
 
559 chandransh 2572 
    Parameters:
772 rajveer 2573 
     - userId
559 chandransh 2574 
    """
2981 rajveer 2575 
    self.send_getMyResearchItems(userId)
2576 
    return self.recv_getMyResearchItems()
559 chandransh 2577 
 
2981 rajveer 2578 
  def send_getMyResearchItems(self, userId):
2579 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2580 
    args = getMyResearchItems_args()
772 rajveer 2581 
    args.userId = userId
559 chandransh 2582 
    args.write(self._oprot)
2583 
    self._oprot.writeMessageEnd()
2584 
    self._oprot.trans.flush()
2585 
 
2981 rajveer 2586 
  def recv_getMyResearchItems(self, ):
559 chandransh 2587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2588 
    if mtype == TMessageType.EXCEPTION:
2589 
      x = TApplicationException()
2590 
      x.read(self._iprot)
2591 
      self._iprot.readMessageEnd()
2592 
      raise x
2981 rajveer 2593 
    result = getMyResearchItems_result()
559 chandransh 2594 
    result.read(self._iprot)
2595 
    self._iprot.readMessageEnd()
3431 rajveer 2596 
    if result.success is not None:
559 chandransh 2597 
      return result.success
3431 rajveer 2598 
    if result.scx is not None:
559 chandransh 2599 
      raise result.scx
2981 rajveer 2600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2601 
 
2981 rajveer 2602 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2603 
    """
2981 rajveer 2604 
    add item to my research for a user
3431 rajveer 2605 
 
559 chandransh 2606 
    Parameters:
2981 rajveer 2607 
     - userId
2608 
     - itemId
559 chandransh 2609 
    """
2981 rajveer 2610 
    self.send_updateMyResearch(userId, itemId)
2611 
    return self.recv_updateMyResearch()
559 chandransh 2612 
 
2981 rajveer 2613 
  def send_updateMyResearch(self, userId, itemId):
2614 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2615 
    args = updateMyResearch_args()
2616 
    args.userId = userId
2617 
    args.itemId = itemId
559 chandransh 2618 
    args.write(self._oprot)
2619 
    self._oprot.writeMessageEnd()
2620 
    self._oprot.trans.flush()
2621 
 
2981 rajveer 2622 
  def recv_updateMyResearch(self, ):
559 chandransh 2623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2624 
    if mtype == TMessageType.EXCEPTION:
2625 
      x = TApplicationException()
2626 
      x.read(self._iprot)
2627 
      self._iprot.readMessageEnd()
2628 
      raise x
2981 rajveer 2629 
    result = updateMyResearch_result()
559 chandransh 2630 
    result.read(self._iprot)
2631 
    self._iprot.readMessageEnd()
3431 rajveer 2632 
    if result.success is not None:
2981 rajveer 2633 
      return result.success
3431 rajveer 2634 
    if result.scx is not None:
2981 rajveer 2635 
      raise result.scx
2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2637 
 
2981 rajveer 2638 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2639 
    """
2981 rajveer 2640 
    delete item from my research for a user
3431 rajveer 2641 
 
1596 ankur.sing 2642 
    Parameters:
2981 rajveer 2643 
     - userId
2644 
     - itemId
1596 ankur.sing 2645 
    """
2981 rajveer 2646 
    self.send_deleteItemFromMyResearch(userId, itemId)
2647 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2648 
 
2981 rajveer 2649 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2650 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2651 
    args = deleteItemFromMyResearch_args()
2652 
    args.userId = userId
2653 
    args.itemId = itemId
1596 ankur.sing 2654 
    args.write(self._oprot)
2655 
    self._oprot.writeMessageEnd()
2656 
    self._oprot.trans.flush()
2657 
 
2981 rajveer 2658 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2660 
    if mtype == TMessageType.EXCEPTION:
2661 
      x = TApplicationException()
2662 
      x.read(self._iprot)
2663 
      self._iprot.readMessageEnd()
2664 
      raise x
2981 rajveer 2665 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2666 
    result.read(self._iprot)
2667 
    self._iprot.readMessageEnd()
3431 rajveer 2668 
    if result.scx is not None:
2981 rajveer 2669 
      raise result.scx
2670 
    return
1596 ankur.sing 2671 
 
2981 rajveer 2672 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2673 
    """
2981 rajveer 2674 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2675 
 
1673 ankur.sing 2676 
    Parameters:
2981 rajveer 2677 
     - userId
1673 ankur.sing 2678 
    """
2981 rajveer 2679 
    self.send_getBrowseHistoryItems(userId)
2680 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2681 
 
2981 rajveer 2682 
  def send_getBrowseHistoryItems(self, userId):
2683 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2684 
    args = getBrowseHistoryItems_args()
2685 
    args.userId = userId
1673 ankur.sing 2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
2981 rajveer 2690 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
2981 rajveer 2697 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
3431 rajveer 2700 
    if result.success is not None:
1673 ankur.sing 2701 
      return result.success
3431 rajveer 2702 
    if result.scx is not None:
2981 rajveer 2703 
      raise result.scx
2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2705 
 
2981 rajveer 2706 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2707 
    """
2981 rajveer 2708 
    add item to browse history for a user
3431 rajveer 2709 
 
2642 varun.gupt 2710 
    Parameters:
2981 rajveer 2711 
     - userId
2712 
     - itemId
2642 varun.gupt 2713 
    """
2981 rajveer 2714 
    self.send_updateBrowseHistory(userId, itemId)
2715 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2716 
 
2981 rajveer 2717 
  def send_updateBrowseHistory(self, userId, itemId):
2718 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2719 
    args = updateBrowseHistory_args()
2720 
    args.userId = userId
2721 
    args.itemId = itemId
2642 varun.gupt 2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
2981 rajveer 2726 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
2981 rajveer 2733 
    result = updateBrowseHistory_result()
2642 varun.gupt 2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
2736 
    return
2737 
 
3385 varun.gupt 2738 
  def getCartsWithCouponCount(self, couponCode):
2739 
    """
2740 
    Returns count of Carts with given coupon applied
3431 rajveer 2741 
 
3385 varun.gupt 2742 
    Parameters:
2743 
     - couponCode
2744 
    """
2745 
    self.send_getCartsWithCouponCount(couponCode)
2746 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2747 
 
3385 varun.gupt 2748 
  def send_getCartsWithCouponCount(self, couponCode):
2749 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2750 
    args = getCartsWithCouponCount_args()
2751 
    args.couponCode = couponCode
2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2756 
  def recv_getCartsWithCouponCount(self, ):
2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2763 
    result = getCartsWithCouponCount_result()
2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
3431 rajveer 2766 
    if result.success is not None:
3385 varun.gupt 2767 
      return result.success
2768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2769 
 
3499 mandeep.dh 2770 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2771 
    """
2772 
    Updates COD trust level of a user
3385 varun.gupt 2773 
 
3499 mandeep.dh 2774 
    Parameters:
2775 
     - userId
2776 
     - trustLevelDelta
2777 
    """
2778 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2779 
 
2780 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2781 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2782 
    args = increaseTrustLevel_args()
2783 
    args.userId = userId
2784 
    args.trustLevelDelta = trustLevelDelta
2785 
    args.write(self._oprot)
2786 
    self._oprot.writeMessageEnd()
2787 
    self._oprot.trans.flush()
5407 amar.kumar 2788 
  def getTrustLevel(self, userId):
2789 
    """
2790 
    Get trust level of a user
2791 
 
2792 
    Parameters:
2793 
     - userId
2794 
    """
2795 
    self.send_getTrustLevel(userId)
2796 
    return self.recv_getTrustLevel()
2797 
 
2798 
  def send_getTrustLevel(self, userId):
2799 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2800 
    args = getTrustLevel_args()
2801 
    args.userId = userId
2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2806 
  def recv_getTrustLevel(self, ):
2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2813 
    result = getTrustLevel_result()
2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
2816 
    if result.success is not None:
2817 
      return result.success
2818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2819 
 
4668 varun.gupt 2820 
  def showCODOption(self, cartId, sourceId, pincode):
2821 
    """
2822 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2823 
 
4668 varun.gupt 2824 
    Parameters:
2825 
     - cartId
2826 
     - sourceId
2827 
     - pincode
2828 
    """
2829 
    self.send_showCODOption(cartId, sourceId, pincode)
2830 
    return self.recv_showCODOption()
2831 
 
2832 
  def send_showCODOption(self, cartId, sourceId, pincode):
2833 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2834 
    args = showCODOption_args()
2835 
    args.cartId = cartId
2836 
    args.sourceId = sourceId
2837 
    args.pincode = pincode
2838 
    args.write(self._oprot)
2839 
    self._oprot.writeMessageEnd()
2840 
    self._oprot.trans.flush()
2841 
 
2842 
  def recv_showCODOption(self, ):
2843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2844 
    if mtype == TMessageType.EXCEPTION:
2845 
      x = TApplicationException()
2846 
      x.read(self._iprot)
2847 
      self._iprot.readMessageEnd()
2848 
      raise x
2849 
    result = showCODOption_result()
2850 
    result.read(self._iprot)
2851 
    self._iprot.readMessageEnd()
2852 
    if result.success is not None:
2853 
      return result.success
2854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2855 
 
5623 anupam.sin 2856 
  def getUserEmails(self, startDate, endDate):
2857 
    """
2858 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2859 
 
5623 anupam.sin 2860 
    Parameters:
2861 
     - startDate
2862 
     - endDate
2863 
    """
2864 
    self.send_getUserEmails(startDate, endDate)
2865 
    return self.recv_getUserEmails()
2866 
 
2867 
  def send_getUserEmails(self, startDate, endDate):
2868 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
2869 
    args = getUserEmails_args()
2870 
    args.startDate = startDate
2871 
    args.endDate = endDate
2872 
    args.write(self._oprot)
2873 
    self._oprot.writeMessageEnd()
2874 
    self._oprot.trans.flush()
2875 
 
2876 
  def recv_getUserEmails(self, ):
2877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2878 
    if mtype == TMessageType.EXCEPTION:
2879 
      x = TApplicationException()
2880 
      x.read(self._iprot)
2881 
      self._iprot.readMessageEnd()
2882 
      raise x
2883 
    result = getUserEmails_result()
2884 
    result.read(self._iprot)
2885 
    self._iprot.readMessageEnd()
2886 
    if result.success is not None:
2887 
      return result.success
2888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
2889 
 
6903 anupam.sin 2890 
  def insureItem(self, itemId, cartId, toInsure):
2891 
    """
2892 
    Mark a cart lineitem as insured. Returns true/false.
2893 
 
2894 
    Parameters:
2895 
     - itemId
2896 
     - cartId
2897 
     - toInsure
2898 
    """
2899 
    self.send_insureItem(itemId, cartId, toInsure)
2900 
    return self.recv_insureItem()
2901 
 
2902 
  def send_insureItem(self, itemId, cartId, toInsure):
2903 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
2904 
    args = insureItem_args()
2905 
    args.itemId = itemId
2906 
    args.cartId = cartId
2907 
    args.toInsure = toInsure
2908 
    args.write(self._oprot)
2909 
    self._oprot.writeMessageEnd()
2910 
    self._oprot.trans.flush()
2911 
 
2912 
  def recv_insureItem(self, ):
2913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2914 
    if mtype == TMessageType.EXCEPTION:
2915 
      x = TApplicationException()
2916 
      x.read(self._iprot)
2917 
      self._iprot.readMessageEnd()
2918 
      raise x
2919 
    result = insureItem_result()
2920 
    result.read(self._iprot)
2921 
    self._iprot.readMessageEnd()
2922 
    if result.success is not None:
2923 
      return result.success
2924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
2925 
 
2926 
  def cancelInsurance(self, cartId):
2927 
    """
2928 
    Cancel insurance for all items in the cart
2929 
 
2930 
    Parameters:
2931 
     - cartId
2932 
    """
2933 
    self.send_cancelInsurance(cartId)
2934 
    return self.recv_cancelInsurance()
2935 
 
2936 
  def send_cancelInsurance(self, cartId):
2937 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
2938 
    args = cancelInsurance_args()
2939 
    args.cartId = cartId
2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_cancelInsurance(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = cancelInsurance_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
2957 
 
2958 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
2959 
    """
2960 
    Stores insurance specific details like date of birth and guardianName
2961 
 
2962 
    Parameters:
2963 
     - addressId
2964 
     - dob
2965 
     - guardianName
2966 
    """
2967 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
2968 
    return self.recv_storeInsuranceSpecificDetails()
2969 
 
2970 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
2971 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
2972 
    args = storeInsuranceSpecificDetails_args()
2973 
    args.addressId = addressId
2974 
    args.dob = dob
2975 
    args.guardianName = guardianName
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_storeInsuranceSpecificDetails(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = storeInsuranceSpecificDetails_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
2990 
    if result.success is not None:
2991 
      return result.success
2992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
2993 
 
2994 
  def isInsuranceDetailPresent(self, addressId):
2995 
    """
2996 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
2997 
 
2998 
    Parameters:
2999 
     - addressId
3000 
    """
3001 
    self.send_isInsuranceDetailPresent(addressId)
3002 
    return self.recv_isInsuranceDetailPresent()
3003 
 
3004 
  def send_isInsuranceDetailPresent(self, addressId):
3005 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3006 
    args = isInsuranceDetailPresent_args()
3007 
    args.addressId = addressId
3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
3011 
 
3012 
  def recv_isInsuranceDetailPresent(self, ):
3013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3014 
    if mtype == TMessageType.EXCEPTION:
3015 
      x = TApplicationException()
3016 
      x.read(self._iprot)
3017 
      self._iprot.readMessageEnd()
3018 
      raise x
3019 
    result = isInsuranceDetailPresent_result()
3020 
    result.read(self._iprot)
3021 
    self._iprot.readMessageEnd()
3022 
    if result.success is not None:
3023 
      return result.success
3024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3025 
 
6821 amar.kumar 3026 
  def isProductAddedToCart(self, itemId, startDate, endDate):
3027 
    """
3028 
    Returns whether product is added to cart from startDate to endDate
5623 anupam.sin 3029 
 
6821 amar.kumar 3030 
    Parameters:
3031 
     - itemId
3032 
     - startDate
3033 
     - endDate
3034 
    """
3035 
    self.send_isProductAddedToCart(itemId, startDate, endDate)
3036 
    return self.recv_isProductAddedToCart()
3037 
 
3038 
  def send_isProductAddedToCart(self, itemId, startDate, endDate):
3039 
    self._oprot.writeMessageBegin('isProductAddedToCart', TMessageType.CALL, self._seqid)
3040 
    args = isProductAddedToCart_args()
3041 
    args.itemId = itemId
3042 
    args.startDate = startDate
3043 
    args.endDate = endDate
3044 
    args.write(self._oprot)
3045 
    self._oprot.writeMessageEnd()
3046 
    self._oprot.trans.flush()
3047 
 
3048 
  def recv_isProductAddedToCart(self, ):
3049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3050 
    if mtype == TMessageType.EXCEPTION:
3051 
      x = TApplicationException()
3052 
      x.read(self._iprot)
3053 
      self._iprot.readMessageEnd()
3054 
      raise x
3055 
    result = isProductAddedToCart_result()
3056 
    result.read(self._iprot)
3057 
    self._iprot.readMessageEnd()
3058 
    if result.success is not None:
3059 
      return result.success
3060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isProductAddedToCart failed: unknown result");
3061 
 
3062 
 
3376 rajveer 3063 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3064 
  def __init__(self, handler):
3376 rajveer 3065 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3066 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3067 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3068 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3069 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3070 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3071 
    self._processMap["createUser"] = Processor.process_createUser
3072 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3073 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3074 
    self._processMap["userExists"] = Processor.process_userExists
3075 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3076 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3077 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3078 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3079 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3080 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3081 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3082 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3083 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3084 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3085 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3086 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3087 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3088 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3089 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3090 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3091 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3092 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3093 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3094 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3095 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3096 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3097 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3098 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3099 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3100 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3101 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3102 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3103 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3104 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3105 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3106 
    self._processMap["getCart"] = Processor.process_getCart
3107 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3108 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3109 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3110 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3111 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3112 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3113 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3114 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3115 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3116 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3117 
    self._processMap["validateCart"] = Processor.process_validateCart
3118 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3119 
    self._processMap["checkOut"] = Processor.process_checkOut
3120 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3121 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3122 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3123 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3124 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3125 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3126 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3127 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3128 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3129 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3130 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3131 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3132 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3133 
    self._processMap["insureItem"] = Processor.process_insureItem
3134 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3135 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3136 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
6821 amar.kumar 3137 
    self._processMap["isProductAddedToCart"] = Processor.process_isProductAddedToCart
94 ashish 3138 
 
3139 
  def process(self, iprot, oprot):
3140 
    (name, type, seqid) = iprot.readMessageBegin()
3141 
    if name not in self._processMap:
3142 
      iprot.skip(TType.STRUCT)
3143 
      iprot.readMessageEnd()
3144 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3145 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3146 
      x.write(oprot)
3147 
      oprot.writeMessageEnd()
3148 
      oprot.trans.flush()
3149 
      return
3150 
    else:
3151 
      self._processMap[name](self, seqid, iprot, oprot)
3152 
    return True
3153 
 
559 chandransh 3154 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3155 
    args = createAnonymousUser_args()
94 ashish 3156 
    args.read(iprot)
3157 
    iprot.readMessageEnd()
559 chandransh 3158 
    result = createAnonymousUser_result()
94 ashish 3159 
    try:
559 chandransh 3160 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3161 
    except UserContextException, ucex:
3162 
      result.ucex = ucex
3163 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3164 
    result.write(oprot)
3165 
    oprot.writeMessageEnd()
3166 
    oprot.trans.flush()
3167 
 
559 chandransh 3168 
  def process_getUserById(self, seqid, iprot, oprot):
3169 
    args = getUserById_args()
94 ashish 3170 
    args.read(iprot)
3171 
    iprot.readMessageEnd()
559 chandransh 3172 
    result = getUserById_result()
94 ashish 3173 
    try:
559 chandransh 3174 
      result.success = self._handler.getUserById(args.userId)
3175 
    except UserContextException, ucex:
3176 
      result.ucex = ucex
3177 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3178 
    result.write(oprot)
3179 
    oprot.writeMessageEnd()
3180 
    oprot.trans.flush()
3181 
 
5326 rajveer 3182 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3183 
    args = getUserByCartId_args()
3184 
    args.read(iprot)
3185 
    iprot.readMessageEnd()
3186 
    result = getUserByCartId_result()
3187 
    try:
3188 
      result.success = self._handler.getUserByCartId(args.cartId)
3189 
    except UserContextException, ucex:
3190 
      result.ucex = ucex
3191 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3192 
    result.write(oprot)
3193 
    oprot.writeMessageEnd()
3194 
    oprot.trans.flush()
3195 
 
1491 vikas 3196 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3197 
    args = getUserByEmail_args()
3198 
    args.read(iprot)
3199 
    iprot.readMessageEnd()
3200 
    result = getUserByEmail_result()
3201 
    try:
3202 
      result.success = self._handler.getUserByEmail(args.email)
3203 
    except UserContextException, ucex:
3204 
      result.ucex = ucex
3205 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3206 
    result.write(oprot)
3207 
    oprot.writeMessageEnd()
3208 
    oprot.trans.flush()
3209 
 
3032 mandeep.dh 3210 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3211 
    args = getUserByMobileNumber_args()
3212 
    args.read(iprot)
3213 
    iprot.readMessageEnd()
3214 
    result = getUserByMobileNumber_result()
3215 
    try:
3216 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3217 
    except UserContextException, ucex:
3218 
      result.ucex = ucex
3219 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3220 
    result.write(oprot)
3221 
    oprot.writeMessageEnd()
3222 
    oprot.trans.flush()
3223 
 
559 chandransh 3224 
  def process_createUser(self, seqid, iprot, oprot):
3225 
    args = createUser_args()
94 ashish 3226 
    args.read(iprot)
3227 
    iprot.readMessageEnd()
559 chandransh 3228 
    result = createUser_result()
94 ashish 3229 
    try:
559 chandransh 3230 
      result.success = self._handler.createUser(args.user)
3231 
    except UserContextException, ucex:
3232 
      result.ucex = ucex
3233 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3234 
    result.write(oprot)
3235 
    oprot.writeMessageEnd()
3236 
    oprot.trans.flush()
3237 
 
559 chandransh 3238 
  def process_updateUser(self, seqid, iprot, oprot):
3239 
    args = updateUser_args()
94 ashish 3240 
    args.read(iprot)
3241 
    iprot.readMessageEnd()
559 chandransh 3242 
    result = updateUser_result()
94 ashish 3243 
    try:
559 chandransh 3244 
      result.success = self._handler.updateUser(args.user)
3245 
    except UserContextException, ucex:
3246 
      result.ucex = ucex
3247 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3248 
    result.write(oprot)
3249 
    oprot.writeMessageEnd()
3250 
    oprot.trans.flush()
3251 
 
122 ashish 3252 
  def process_authenticateUser(self, seqid, iprot, oprot):
3253 
    args = authenticateUser_args()
3254 
    args.read(iprot)
3255 
    iprot.readMessageEnd()
3256 
    result = authenticateUser_result()
3257 
    try:
559 chandransh 3258 
      result.success = self._handler.authenticateUser(args.email, args.password)
3259 
    except AuthenticationException, auex:
3260 
      result.auex = auex
122 ashish 3261 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3262 
    result.write(oprot)
3263 
    oprot.writeMessageEnd()
3264 
    oprot.trans.flush()
3265 
 
94 ashish 3266 
  def process_userExists(self, seqid, iprot, oprot):
3267 
    args = userExists_args()
3268 
    args.read(iprot)
3269 
    iprot.readMessageEnd()
3270 
    result = userExists_result()
3271 
    try:
3272 
      result.success = self._handler.userExists(args.email)
3273 
    except UserContextException, ucx:
3274 
      result.ucx = ucx
3275 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3276 
    result.write(oprot)
3277 
    oprot.writeMessageEnd()
3278 
    oprot.trans.flush()
3279 
 
3280 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3281 
    args = addAddressForUser_args()
3282 
    args.read(iprot)
3283 
    iprot.readMessageEnd()
3284 
    result = addAddressForUser_result()
3285 
    try:
567 rajveer 3286 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3287 
    except UserContextException, ucx:
3288 
      result.ucx = ucx
3289 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3290 
    result.write(oprot)
3291 
    oprot.writeMessageEnd()
3292 
    oprot.trans.flush()
3293 
 
3294 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3295 
    args = removeAddressForUser_args()
3296 
    args.read(iprot)
3297 
    iprot.readMessageEnd()
3298 
    result = removeAddressForUser_result()
3299 
    try:
3300 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3301 
    except UserContextException, ucx:
3302 
      result.ucx = ucx
3303 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3304 
    result.write(oprot)
3305 
    oprot.writeMessageEnd()
3306 
    oprot.trans.flush()
3307 
 
3308 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3309 
    args = setUserAsLoggedIn_args()
3310 
    args.read(iprot)
3311 
    iprot.readMessageEnd()
3312 
    result = setUserAsLoggedIn_result()
3313 
    try:
3314 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3315 
    except UserContextException, ucx:
3316 
      result.ucx = ucx
3317 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3318 
    result.write(oprot)
3319 
    oprot.writeMessageEnd()
3320 
    oprot.trans.flush()
3321 
 
3322 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3323 
    args = setUserAsLoggedOut_args()
3324 
    args.read(iprot)
3325 
    iprot.readMessageEnd()
3326 
    result = setUserAsLoggedOut_result()
3327 
    try:
3328 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3329 
    except UserContextException, ucx:
3330 
      result.ucx = ucx
3331 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3332 
    result.write(oprot)
3333 
    oprot.writeMessageEnd()
3334 
    oprot.trans.flush()
3335 
 
504 rajveer 3336 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3337 
    args = setDefaultAddress_args()
3338 
    args.read(iprot)
3339 
    iprot.readMessageEnd()
3340 
    result = setDefaultAddress_result()
3341 
    try:
3342 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3343 
    except UserContextException, ucx:
3344 
      result.ucx = ucx
3345 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3346 
    result.write(oprot)
3347 
    oprot.writeMessageEnd()
3348 
    oprot.trans.flush()
3349 
 
94 ashish 3350 
  def process_updatePassword(self, seqid, iprot, oprot):
3351 
    args = updatePassword_args()
3352 
    args.read(iprot)
3353 
    iprot.readMessageEnd()
3354 
    result = updatePassword_result()
3355 
    try:
594 rajveer 3356 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3357 
    except UserContextException, ucx:
3358 
      result.ucx = ucx
3359 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3360 
    result.write(oprot)
3361 
    oprot.writeMessageEnd()
3362 
    oprot.trans.flush()
3363 
 
581 rajveer 3364 
  def process_forgotPassword(self, seqid, iprot, oprot):
3365 
    args = forgotPassword_args()
3366 
    args.read(iprot)
3367 
    iprot.readMessageEnd()
3368 
    result = forgotPassword_result()
3369 
    try:
884 rajveer 3370 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3371 
    except UserContextException, ucx:
3372 
      result.ucx = ucx
3373 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3374 
    result.write(oprot)
3375 
    oprot.writeMessageEnd()
3376 
    oprot.trans.flush()
3377 
 
594 rajveer 3378 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3379 
    args = getAllAddressesForUser_args()
3380 
    args.read(iprot)
3381 
    iprot.readMessageEnd()
3382 
    result = getAllAddressesForUser_result()
3383 
    try:
3384 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3385 
    except UserContextException, ucx:
3386 
      result.ucx = ucx
3387 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3388 
    result.write(oprot)
3389 
    oprot.writeMessageEnd()
3390 
    oprot.trans.flush()
3391 
 
1894 vikas 3392 
  def process_getAddressById(self, seqid, iprot, oprot):
3393 
    args = getAddressById_args()
3394 
    args.read(iprot)
3395 
    iprot.readMessageEnd()
3396 
    result = getAddressById_result()
3397 
    try:
3398 
      result.success = self._handler.getAddressById(args.addressId)
3399 
    except UserContextException, ucx:
3400 
      result.ucx = ucx
3401 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3402 
    result.write(oprot)
3403 
    oprot.writeMessageEnd()
3404 
    oprot.trans.flush()
3405 
 
594 rajveer 3406 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3407 
    args = getDefaultAddressId_args()
3408 
    args.read(iprot)
3409 
    iprot.readMessageEnd()
3410 
    result = getDefaultAddressId_result()
3411 
    try:
3412 
      result.success = self._handler.getDefaultAddressId(args.userId)
3413 
    except UserContextException, ucx:
3414 
      result.ucx = ucx
3415 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3416 
    result.write(oprot)
3417 
    oprot.writeMessageEnd()
3418 
    oprot.trans.flush()
3419 
 
785 rajveer 3420 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3421 
    args = getDefaultPincode_args()
3422 
    args.read(iprot)
3423 
    iprot.readMessageEnd()
3424 
    result = getDefaultPincode_result()
3425 
    try:
3426 
      result.success = self._handler.getDefaultPincode(args.userId)
3427 
    except UserContextException, ucx:
3428 
      result.ucx = ucx
3429 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3430 
    result.write(oprot)
3431 
    oprot.writeMessageEnd()
3432 
    oprot.trans.flush()
3433 
 
1274 varun.gupt 3434 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3435 
    args = saveUserCommunication_args()
3436 
    args.read(iprot)
3437 
    iprot.readMessageEnd()
3438 
    result = saveUserCommunication_result()
3439 
    try:
3440 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3441 
    except UserCommunicationException, ucx:
3442 
      result.ucx = ucx
3443 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3444 
    result.write(oprot)
3445 
    oprot.writeMessageEnd()
3446 
    oprot.trans.flush()
3447 
 
1590 varun.gupt 3448 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3449 
    args = getUserCommunicationById_args()
3450 
    args.read(iprot)
3451 
    iprot.readMessageEnd()
3452 
    result = getUserCommunicationById_result()
3453 
    try:
3454 
      result.success = self._handler.getUserCommunicationById(args.id)
3455 
    except UserCommunicationException, ucx:
3456 
      result.ucx = ucx
3457 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3458 
    result.write(oprot)
3459 
    oprot.writeMessageEnd()
3460 
    oprot.trans.flush()
3461 
 
3462 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3463 
    args = getUserCommunicationByUser_args()
3464 
    args.read(iprot)
3465 
    iprot.readMessageEnd()
3466 
    result = getUserCommunicationByUser_result()
3467 
    try:
3468 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3469 
    except UserCommunicationException, ucx:
3470 
      result.ucx = ucx
3471 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3472 
    result.write(oprot)
3473 
    oprot.writeMessageEnd()
3474 
    oprot.trans.flush()
3475 
 
3476 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3477 
    args = getAllUserCommunications_args()
3478 
    args.read(iprot)
3479 
    iprot.readMessageEnd()
3480 
    result = getAllUserCommunications_result()
3481 
    try:
3482 
      result.success = self._handler.getAllUserCommunications()
3483 
    except UserCommunicationException, ucx:
3484 
      result.ucx = ucx
3485 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3486 
    result.write(oprot)
3487 
    oprot.writeMessageEnd()
3488 
    oprot.trans.flush()
3489 
 
5407 amar.kumar 3490 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3491 
    args = removeUserCommunication_args()
3492 
    args.read(iprot)
3493 
    iprot.readMessageEnd()
3494 
    result = removeUserCommunication_result()
3495 
    try:
3496 
      self._handler.removeUserCommunication(args.id)
3497 
    except UserCommunicationException, ucx:
3498 
      result.ucx = ucx
3499 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3500 
    result.write(oprot)
3501 
    oprot.writeMessageEnd()
3502 
    oprot.trans.flush()
3503 
 
1845 vikas 3504 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3505 
    args = createMasterAffiliate_args()
3506 
    args.read(iprot)
3507 
    iprot.readMessageEnd()
3508 
    result = createMasterAffiliate_result()
3509 
    try:
1859 vikas 3510 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3511 
    except UserAffiliateException, utx:
1845 vikas 3512 
      result.utx = utx
3513 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3514 
    result.write(oprot)
3515 
    oprot.writeMessageEnd()
3516 
    oprot.trans.flush()
3517 
 
1899 vikas 3518 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3519 
    args = getAllMasterAffiliates_args()
3520 
    args.read(iprot)
3521 
    iprot.readMessageEnd()
3522 
    result = getAllMasterAffiliates_result()
3523 
    try:
3524 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3525 
    except UserAffiliateException, utx:
1899 vikas 3526 
      result.utx = utx
3527 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3528 
    result.write(oprot)
3529 
    oprot.writeMessageEnd()
3530 
    oprot.trans.flush()
3531 
 
1845 vikas 3532 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3533 
    args = getMasterAffiliateById_args()
3534 
    args.read(iprot)
3535 
    iprot.readMessageEnd()
3536 
    result = getMasterAffiliateById_result()
3537 
    try:
3538 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3539 
    except UserAffiliateException, utx:
1845 vikas 3540 
      result.utx = utx
3541 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3542 
    result.write(oprot)
3543 
    oprot.writeMessageEnd()
3544 
    oprot.trans.flush()
3545 
 
3546 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3547 
    args = getMasterAffiliateByName_args()
3548 
    args.read(iprot)
3549 
    iprot.readMessageEnd()
3550 
    result = getMasterAffiliateByName_result()
3551 
    try:
3552 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3553 
    except UserAffiliateException, utx:
1845 vikas 3554 
      result.utx = utx
3555 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3556 
    result.write(oprot)
3557 
    oprot.writeMessageEnd()
3558 
    oprot.trans.flush()
3559 
 
3560 
  def process_createAffiliate(self, seqid, iprot, oprot):
3561 
    args = createAffiliate_args()
3562 
    args.read(iprot)
3563 
    iprot.readMessageEnd()
3564 
    result = createAffiliate_result()
3565 
    try:
1859 vikas 3566 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3567 
    except UserAffiliateException, utx:
1845 vikas 3568 
      result.utx = utx
3569 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3570 
    result.write(oprot)
3571 
    oprot.writeMessageEnd()
3572 
    oprot.trans.flush()
3573 
 
3574 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3575 
    args = getAffiliateById_args()
3576 
    args.read(iprot)
3577 
    iprot.readMessageEnd()
3578 
    result = getAffiliateById_result()
3579 
    try:
3580 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3581 
    except UserAffiliateException, utx:
1845 vikas 3582 
      result.utx = utx
3583 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3584 
    result.write(oprot)
3585 
    oprot.writeMessageEnd()
3586 
    oprot.trans.flush()
3587 
 
3588 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3589 
    args = getAffiliateByName_args()
3590 
    args.read(iprot)
3591 
    iprot.readMessageEnd()
3592 
    result = getAffiliateByName_result()
3593 
    try:
3594 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3595 
    except UserAffiliateException, utx:
1845 vikas 3596 
      result.utx = utx
3597 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3598 
    result.write(oprot)
3599 
    oprot.writeMessageEnd()
3600 
    oprot.trans.flush()
3601 
 
3602 
  def process_getTrackerById(self, seqid, iprot, oprot):
3603 
    args = getTrackerById_args()
3604 
    args.read(iprot)
3605 
    iprot.readMessageEnd()
3606 
    result = getTrackerById_result()
3607 
    try:
1996 vikas 3608 
      result.success = self._handler.getTrackerById(args.id)
3609 
    except UserAffiliateException, utx:
1845 vikas 3610 
      result.utx = utx
3611 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3612 
    result.write(oprot)
3613 
    oprot.writeMessageEnd()
3614 
    oprot.trans.flush()
3615 
 
1996 vikas 3616 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3617 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3618 
    args.read(iprot)
3619 
    iprot.readMessageEnd()
1996 vikas 3620 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3621 
    try:
1996 vikas 3622 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3623 
    except UserAffiliateException, utx:
1845 vikas 3624 
      result.utx = utx
1996 vikas 3625 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3626 
    result.write(oprot)
3627 
    oprot.writeMessageEnd()
3628 
    oprot.trans.flush()
3629 
 
3630 
  def process_addTrackLog(self, seqid, iprot, oprot):
3631 
    args = addTrackLog_args()
3632 
    args.read(iprot)
3633 
    iprot.readMessageEnd()
3634 
    result = addTrackLog_result()
3635 
    try:
1996 vikas 3636 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3637 
    except UserAffiliateException, utx:
1845 vikas 3638 
      result.utx = utx
3639 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3640 
    result.write(oprot)
3641 
    oprot.writeMessageEnd()
3642 
    oprot.trans.flush()
3643 
 
3644 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3645 
    args = getTrackLogById_args()
3646 
    args.read(iprot)
3647 
    iprot.readMessageEnd()
3648 
    result = getTrackLogById_result()
3649 
    try:
3650 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3651 
    except UserAffiliateException, utx:
1845 vikas 3652 
      result.utx = utx
3653 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3654 
    result.write(oprot)
3655 
    oprot.writeMessageEnd()
3656 
    oprot.trans.flush()
3657 
 
1996 vikas 3658 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3659 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3660 
    args.read(iprot)
3661 
    iprot.readMessageEnd()
1996 vikas 3662 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3663 
    try:
3293 vikas 3664 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3665 
    except UserAffiliateException, utx:
1845 vikas 3666 
      result.utx = utx
1996 vikas 3667 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3668 
    result.write(oprot)
3669 
    oprot.writeMessageEnd()
3670 
    oprot.trans.flush()
3671 
 
3672 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3673 
    args = getTrackLogsByUser_args()
3674 
    args.read(iprot)
3675 
    iprot.readMessageEnd()
3676 
    result = getTrackLogsByUser_result()
3677 
    try:
3678 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3679 
    except UserAffiliateException, utx:
1845 vikas 3680 
      result.utx = utx
3681 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3682 
    result.write(oprot)
3683 
    oprot.writeMessageEnd()
3684 
    oprot.trans.flush()
3685 
 
3686 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3687 
    args = getTrackLogs_args()
3688 
    args.read(iprot)
3689 
    iprot.readMessageEnd()
3690 
    result = getTrackLogs_result()
3691 
    try:
1996 vikas 3692 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3693 
    except UserAffiliateException, utx:
1845 vikas 3694 
      result.utx = utx
3695 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3696 
    result.write(oprot)
3697 
    oprot.writeMessageEnd()
3698 
    oprot.trans.flush()
3699 
 
559 chandransh 3700 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3701 
    args = getCurrentCart_args()
94 ashish 3702 
    args.read(iprot)
3703 
    iprot.readMessageEnd()
559 chandransh 3704 
    result = getCurrentCart_result()
94 ashish 3705 
    try:
559 chandransh 3706 
      result.success = self._handler.getCurrentCart(args.userId)
3707 
    except ShoppingCartException, scx:
3708 
      result.scx = scx
3709 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3710 
    result.write(oprot)
3711 
    oprot.writeMessageEnd()
3712 
    oprot.trans.flush()
3713 
 
559 chandransh 3714 
  def process_getCart(self, seqid, iprot, oprot):
3715 
    args = getCart_args()
94 ashish 3716 
    args.read(iprot)
3717 
    iprot.readMessageEnd()
559 chandransh 3718 
    result = getCart_result()
94 ashish 3719 
    try:
559 chandransh 3720 
      result.success = self._handler.getCart(args.cartId)
3721 
    except ShoppingCartException, scx:
3722 
      result.scx = scx
3723 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3724 
    result.write(oprot)
3725 
    oprot.writeMessageEnd()
3726 
    oprot.trans.flush()
3727 
 
559 chandransh 3728 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3729 
    args = getCartsByTime_args()
94 ashish 3730 
    args.read(iprot)
3731 
    iprot.readMessageEnd()
559 chandransh 3732 
    result = getCartsByTime_result()
94 ashish 3733 
    try:
559 chandransh 3734 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3735 
    except ShoppingCartException, scx:
3736 
      result.scx = scx
3737 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3738 
    result.write(oprot)
3739 
    oprot.writeMessageEnd()
3740 
    oprot.trans.flush()
3741 
 
559 chandransh 3742 
  def process_addItemToCart(self, seqid, iprot, oprot):
3743 
    args = addItemToCart_args()
130 ashish 3744 
    args.read(iprot)
3745 
    iprot.readMessageEnd()
559 chandransh 3746 
    result = addItemToCart_result()
130 ashish 3747 
    try:
3557 rajveer 3748 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 3749 
    except ShoppingCartException, scx:
3750 
      result.scx = scx
3751 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3752 
    result.write(oprot)
3753 
    oprot.writeMessageEnd()
3754 
    oprot.trans.flush()
3755 
 
559 chandransh 3756 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3757 
    args = deleteItemFromCart_args()
3758 
    args.read(iprot)
3759 
    iprot.readMessageEnd()
3760 
    result = deleteItemFromCart_result()
3761 
    try:
3762 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3763 
    except ShoppingCartException, scx:
3764 
      result.scx = scx
3765 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3766 
    result.write(oprot)
3767 
    oprot.writeMessageEnd()
3768 
    oprot.trans.flush()
130 ashish 3769 
 
559 chandransh 3770 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3771 
    args = addAddressToCart_args()
3772 
    args.read(iprot)
3773 
    iprot.readMessageEnd()
3774 
    result = addAddressToCart_result()
575 chandransh 3775 
    try:
3776 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3777 
    except ShoppingCartException, scx:
3778 
      result.scx = scx
559 chandransh 3779 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3780 
    result.write(oprot)
3781 
    oprot.writeMessageEnd()
3782 
    oprot.trans.flush()
3783 
 
5553 rajveer 3784 
  def process_addStoreToCart(self, seqid, iprot, oprot):
3785 
    args = addStoreToCart_args()
3786 
    args.read(iprot)
3787 
    iprot.readMessageEnd()
3788 
    result = addStoreToCart_result()
3789 
    try:
3790 
      self._handler.addStoreToCart(args.cartId, args.storeId)
3791 
    except ShoppingCartException, scx:
3792 
      result.scx = scx
3793 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
3794 
    result.write(oprot)
3795 
    oprot.writeMessageEnd()
3796 
    oprot.trans.flush()
3797 
 
1976 varun.gupt 3798 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3799 
    args = applyCouponToCart_args()
3800 
    args.read(iprot)
3801 
    iprot.readMessageEnd()
3802 
    result = applyCouponToCart_result()
3803 
    try:
6922 anupam.sin 3804 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 3805 
    except ShoppingCartException, scx:
3806 
      result.scx = scx
3807 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3808 
    result.write(oprot)
3809 
    oprot.writeMessageEnd()
3810 
    oprot.trans.flush()
3811 
 
3812 
  def process_removeCoupon(self, seqid, iprot, oprot):
3813 
    args = removeCoupon_args()
3814 
    args.read(iprot)
3815 
    iprot.readMessageEnd()
3816 
    result = removeCoupon_result()
3817 
    try:
3818 
      self._handler.removeCoupon(args.cartId)
3819 
    except ShoppingCartException, scx:
3820 
      result.scx = scx
3821 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3822 
    result.write(oprot)
3823 
    oprot.writeMessageEnd()
3824 
    oprot.trans.flush()
3825 
 
3554 varun.gupt 3826 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
3827 
    args = deleteDiscountsFromCart_args()
3828 
    args.read(iprot)
3829 
    iprot.readMessageEnd()
3830 
    result = deleteDiscountsFromCart_result()
3831 
    try:
3832 
      self._handler.deleteDiscountsFromCart(args.cartId)
3833 
    except ShoppingCartException, scx:
3834 
      result.scx = scx
3835 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
3836 
    result.write(oprot)
3837 
    oprot.writeMessageEnd()
3838 
    oprot.trans.flush()
3839 
 
3840 
  def process_saveDiscounts(self, seqid, iprot, oprot):
3841 
    args = saveDiscounts_args()
3842 
    args.read(iprot)
3843 
    iprot.readMessageEnd()
3844 
    result = saveDiscounts_result()
3845 
    try:
3846 
      self._handler.saveDiscounts(args.discounts)
3847 
    except ShoppingCartException, scx:
3848 
      result.scx = scx
3849 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
3850 
    result.write(oprot)
3851 
    oprot.writeMessageEnd()
3852 
    oprot.trans.flush()
3853 
 
690 chandransh 3854 
  def process_createOrders(self, seqid, iprot, oprot):
3855 
    args = createOrders_args()
559 chandransh 3856 
    args.read(iprot)
3857 
    iprot.readMessageEnd()
690 chandransh 3858 
    result = createOrders_result()
559 chandransh 3859 
    try:
6389 rajveer 3860 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId)
559 chandransh 3861 
    except ShoppingCartException, scx:
3862 
      result.scx = scx
690 chandransh 3863 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3864 
    result.write(oprot)
3865 
    oprot.writeMessageEnd()
3866 
    oprot.trans.flush()
3867 
 
3868 
  def process_validateCart(self, seqid, iprot, oprot):
3869 
    args = validateCart_args()
3870 
    args.read(iprot)
3871 
    iprot.readMessageEnd()
3872 
    result = validateCart_result()
575 chandransh 3873 
    try:
3557 rajveer 3874 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 3875 
    except ShoppingCartException, scex:
3876 
      result.scex = scex
559 chandransh 3877 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3878 
    result.write(oprot)
3879 
    oprot.writeMessageEnd()
3880 
    oprot.trans.flush()
3881 
 
690 chandransh 3882 
  def process_mergeCart(self, seqid, iprot, oprot):
3883 
    args = mergeCart_args()
575 chandransh 3884 
    args.read(iprot)
3885 
    iprot.readMessageEnd()
690 chandransh 3886 
    result = mergeCart_result()
3887 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3888 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3889 
    result.write(oprot)
3890 
    oprot.writeMessageEnd()
3891 
    oprot.trans.flush()
3892 
 
3893 
  def process_checkOut(self, seqid, iprot, oprot):
3894 
    args = checkOut_args()
3895 
    args.read(iprot)
3896 
    iprot.readMessageEnd()
3897 
    result = checkOut_result()
575 chandransh 3898 
    try:
690 chandransh 3899 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3900 
    except ShoppingCartException, scex:
3901 
      result.scex = scex
690 chandransh 3902 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3903 
    result.write(oprot)
3904 
    oprot.writeMessageEnd()
3905 
    oprot.trans.flush()
3906 
 
690 chandransh 3907 
  def process_resetCart(self, seqid, iprot, oprot):
3908 
    args = resetCart_args()
559 chandransh 3909 
    args.read(iprot)
3910 
    iprot.readMessageEnd()
690 chandransh 3911 
    result = resetCart_result()
3912 
    try:
3913 
      result.success = self._handler.resetCart(args.cartId, args.items)
3914 
    except ShoppingCartException, scex:
3915 
      result.scex = scex
3916 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3917 
    result.write(oprot)
3918 
    oprot.writeMessageEnd()
3919 
    oprot.trans.flush()
3920 
 
2981 rajveer 3921 
  def process_getUserCount(self, seqid, iprot, oprot):
3922 
    args = getUserCount_args()
559 chandransh 3923 
    args.read(iprot)
3924 
    iprot.readMessageEnd()
2981 rajveer 3925 
    result = getUserCount_result()
3926 
    result.success = self._handler.getUserCount(args.userType)
3927 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 3928 
    result.write(oprot)
3929 
    oprot.writeMessageEnd()
3930 
    oprot.trans.flush()
3931 
 
2981 rajveer 3932 
  def process_getAllUsers(self, seqid, iprot, oprot):
3933 
    args = getAllUsers_args()
559 chandransh 3934 
    args.read(iprot)
3935 
    iprot.readMessageEnd()
2981 rajveer 3936 
    result = getAllUsers_result()
3937 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
3938 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 3939 
    result.write(oprot)
3940 
    oprot.writeMessageEnd()
3941 
    oprot.trans.flush()
3942 
 
2981 rajveer 3943 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
3944 
    args = getMyResearchItems_args()
559 chandransh 3945 
    args.read(iprot)
3946 
    iprot.readMessageEnd()
2981 rajveer 3947 
    result = getMyResearchItems_result()
559 chandransh 3948 
    try:
2981 rajveer 3949 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 3950 
    except WidgetException, scx:
3951 
      result.scx = scx
2981 rajveer 3952 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 3953 
    result.write(oprot)
3954 
    oprot.writeMessageEnd()
3955 
    oprot.trans.flush()
3956 
 
2981 rajveer 3957 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3958 
    args = updateMyResearch_args()
772 rajveer 3959 
    args.read(iprot)
3960 
    iprot.readMessageEnd()
2981 rajveer 3961 
    result = updateMyResearch_result()
3962 
    try:
3963 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
3964 
    except WidgetException, scx:
3965 
      result.scx = scx
3966 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 3967 
    result.write(oprot)
3968 
    oprot.writeMessageEnd()
3969 
    oprot.trans.flush()
559 chandransh 3970 
 
2981 rajveer 3971 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3972 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 3973 
    args.read(iprot)
3974 
    iprot.readMessageEnd()
2981 rajveer 3975 
    result = deleteItemFromMyResearch_result()
3976 
    try:
3977 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
3978 
    except WidgetException, scx:
3979 
      result.scx = scx
3980 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 3981 
    result.write(oprot)
3982 
    oprot.writeMessageEnd()
3983 
    oprot.trans.flush()
772 rajveer 3984 
 
2981 rajveer 3985 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
3986 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 3987 
    args.read(iprot)
3988 
    iprot.readMessageEnd()
2981 rajveer 3989 
    result = getBrowseHistoryItems_result()
3990 
    try:
3991 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
3992 
    except WidgetException, scx:
3993 
      result.scx = scx
3994 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
1596 ankur.sing 3998 
 
2981 rajveer 3999 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4000 
    args = updateBrowseHistory_args()
2642 varun.gupt 4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
2981 rajveer 4003 
    result = updateBrowseHistory_result()
4004 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4005 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4006 
    result.write(oprot)
4007 
    oprot.writeMessageEnd()
4008 
    oprot.trans.flush()
1673 ankur.sing 4009 
 
3385 varun.gupt 4010 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4011 
    args = getCartsWithCouponCount_args()
4012 
    args.read(iprot)
4013 
    iprot.readMessageEnd()
4014 
    result = getCartsWithCouponCount_result()
4015 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4016 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4017 
    result.write(oprot)
4018 
    oprot.writeMessageEnd()
4019 
    oprot.trans.flush()
2642 varun.gupt 4020 
 
3499 mandeep.dh 4021 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4022 
    args = increaseTrustLevel_args()
4023 
    args.read(iprot)
4024 
    iprot.readMessageEnd()
4025 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4026 
    return
3385 varun.gupt 4027 
 
5407 amar.kumar 4028 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4029 
    args = getTrustLevel_args()
4030 
    args.read(iprot)
4031 
    iprot.readMessageEnd()
4032 
    result = getTrustLevel_result()
4033 
    result.success = self._handler.getTrustLevel(args.userId)
4034 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
4668 varun.gupt 4039 
  def process_showCODOption(self, seqid, iprot, oprot):
4040 
    args = showCODOption_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = showCODOption_result()
4044 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4045 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4046 
    result.write(oprot)
4047 
    oprot.writeMessageEnd()
4048 
    oprot.trans.flush()
3499 mandeep.dh 4049 
 
5623 anupam.sin 4050 
  def process_getUserEmails(self, seqid, iprot, oprot):
4051 
    args = getUserEmails_args()
4052 
    args.read(iprot)
4053 
    iprot.readMessageEnd()
4054 
    result = getUserEmails_result()
4055 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4056 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4057 
    result.write(oprot)
4058 
    oprot.writeMessageEnd()
4059 
    oprot.trans.flush()
4668 varun.gupt 4060 
 
6903 anupam.sin 4061 
  def process_insureItem(self, seqid, iprot, oprot):
4062 
    args = insureItem_args()
4063 
    args.read(iprot)
4064 
    iprot.readMessageEnd()
4065 
    result = insureItem_result()
4066 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure)
4067 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4068 
    result.write(oprot)
4069 
    oprot.writeMessageEnd()
4070 
    oprot.trans.flush()
4071 
 
4072 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4073 
    args = cancelInsurance_args()
4074 
    args.read(iprot)
4075 
    iprot.readMessageEnd()
4076 
    result = cancelInsurance_result()
4077 
    result.success = self._handler.cancelInsurance(args.cartId)
4078 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
4083 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4084 
    args = storeInsuranceSpecificDetails_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = storeInsuranceSpecificDetails_result()
4088 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4089 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4090 
    result.write(oprot)
4091 
    oprot.writeMessageEnd()
4092 
    oprot.trans.flush()
4093 
 
4094 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4095 
    args = isInsuranceDetailPresent_args()
4096 
    args.read(iprot)
4097 
    iprot.readMessageEnd()
4098 
    result = isInsuranceDetailPresent_result()
4099 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4100 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4101 
    result.write(oprot)
4102 
    oprot.writeMessageEnd()
4103 
    oprot.trans.flush()
4104 
 
6821 amar.kumar 4105 
  def process_isProductAddedToCart(self, seqid, iprot, oprot):
4106 
    args = isProductAddedToCart_args()
4107 
    args.read(iprot)
4108 
    iprot.readMessageEnd()
4109 
    result = isProductAddedToCart_result()
4110 
    result.success = self._handler.isProductAddedToCart(args.itemId, args.startDate, args.endDate)
4111 
    oprot.writeMessageBegin("isProductAddedToCart", TMessageType.REPLY, seqid)
4112 
    result.write(oprot)
4113 
    oprot.writeMessageEnd()
4114 
    oprot.trans.flush()
5623 anupam.sin 4115 
 
6821 amar.kumar 4116 
 
94 ashish 4117 
# HELPER FUNCTIONS AND STRUCTURES
4118 
 
559 chandransh 4119 
class createAnonymousUser_args:
94 ashish 4120 
  """
4121 
  Attributes:
559 chandransh 4122 
   - jsessionId
94 ashish 4123 
  """
4124 
 
4125 
  thrift_spec = (
4126 
    None, # 0
559 chandransh 4127 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4128 
  )
4129 
 
559 chandransh 4130 
  def __init__(self, jsessionId=None,):
4131 
    self.jsessionId = jsessionId
94 ashish 4132 
 
4133 
  def read(self, iprot):
4134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4136 
      return
4137 
    iprot.readStructBegin()
4138 
    while True:
4139 
      (fname, ftype, fid) = iprot.readFieldBegin()
4140 
      if ftype == TType.STOP:
4141 
        break
4142 
      if fid == 1:
559 chandransh 4143 
        if ftype == TType.STRING:
4144 
          self.jsessionId = iprot.readString();
94 ashish 4145 
        else:
4146 
          iprot.skip(ftype)
4147 
      else:
4148 
        iprot.skip(ftype)
4149 
      iprot.readFieldEnd()
4150 
    iprot.readStructEnd()
4151 
 
4152 
  def write(self, oprot):
4153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4155 
      return
559 chandransh 4156 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4157 
    if self.jsessionId is not None:
559 chandransh 4158 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4159 
      oprot.writeString(self.jsessionId)
94 ashish 4160 
      oprot.writeFieldEnd()
4161 
    oprot.writeFieldStop()
4162 
    oprot.writeStructEnd()
4163 
 
3431 rajveer 4164 
  def validate(self):
4165 
    return
4166 
 
4167 
 
94 ashish 4168 
  def __repr__(self):
4169 
    L = ['%s=%r' % (key, value)
4170 
      for key, value in self.__dict__.iteritems()]
4171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4172 
 
4173 
  def __eq__(self, other):
4174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4175 
 
4176 
  def __ne__(self, other):
4177 
    return not (self == other)
4178 
 
559 chandransh 4179 
class createAnonymousUser_result:
94 ashish 4180 
  """
4181 
  Attributes:
4182 
   - success
559 chandransh 4183 
   - ucex
94 ashish 4184 
  """
4185 
 
4186 
  thrift_spec = (
559 chandransh 4187 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4188 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4189 
  )
4190 
 
559 chandransh 4191 
  def __init__(self, success=None, ucex=None,):
94 ashish 4192 
    self.success = success
559 chandransh 4193 
    self.ucex = ucex
94 ashish 4194 
 
4195 
  def read(self, iprot):
4196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4198 
      return
4199 
    iprot.readStructBegin()
4200 
    while True:
4201 
      (fname, ftype, fid) = iprot.readFieldBegin()
4202 
      if ftype == TType.STOP:
4203 
        break
4204 
      if fid == 0:
4205 
        if ftype == TType.STRUCT:
559 chandransh 4206 
          self.success = User()
94 ashish 4207 
          self.success.read(iprot)
4208 
        else:
4209 
          iprot.skip(ftype)
4210 
      elif fid == 1:
4211 
        if ftype == TType.STRUCT:
559 chandransh 4212 
          self.ucex = UserContextException()
4213 
          self.ucex.read(iprot)
94 ashish 4214 
        else:
4215 
          iprot.skip(ftype)
4216 
      else:
4217 
        iprot.skip(ftype)
4218 
      iprot.readFieldEnd()
4219 
    iprot.readStructEnd()
4220 
 
4221 
  def write(self, oprot):
4222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4224 
      return
559 chandransh 4225 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4226 
    if self.success is not None:
94 ashish 4227 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4228 
      self.success.write(oprot)
4229 
      oprot.writeFieldEnd()
3431 rajveer 4230 
    if self.ucex is not None:
559 chandransh 4231 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4232 
      self.ucex.write(oprot)
94 ashish 4233 
      oprot.writeFieldEnd()
4234 
    oprot.writeFieldStop()
4235 
    oprot.writeStructEnd()
4236 
 
3431 rajveer 4237 
  def validate(self):
4238 
    return
4239 
 
4240 
 
94 ashish 4241 
  def __repr__(self):
4242 
    L = ['%s=%r' % (key, value)
4243 
      for key, value in self.__dict__.iteritems()]
4244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4245 
 
4246 
  def __eq__(self, other):
4247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4248 
 
4249 
  def __ne__(self, other):
4250 
    return not (self == other)
4251 
 
559 chandransh 4252 
class getUserById_args:
94 ashish 4253 
  """
4254 
  Attributes:
4255 
   - userId
4256 
  """
4257 
 
4258 
  thrift_spec = (
4259 
    None, # 0
4260 
    (1, TType.I64, 'userId', None, None, ), # 1
4261 
  )
4262 
 
559 chandransh 4263 
  def __init__(self, userId=None,):
94 ashish 4264 
    self.userId = userId
4265 
 
4266 
  def read(self, iprot):
4267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4269 
      return
4270 
    iprot.readStructBegin()
4271 
    while True:
4272 
      (fname, ftype, fid) = iprot.readFieldBegin()
4273 
      if ftype == TType.STOP:
4274 
        break
4275 
      if fid == 1:
4276 
        if ftype == TType.I64:
4277 
          self.userId = iprot.readI64();
4278 
        else:
4279 
          iprot.skip(ftype)
4280 
      else:
4281 
        iprot.skip(ftype)
4282 
      iprot.readFieldEnd()
4283 
    iprot.readStructEnd()
4284 
 
4285 
  def write(self, oprot):
4286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4288 
      return
559 chandransh 4289 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4290 
    if self.userId is not None:
94 ashish 4291 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4292 
      oprot.writeI64(self.userId)
4293 
      oprot.writeFieldEnd()
4294 
    oprot.writeFieldStop()
4295 
    oprot.writeStructEnd()
4296 
 
3431 rajveer 4297 
  def validate(self):
4298 
    return
4299 
 
4300 
 
94 ashish 4301 
  def __repr__(self):
4302 
    L = ['%s=%r' % (key, value)
4303 
      for key, value in self.__dict__.iteritems()]
4304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4305 
 
4306 
  def __eq__(self, other):
4307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4308 
 
4309 
  def __ne__(self, other):
4310 
    return not (self == other)
4311 
 
559 chandransh 4312 
class getUserById_result:
94 ashish 4313 
  """
4314 
  Attributes:
4315 
   - success
559 chandransh 4316 
   - ucex
94 ashish 4317 
  """
4318 
 
4319 
  thrift_spec = (
559 chandransh 4320 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4321 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4322 
  )
4323 
 
559 chandransh 4324 
  def __init__(self, success=None, ucex=None,):
94 ashish 4325 
    self.success = success
559 chandransh 4326 
    self.ucex = ucex
94 ashish 4327 
 
4328 
  def read(self, iprot):
4329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4331 
      return
4332 
    iprot.readStructBegin()
4333 
    while True:
4334 
      (fname, ftype, fid) = iprot.readFieldBegin()
4335 
      if ftype == TType.STOP:
4336 
        break
4337 
      if fid == 0:
4338 
        if ftype == TType.STRUCT:
559 chandransh 4339 
          self.success = User()
94 ashish 4340 
          self.success.read(iprot)
4341 
        else:
4342 
          iprot.skip(ftype)
4343 
      elif fid == 1:
4344 
        if ftype == TType.STRUCT:
559 chandransh 4345 
          self.ucex = UserContextException()
4346 
          self.ucex.read(iprot)
94 ashish 4347 
        else:
4348 
          iprot.skip(ftype)
4349 
      else:
4350 
        iprot.skip(ftype)
4351 
      iprot.readFieldEnd()
4352 
    iprot.readStructEnd()
4353 
 
4354 
  def write(self, oprot):
4355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4357 
      return
559 chandransh 4358 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4359 
    if self.success is not None:
94 ashish 4360 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4361 
      self.success.write(oprot)
4362 
      oprot.writeFieldEnd()
3431 rajveer 4363 
    if self.ucex is not None:
559 chandransh 4364 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4365 
      self.ucex.write(oprot)
94 ashish 4366 
      oprot.writeFieldEnd()
4367 
    oprot.writeFieldStop()
4368 
    oprot.writeStructEnd()
4369 
 
3431 rajveer 4370 
  def validate(self):
4371 
    return
4372 
 
4373 
 
94 ashish 4374 
  def __repr__(self):
4375 
    L = ['%s=%r' % (key, value)
4376 
      for key, value in self.__dict__.iteritems()]
4377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4378 
 
4379 
  def __eq__(self, other):
4380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4381 
 
4382 
  def __ne__(self, other):
4383 
    return not (self == other)
4384 
 
5326 rajveer 4385 
class getUserByCartId_args:
1491 vikas 4386 
  """
4387 
  Attributes:
5326 rajveer 4388 
   - cartId
1491 vikas 4389 
  """
4390 
 
4391 
  thrift_spec = (
4392 
    None, # 0
5326 rajveer 4393 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4394 
  )
4395 
 
5326 rajveer 4396 
  def __init__(self, cartId=None,):
4397 
    self.cartId = cartId
1491 vikas 4398 
 
4399 
  def read(self, iprot):
4400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4402 
      return
4403 
    iprot.readStructBegin()
4404 
    while True:
4405 
      (fname, ftype, fid) = iprot.readFieldBegin()
4406 
      if ftype == TType.STOP:
4407 
        break
4408 
      if fid == 1:
5326 rajveer 4409 
        if ftype == TType.I64:
4410 
          self.cartId = iprot.readI64();
1491 vikas 4411 
        else:
4412 
          iprot.skip(ftype)
4413 
      else:
4414 
        iprot.skip(ftype)
4415 
      iprot.readFieldEnd()
4416 
    iprot.readStructEnd()
4417 
 
4418 
  def write(self, oprot):
4419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4421 
      return
5326 rajveer 4422 
    oprot.writeStructBegin('getUserByCartId_args')
4423 
    if self.cartId is not None:
4424 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4425 
      oprot.writeI64(self.cartId)
1491 vikas 4426 
      oprot.writeFieldEnd()
4427 
    oprot.writeFieldStop()
4428 
    oprot.writeStructEnd()
4429 
 
3431 rajveer 4430 
  def validate(self):
4431 
    return
4432 
 
4433 
 
1491 vikas 4434 
  def __repr__(self):
4435 
    L = ['%s=%r' % (key, value)
4436 
      for key, value in self.__dict__.iteritems()]
4437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4438 
 
4439 
  def __eq__(self, other):
4440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4441 
 
4442 
  def __ne__(self, other):
4443 
    return not (self == other)
4444 
 
5326 rajveer 4445 
class getUserByCartId_result:
1491 vikas 4446 
  """
4447 
  Attributes:
4448 
   - success
4449 
   - ucex
4450 
  """
4451 
 
4452 
  thrift_spec = (
4453 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4454 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4455 
  )
4456 
 
4457 
  def __init__(self, success=None, ucex=None,):
4458 
    self.success = success
4459 
    self.ucex = ucex
4460 
 
4461 
  def read(self, iprot):
4462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4464 
      return
4465 
    iprot.readStructBegin()
4466 
    while True:
4467 
      (fname, ftype, fid) = iprot.readFieldBegin()
4468 
      if ftype == TType.STOP:
4469 
        break
4470 
      if fid == 0:
4471 
        if ftype == TType.STRUCT:
4472 
          self.success = User()
4473 
          self.success.read(iprot)
4474 
        else:
4475 
          iprot.skip(ftype)
4476 
      elif fid == 1:
4477 
        if ftype == TType.STRUCT:
4478 
          self.ucex = UserContextException()
4479 
          self.ucex.read(iprot)
4480 
        else:
4481 
          iprot.skip(ftype)
4482 
      else:
4483 
        iprot.skip(ftype)
4484 
      iprot.readFieldEnd()
4485 
    iprot.readStructEnd()
4486 
 
4487 
  def write(self, oprot):
4488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4490 
      return
5326 rajveer 4491 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 4492 
    if self.success is not None:
1491 vikas 4493 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4494 
      self.success.write(oprot)
4495 
      oprot.writeFieldEnd()
3431 rajveer 4496 
    if self.ucex is not None:
1491 vikas 4497 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4498 
      self.ucex.write(oprot)
4499 
      oprot.writeFieldEnd()
4500 
    oprot.writeFieldStop()
4501 
    oprot.writeStructEnd()
4502 
 
3431 rajveer 4503 
  def validate(self):
4504 
    return
4505 
 
4506 
 
1491 vikas 4507 
  def __repr__(self):
4508 
    L = ['%s=%r' % (key, value)
4509 
      for key, value in self.__dict__.iteritems()]
4510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4511 
 
4512 
  def __eq__(self, other):
4513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4514 
 
4515 
  def __ne__(self, other):
4516 
    return not (self == other)
4517 
 
5326 rajveer 4518 
class getUserByEmail_args:
3032 mandeep.dh 4519 
  """
4520 
  Attributes:
5326 rajveer 4521 
   - email
3032 mandeep.dh 4522 
  """
4523 
 
4524 
  thrift_spec = (
4525 
    None, # 0
5326 rajveer 4526 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 4527 
  )
4528 
 
5326 rajveer 4529 
  def __init__(self, email=None,):
4530 
    self.email = email
3032 mandeep.dh 4531 
 
4532 
  def read(self, iprot):
4533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4535 
      return
4536 
    iprot.readStructBegin()
4537 
    while True:
4538 
      (fname, ftype, fid) = iprot.readFieldBegin()
4539 
      if ftype == TType.STOP:
4540 
        break
4541 
      if fid == 1:
5326 rajveer 4542 
        if ftype == TType.STRING:
4543 
          self.email = iprot.readString();
3032 mandeep.dh 4544 
        else:
4545 
          iprot.skip(ftype)
4546 
      else:
4547 
        iprot.skip(ftype)
4548 
      iprot.readFieldEnd()
4549 
    iprot.readStructEnd()
4550 
 
4551 
  def write(self, oprot):
4552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4554 
      return
5326 rajveer 4555 
    oprot.writeStructBegin('getUserByEmail_args')
4556 
    if self.email is not None:
4557 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4558 
      oprot.writeString(self.email)
3032 mandeep.dh 4559 
      oprot.writeFieldEnd()
4560 
    oprot.writeFieldStop()
4561 
    oprot.writeStructEnd()
4562 
 
3431 rajveer 4563 
  def validate(self):
4564 
    return
4565 
 
4566 
 
3032 mandeep.dh 4567 
  def __repr__(self):
4568 
    L = ['%s=%r' % (key, value)
4569 
      for key, value in self.__dict__.iteritems()]
4570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4571 
 
4572 
  def __eq__(self, other):
4573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4574 
 
4575 
  def __ne__(self, other):
4576 
    return not (self == other)
4577 
 
5326 rajveer 4578 
class getUserByEmail_result:
3032 mandeep.dh 4579 
  """
4580 
  Attributes:
4581 
   - success
4582 
   - ucex
4583 
  """
4584 
 
4585 
  thrift_spec = (
4586 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4587 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4588 
  )
4589 
 
4590 
  def __init__(self, success=None, ucex=None,):
4591 
    self.success = success
4592 
    self.ucex = ucex
4593 
 
4594 
  def read(self, iprot):
4595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4597 
      return
4598 
    iprot.readStructBegin()
4599 
    while True:
4600 
      (fname, ftype, fid) = iprot.readFieldBegin()
4601 
      if ftype == TType.STOP:
4602 
        break
4603 
      if fid == 0:
4604 
        if ftype == TType.STRUCT:
4605 
          self.success = User()
4606 
          self.success.read(iprot)
4607 
        else:
4608 
          iprot.skip(ftype)
4609 
      elif fid == 1:
4610 
        if ftype == TType.STRUCT:
4611 
          self.ucex = UserContextException()
4612 
          self.ucex.read(iprot)
4613 
        else:
4614 
          iprot.skip(ftype)
4615 
      else:
4616 
        iprot.skip(ftype)
4617 
      iprot.readFieldEnd()
4618 
    iprot.readStructEnd()
4619 
 
4620 
  def write(self, oprot):
4621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4623 
      return
5326 rajveer 4624 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 4625 
    if self.success is not None:
3032 mandeep.dh 4626 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4627 
      self.success.write(oprot)
4628 
      oprot.writeFieldEnd()
3431 rajveer 4629 
    if self.ucex is not None:
3032 mandeep.dh 4630 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4631 
      self.ucex.write(oprot)
4632 
      oprot.writeFieldEnd()
4633 
    oprot.writeFieldStop()
4634 
    oprot.writeStructEnd()
4635 
 
3431 rajveer 4636 
  def validate(self):
4637 
    return
4638 
 
4639 
 
3032 mandeep.dh 4640 
  def __repr__(self):
4641 
    L = ['%s=%r' % (key, value)
4642 
      for key, value in self.__dict__.iteritems()]
4643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4644 
 
4645 
  def __eq__(self, other):
4646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4647 
 
4648 
  def __ne__(self, other):
4649 
    return not (self == other)
4650 
 
5326 rajveer 4651 
class getUserByMobileNumber_args:
94 ashish 4652 
  """
4653 
  Attributes:
5326 rajveer 4654 
   - mobileNumber
94 ashish 4655 
  """
4656 
 
4657 
  thrift_spec = (
4658 
    None, # 0
5326 rajveer 4659 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 4660 
  )
4661 
 
5326 rajveer 4662 
  def __init__(self, mobileNumber=None,):
4663 
    self.mobileNumber = mobileNumber
94 ashish 4664 
 
4665 
  def read(self, iprot):
4666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4668 
      return
4669 
    iprot.readStructBegin()
4670 
    while True:
4671 
      (fname, ftype, fid) = iprot.readFieldBegin()
4672 
      if ftype == TType.STOP:
4673 
        break
4674 
      if fid == 1:
5326 rajveer 4675 
        if ftype == TType.I64:
4676 
          self.mobileNumber = iprot.readI64();
94 ashish 4677 
        else:
4678 
          iprot.skip(ftype)
4679 
      else:
4680 
        iprot.skip(ftype)
4681 
      iprot.readFieldEnd()
4682 
    iprot.readStructEnd()
4683 
 
4684 
  def write(self, oprot):
4685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4687 
      return
5326 rajveer 4688 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4689 
    if self.mobileNumber is not None:
4690 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4691 
      oprot.writeI64(self.mobileNumber)
94 ashish 4692 
      oprot.writeFieldEnd()
4693 
    oprot.writeFieldStop()
4694 
    oprot.writeStructEnd()
4695 
 
3431 rajveer 4696 
  def validate(self):
4697 
    return
4698 
 
4699 
 
94 ashish 4700 
  def __repr__(self):
4701 
    L = ['%s=%r' % (key, value)
4702 
      for key, value in self.__dict__.iteritems()]
4703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4704 
 
4705 
  def __eq__(self, other):
4706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4707 
 
4708 
  def __ne__(self, other):
4709 
    return not (self == other)
4710 
 
5326 rajveer 4711 
class getUserByMobileNumber_result:
94 ashish 4712 
  """
4713 
  Attributes:
4714 
   - success
559 chandransh 4715 
   - ucex
94 ashish 4716 
  """
4717 
 
4718 
  thrift_spec = (
559 chandransh 4719 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4720 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4721 
  )
4722 
 
559 chandransh 4723 
  def __init__(self, success=None, ucex=None,):
94 ashish 4724 
    self.success = success
559 chandransh 4725 
    self.ucex = ucex
94 ashish 4726 
 
4727 
  def read(self, iprot):
4728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4730 
      return
4731 
    iprot.readStructBegin()
4732 
    while True:
4733 
      (fname, ftype, fid) = iprot.readFieldBegin()
4734 
      if ftype == TType.STOP:
4735 
        break
4736 
      if fid == 0:
4737 
        if ftype == TType.STRUCT:
559 chandransh 4738 
          self.success = User()
94 ashish 4739 
          self.success.read(iprot)
4740 
        else:
4741 
          iprot.skip(ftype)
4742 
      elif fid == 1:
4743 
        if ftype == TType.STRUCT:
559 chandransh 4744 
          self.ucex = UserContextException()
4745 
          self.ucex.read(iprot)
94 ashish 4746 
        else:
4747 
          iprot.skip(ftype)
4748 
      else:
4749 
        iprot.skip(ftype)
4750 
      iprot.readFieldEnd()
4751 
    iprot.readStructEnd()
4752 
 
4753 
  def write(self, oprot):
4754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4756 
      return
5326 rajveer 4757 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 4758 
    if self.success is not None:
94 ashish 4759 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4760 
      self.success.write(oprot)
4761 
      oprot.writeFieldEnd()
3431 rajveer 4762 
    if self.ucex is not None:
559 chandransh 4763 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4764 
      self.ucex.write(oprot)
94 ashish 4765 
      oprot.writeFieldEnd()
4766 
    oprot.writeFieldStop()
4767 
    oprot.writeStructEnd()
4768 
 
3431 rajveer 4769 
  def validate(self):
4770 
    return
4771 
 
4772 
 
94 ashish 4773 
  def __repr__(self):
4774 
    L = ['%s=%r' % (key, value)
4775 
      for key, value in self.__dict__.iteritems()]
4776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4777 
 
4778 
  def __eq__(self, other):
4779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4780 
 
4781 
  def __ne__(self, other):
4782 
    return not (self == other)
4783 
 
5326 rajveer 4784 
class createUser_args:
94 ashish 4785 
  """
4786 
  Attributes:
559 chandransh 4787 
   - user
94 ashish 4788 
  """
4789 
 
4790 
  thrift_spec = (
4791 
    None, # 0
559 chandransh 4792 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4793 
  )
4794 
 
559 chandransh 4795 
  def __init__(self, user=None,):
4796 
    self.user = user
94 ashish 4797 
 
4798 
  def read(self, iprot):
4799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4801 
      return
4802 
    iprot.readStructBegin()
4803 
    while True:
4804 
      (fname, ftype, fid) = iprot.readFieldBegin()
4805 
      if ftype == TType.STOP:
4806 
        break
4807 
      if fid == 1:
559 chandransh 4808 
        if ftype == TType.STRUCT:
4809 
          self.user = User()
4810 
          self.user.read(iprot)
94 ashish 4811 
        else:
4812 
          iprot.skip(ftype)
4813 
      else:
4814 
        iprot.skip(ftype)
4815 
      iprot.readFieldEnd()
4816 
    iprot.readStructEnd()
4817 
 
4818 
  def write(self, oprot):
4819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4821 
      return
5326 rajveer 4822 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 4823 
    if self.user is not None:
559 chandransh 4824 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4825 
      self.user.write(oprot)
94 ashish 4826 
      oprot.writeFieldEnd()
4827 
    oprot.writeFieldStop()
4828 
    oprot.writeStructEnd()
4829 
 
3431 rajveer 4830 
  def validate(self):
4831 
    return
4832 
 
4833 
 
94 ashish 4834 
  def __repr__(self):
4835 
    L = ['%s=%r' % (key, value)
4836 
      for key, value in self.__dict__.iteritems()]
4837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4838 
 
4839 
  def __eq__(self, other):
4840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4841 
 
4842 
  def __ne__(self, other):
4843 
    return not (self == other)
4844 
 
5326 rajveer 4845 
class createUser_result:
94 ashish 4846 
  """
4847 
  Attributes:
4848 
   - success
559 chandransh 4849 
   - ucex
94 ashish 4850 
  """
4851 
 
4852 
  thrift_spec = (
559 chandransh 4853 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4854 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4855 
  )
4856 
 
559 chandransh 4857 
  def __init__(self, success=None, ucex=None,):
94 ashish 4858 
    self.success = success
559 chandransh 4859 
    self.ucex = ucex
94 ashish 4860 
 
4861 
  def read(self, iprot):
4862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4864 
      return
4865 
    iprot.readStructBegin()
4866 
    while True:
4867 
      (fname, ftype, fid) = iprot.readFieldBegin()
4868 
      if ftype == TType.STOP:
4869 
        break
4870 
      if fid == 0:
4871 
        if ftype == TType.STRUCT:
559 chandransh 4872 
          self.success = User()
94 ashish 4873 
          self.success.read(iprot)
4874 
        else:
4875 
          iprot.skip(ftype)
4876 
      elif fid == 1:
4877 
        if ftype == TType.STRUCT:
559 chandransh 4878 
          self.ucex = UserContextException()
4879 
          self.ucex.read(iprot)
94 ashish 4880 
        else:
4881 
          iprot.skip(ftype)
4882 
      else:
4883 
        iprot.skip(ftype)
4884 
      iprot.readFieldEnd()
4885 
    iprot.readStructEnd()
4886 
 
4887 
  def write(self, oprot):
4888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4890 
      return
5326 rajveer 4891 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 4892 
    if self.success is not None:
94 ashish 4893 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4894 
      self.success.write(oprot)
4895 
      oprot.writeFieldEnd()
3431 rajveer 4896 
    if self.ucex is not None:
559 chandransh 4897 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4898 
      self.ucex.write(oprot)
94 ashish 4899 
      oprot.writeFieldEnd()
4900 
    oprot.writeFieldStop()
4901 
    oprot.writeStructEnd()
4902 
 
3431 rajveer 4903 
  def validate(self):
4904 
    return
4905 
 
4906 
 
94 ashish 4907 
  def __repr__(self):
4908 
    L = ['%s=%r' % (key, value)
4909 
      for key, value in self.__dict__.iteritems()]
4910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4911 
 
4912 
  def __eq__(self, other):
4913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4914 
 
4915 
  def __ne__(self, other):
4916 
    return not (self == other)
4917 
 
5326 rajveer 4918 
class updateUser_args:
94 ashish 4919 
  """
4920 
  Attributes:
5326 rajveer 4921 
   - user
94 ashish 4922 
  """
4923 
 
4924 
  thrift_spec = (
4925 
    None, # 0
5326 rajveer 4926 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4927 
  )
4928 
 
5326 rajveer 4929 
  def __init__(self, user=None,):
4930 
    self.user = user
94 ashish 4931 
 
4932 
  def read(self, iprot):
4933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4935 
      return
4936 
    iprot.readStructBegin()
4937 
    while True:
4938 
      (fname, ftype, fid) = iprot.readFieldBegin()
4939 
      if ftype == TType.STOP:
4940 
        break
4941 
      if fid == 1:
5326 rajveer 4942 
        if ftype == TType.STRUCT:
4943 
          self.user = User()
4944 
          self.user.read(iprot)
94 ashish 4945 
        else:
4946 
          iprot.skip(ftype)
4947 
      else:
4948 
        iprot.skip(ftype)
4949 
      iprot.readFieldEnd()
4950 
    iprot.readStructEnd()
4951 
 
4952 
  def write(self, oprot):
4953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4955 
      return
5326 rajveer 4956 
    oprot.writeStructBegin('updateUser_args')
4957 
    if self.user is not None:
4958 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4959 
      self.user.write(oprot)
94 ashish 4960 
      oprot.writeFieldEnd()
4961 
    oprot.writeFieldStop()
4962 
    oprot.writeStructEnd()
4963 
 
3431 rajveer 4964 
  def validate(self):
4965 
    return
4966 
 
4967 
 
94 ashish 4968 
  def __repr__(self):
4969 
    L = ['%s=%r' % (key, value)
4970 
      for key, value in self.__dict__.iteritems()]
4971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4972 
 
4973 
  def __eq__(self, other):
4974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4975 
 
4976 
  def __ne__(self, other):
4977 
    return not (self == other)
4978 
 
5326 rajveer 4979 
class updateUser_result:
94 ashish 4980 
  """
4981 
  Attributes:
4982 
   - success
559 chandransh 4983 
   - ucex
94 ashish 4984 
  """
4985 
 
4986 
  thrift_spec = (
5326 rajveer 4987 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 4988 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4989 
  )
4990 
 
559 chandransh 4991 
  def __init__(self, success=None, ucex=None,):
94 ashish 4992 
    self.success = success
559 chandransh 4993 
    self.ucex = ucex
94 ashish 4994 
 
4995 
  def read(self, iprot):
4996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4998 
      return
4999 
    iprot.readStructBegin()
5000 
    while True:
5001 
      (fname, ftype, fid) = iprot.readFieldBegin()
5002 
      if ftype == TType.STOP:
5003 
        break
5004 
      if fid == 0:
5326 rajveer 5005 
        if ftype == TType.STRUCT:
5006 
          self.success = User()
5007 
          self.success.read(iprot)
94 ashish 5008 
        else:
5009 
          iprot.skip(ftype)
5010 
      elif fid == 1:
5011 
        if ftype == TType.STRUCT:
559 chandransh 5012 
          self.ucex = UserContextException()
5013 
          self.ucex.read(iprot)
94 ashish 5014 
        else:
5015 
          iprot.skip(ftype)
5016 
      else:
5017 
        iprot.skip(ftype)
5018 
      iprot.readFieldEnd()
5019 
    iprot.readStructEnd()
5020 
 
5021 
  def write(self, oprot):
5022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5024 
      return
5326 rajveer 5025 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5026 
    if self.success is not None:
5326 rajveer 5027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5028 
      self.success.write(oprot)
94 ashish 5029 
      oprot.writeFieldEnd()
3431 rajveer 5030 
    if self.ucex is not None:
559 chandransh 5031 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5032 
      self.ucex.write(oprot)
94 ashish 5033 
      oprot.writeFieldEnd()
5034 
    oprot.writeFieldStop()
5035 
    oprot.writeStructEnd()
5036 
 
3431 rajveer 5037 
  def validate(self):
5038 
    return
5039 
 
5040 
 
94 ashish 5041 
  def __repr__(self):
5042 
    L = ['%s=%r' % (key, value)
5043 
      for key, value in self.__dict__.iteritems()]
5044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5045 
 
5046 
  def __eq__(self, other):
5047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5048 
 
5049 
  def __ne__(self, other):
5050 
    return not (self == other)
5051 
 
559 chandransh 5052 
class authenticateUser_args:
94 ashish 5053 
  """
5054 
  Attributes:
5055 
   - email
5056 
   - password
5057 
  """
5058 
 
5059 
  thrift_spec = (
5060 
    None, # 0
5061 
    (1, TType.STRING, 'email', None, None, ), # 1
5062 
    (2, TType.STRING, 'password', None, None, ), # 2
5063 
  )
5064 
 
5065 
  def __init__(self, email=None, password=None,):
5066 
    self.email = email
5067 
    self.password = password
5068 
 
5069 
  def read(self, iprot):
5070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5072 
      return
5073 
    iprot.readStructBegin()
5074 
    while True:
5075 
      (fname, ftype, fid) = iprot.readFieldBegin()
5076 
      if ftype == TType.STOP:
5077 
        break
5078 
      if fid == 1:
5079 
        if ftype == TType.STRING:
5080 
          self.email = iprot.readString();
5081 
        else:
5082 
          iprot.skip(ftype)
5083 
      elif fid == 2:
5084 
        if ftype == TType.STRING:
5085 
          self.password = iprot.readString();
5086 
        else:
5087 
          iprot.skip(ftype)
5088 
      else:
5089 
        iprot.skip(ftype)
5090 
      iprot.readFieldEnd()
5091 
    iprot.readStructEnd()
5092 
 
5093 
  def write(self, oprot):
5094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5096 
      return
559 chandransh 5097 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5098 
    if self.email is not None:
94 ashish 5099 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5100 
      oprot.writeString(self.email)
5101 
      oprot.writeFieldEnd()
3431 rajveer 5102 
    if self.password is not None:
94 ashish 5103 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5104 
      oprot.writeString(self.password)
5105 
      oprot.writeFieldEnd()
5106 
    oprot.writeFieldStop()
5107 
    oprot.writeStructEnd()
5108 
 
3431 rajveer 5109 
  def validate(self):
5110 
    return
5111 
 
5112 
 
94 ashish 5113 
  def __repr__(self):
5114 
    L = ['%s=%r' % (key, value)
5115 
      for key, value in self.__dict__.iteritems()]
5116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5117 
 
5118 
  def __eq__(self, other):
5119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5120 
 
5121 
  def __ne__(self, other):
5122 
    return not (self == other)
5123 
 
559 chandransh 5124 
class authenticateUser_result:
94 ashish 5125 
  """
5126 
  Attributes:
5127 
   - success
559 chandransh 5128 
   - auex
94 ashish 5129 
  """
5130 
 
5131 
  thrift_spec = (
559 chandransh 5132 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5133 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5134 
  )
5135 
 
559 chandransh 5136 
  def __init__(self, success=None, auex=None,):
94 ashish 5137 
    self.success = success
559 chandransh 5138 
    self.auex = auex
94 ashish 5139 
 
5140 
  def read(self, iprot):
5141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5143 
      return
5144 
    iprot.readStructBegin()
5145 
    while True:
5146 
      (fname, ftype, fid) = iprot.readFieldBegin()
5147 
      if ftype == TType.STOP:
5148 
        break
5149 
      if fid == 0:
5150 
        if ftype == TType.STRUCT:
559 chandransh 5151 
          self.success = User()
94 ashish 5152 
          self.success.read(iprot)
5153 
        else:
5154 
          iprot.skip(ftype)
5155 
      elif fid == 1:
5156 
        if ftype == TType.STRUCT:
559 chandransh 5157 
          self.auex = AuthenticationException()
5158 
          self.auex.read(iprot)
94 ashish 5159 
        else:
5160 
          iprot.skip(ftype)
5161 
      else:
5162 
        iprot.skip(ftype)
5163 
      iprot.readFieldEnd()
5164 
    iprot.readStructEnd()
5165 
 
5166 
  def write(self, oprot):
5167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5169 
      return
559 chandransh 5170 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5171 
    if self.success is not None:
94 ashish 5172 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5173 
      self.success.write(oprot)
5174 
      oprot.writeFieldEnd()
3431 rajveer 5175 
    if self.auex is not None:
559 chandransh 5176 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5177 
      self.auex.write(oprot)
94 ashish 5178 
      oprot.writeFieldEnd()
5179 
    oprot.writeFieldStop()
5180 
    oprot.writeStructEnd()
5181 
 
3431 rajveer 5182 
  def validate(self):
5183 
    return
5184 
 
5185 
 
94 ashish 5186 
  def __repr__(self):
5187 
    L = ['%s=%r' % (key, value)
5188 
      for key, value in self.__dict__.iteritems()]
5189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5190 
 
5191 
  def __eq__(self, other):
5192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5193 
 
5194 
  def __ne__(self, other):
5195 
    return not (self == other)
5196 
 
559 chandransh 5197 
class userExists_args:
122 ashish 5198 
  """
5199 
  Attributes:
559 chandransh 5200 
   - email
122 ashish 5201 
  """
5202 
 
5203 
  thrift_spec = (
5204 
    None, # 0
559 chandransh 5205 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5206 
  )
5207 
 
559 chandransh 5208 
  def __init__(self, email=None,):
5209 
    self.email = email
122 ashish 5210 
 
5211 
  def read(self, iprot):
5212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5214 
      return
5215 
    iprot.readStructBegin()
5216 
    while True:
5217 
      (fname, ftype, fid) = iprot.readFieldBegin()
5218 
      if ftype == TType.STOP:
5219 
        break
5220 
      if fid == 1:
5221 
        if ftype == TType.STRING:
559 chandransh 5222 
          self.email = iprot.readString();
122 ashish 5223 
        else:
5224 
          iprot.skip(ftype)
559 chandransh 5225 
      else:
5226 
        iprot.skip(ftype)
5227 
      iprot.readFieldEnd()
5228 
    iprot.readStructEnd()
5229 
 
5230 
  def write(self, oprot):
5231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5233 
      return
5234 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5235 
    if self.email is not None:
559 chandransh 5236 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5237 
      oprot.writeString(self.email)
5238 
      oprot.writeFieldEnd()
5239 
    oprot.writeFieldStop()
5240 
    oprot.writeStructEnd()
5241 
 
3431 rajveer 5242 
  def validate(self):
5243 
    return
5244 
 
5245 
 
559 chandransh 5246 
  def __repr__(self):
5247 
    L = ['%s=%r' % (key, value)
5248 
      for key, value in self.__dict__.iteritems()]
5249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5250 
 
5251 
  def __eq__(self, other):
5252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5253 
 
5254 
  def __ne__(self, other):
5255 
    return not (self == other)
5256 
 
5257 
class userExists_result:
5258 
  """
5259 
  Attributes:
5260 
   - success
5261 
   - ucx
5262 
  """
5263 
 
5264 
  thrift_spec = (
5265 
    (0, TType.BOOL, 'success', None, None, ), # 0
5266 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5267 
  )
5268 
 
5269 
  def __init__(self, success=None, ucx=None,):
5270 
    self.success = success
5271 
    self.ucx = ucx
5272 
 
5273 
  def read(self, iprot):
5274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5276 
      return
5277 
    iprot.readStructBegin()
5278 
    while True:
5279 
      (fname, ftype, fid) = iprot.readFieldBegin()
5280 
      if ftype == TType.STOP:
5281 
        break
5282 
      if fid == 0:
5283 
        if ftype == TType.BOOL:
5284 
          self.success = iprot.readBool();
5285 
        else:
5286 
          iprot.skip(ftype)
5287 
      elif fid == 1:
5288 
        if ftype == TType.STRUCT:
5289 
          self.ucx = UserContextException()
5290 
          self.ucx.read(iprot)
5291 
        else:
5292 
          iprot.skip(ftype)
5293 
      else:
5294 
        iprot.skip(ftype)
5295 
      iprot.readFieldEnd()
5296 
    iprot.readStructEnd()
5297 
 
5298 
  def write(self, oprot):
5299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5301 
      return
5302 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5303 
    if self.success is not None:
559 chandransh 5304 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5305 
      oprot.writeBool(self.success)
5306 
      oprot.writeFieldEnd()
3431 rajveer 5307 
    if self.ucx is not None:
559 chandransh 5308 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5309 
      self.ucx.write(oprot)
5310 
      oprot.writeFieldEnd()
5311 
    oprot.writeFieldStop()
5312 
    oprot.writeStructEnd()
5313 
 
3431 rajveer 5314 
  def validate(self):
5315 
    return
5316 
 
5317 
 
559 chandransh 5318 
  def __repr__(self):
5319 
    L = ['%s=%r' % (key, value)
5320 
      for key, value in self.__dict__.iteritems()]
5321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5322 
 
5323 
  def __eq__(self, other):
5324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5325 
 
5326 
  def __ne__(self, other):
5327 
    return not (self == other)
5328 
 
5329 
class addAddressForUser_args:
5330 
  """
5331 
  Attributes:
5332 
   - userId
5333 
   - address
5334 
   - setDefault
5335 
  """
5336 
 
5337 
  thrift_spec = (
5338 
    None, # 0
5339 
    (1, TType.I64, 'userId', None, None, ), # 1
5340 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5341 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5342 
  )
5343 
 
567 rajveer 5344 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5345 
    self.userId = userId
5346 
    self.address = address
5347 
    self.setDefault = setDefault
5348 
 
5349 
  def read(self, iprot):
5350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5352 
      return
5353 
    iprot.readStructBegin()
5354 
    while True:
5355 
      (fname, ftype, fid) = iprot.readFieldBegin()
5356 
      if ftype == TType.STOP:
5357 
        break
5358 
      if fid == 1:
5359 
        if ftype == TType.I64:
5360 
          self.userId = iprot.readI64();
5361 
        else:
5362 
          iprot.skip(ftype)
122 ashish 5363 
      elif fid == 2:
559 chandransh 5364 
        if ftype == TType.STRUCT:
5365 
          self.address = Address()
5366 
          self.address.read(iprot)
122 ashish 5367 
        else:
5368 
          iprot.skip(ftype)
5369 
      elif fid == 3:
5370 
        if ftype == TType.BOOL:
559 chandransh 5371 
          self.setDefault = iprot.readBool();
122 ashish 5372 
        else:
5373 
          iprot.skip(ftype)
5374 
      else:
5375 
        iprot.skip(ftype)
5376 
      iprot.readFieldEnd()
5377 
    iprot.readStructEnd()
5378 
 
5379 
  def write(self, oprot):
5380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5382 
      return
559 chandransh 5383 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5384 
    if self.userId is not None:
559 chandransh 5385 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5386 
      oprot.writeI64(self.userId)
122 ashish 5387 
      oprot.writeFieldEnd()
3431 rajveer 5388 
    if self.address is not None:
559 chandransh 5389 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5390 
      self.address.write(oprot)
122 ashish 5391 
      oprot.writeFieldEnd()
3431 rajveer 5392 
    if self.setDefault is not None:
567 rajveer 5393 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5394 
      oprot.writeBool(self.setDefault)
5395 
      oprot.writeFieldEnd()
122 ashish 5396 
    oprot.writeFieldStop()
5397 
    oprot.writeStructEnd()
5398 
 
3431 rajveer 5399 
  def validate(self):
5400 
    return
5401 
 
5402 
 
122 ashish 5403 
  def __repr__(self):
5404 
    L = ['%s=%r' % (key, value)
5405 
      for key, value in self.__dict__.iteritems()]
5406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5407 
 
5408 
  def __eq__(self, other):
5409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5410 
 
5411 
  def __ne__(self, other):
5412 
    return not (self == other)
5413 
 
559 chandransh 5414 
class addAddressForUser_result:
122 ashish 5415 
  """
5416 
  Attributes:
5417 
   - success
559 chandransh 5418 
   - ucx
122 ashish 5419 
  """
5420 
 
5421 
  thrift_spec = (
567 rajveer 5422 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5423 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5424 
  )
5425 
 
559 chandransh 5426 
  def __init__(self, success=None, ucx=None,):
122 ashish 5427 
    self.success = success
559 chandransh 5428 
    self.ucx = ucx
122 ashish 5429 
 
5430 
  def read(self, iprot):
5431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5433 
      return
5434 
    iprot.readStructBegin()
5435 
    while True:
5436 
      (fname, ftype, fid) = iprot.readFieldBegin()
5437 
      if ftype == TType.STOP:
5438 
        break
5439 
      if fid == 0:
567 rajveer 5440 
        if ftype == TType.I64:
5441 
          self.success = iprot.readI64();
122 ashish 5442 
        else:
5443 
          iprot.skip(ftype)
5444 
      elif fid == 1:
5445 
        if ftype == TType.STRUCT:
559 chandransh 5446 
          self.ucx = UserContextException()
5447 
          self.ucx.read(iprot)
122 ashish 5448 
        else:
5449 
          iprot.skip(ftype)
5450 
      else:
5451 
        iprot.skip(ftype)
5452 
      iprot.readFieldEnd()
5453 
    iprot.readStructEnd()
5454 
 
5455 
  def write(self, oprot):
5456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5458 
      return
559 chandransh 5459 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 5460 
    if self.success is not None:
567 rajveer 5461 
      oprot.writeFieldBegin('success', TType.I64, 0)
5462 
      oprot.writeI64(self.success)
122 ashish 5463 
      oprot.writeFieldEnd()
3431 rajveer 5464 
    if self.ucx is not None:
559 chandransh 5465 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5466 
      self.ucx.write(oprot)
122 ashish 5467 
      oprot.writeFieldEnd()
5468 
    oprot.writeFieldStop()
5469 
    oprot.writeStructEnd()
5470 
 
3431 rajveer 5471 
  def validate(self):
5472 
    return
5473 
 
5474 
 
122 ashish 5475 
  def __repr__(self):
5476 
    L = ['%s=%r' % (key, value)
5477 
      for key, value in self.__dict__.iteritems()]
5478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5479 
 
5480 
  def __eq__(self, other):
5481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5482 
 
5483 
  def __ne__(self, other):
5484 
    return not (self == other)
5485 
 
559 chandransh 5486 
class removeAddressForUser_args:
94 ashish 5487 
  """
5488 
  Attributes:
559 chandransh 5489 
   - userid
5490 
   - addressId
94 ashish 5491 
  """
5492 
 
5493 
  thrift_spec = (
5494 
    None, # 0
559 chandransh 5495 
    (1, TType.I64, 'userid', None, None, ), # 1
5496 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5497 
  )
5498 
 
559 chandransh 5499 
  def __init__(self, userid=None, addressId=None,):
5500 
    self.userid = userid
5501 
    self.addressId = addressId
94 ashish 5502 
 
5503 
  def read(self, iprot):
5504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5506 
      return
5507 
    iprot.readStructBegin()
5508 
    while True:
5509 
      (fname, ftype, fid) = iprot.readFieldBegin()
5510 
      if ftype == TType.STOP:
5511 
        break
5512 
      if fid == 1:
559 chandransh 5513 
        if ftype == TType.I64:
5514 
          self.userid = iprot.readI64();
94 ashish 5515 
        else:
5516 
          iprot.skip(ftype)
559 chandransh 5517 
      elif fid == 2:
5518 
        if ftype == TType.I64:
5519 
          self.addressId = iprot.readI64();
5520 
        else:
5521 
          iprot.skip(ftype)
94 ashish 5522 
      else:
5523 
        iprot.skip(ftype)
5524 
      iprot.readFieldEnd()
5525 
    iprot.readStructEnd()
5526 
 
5527 
  def write(self, oprot):
5528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5530 
      return
559 chandransh 5531 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 5532 
    if self.userid is not None:
559 chandransh 5533 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5534 
      oprot.writeI64(self.userid)
94 ashish 5535 
      oprot.writeFieldEnd()
3431 rajveer 5536 
    if self.addressId is not None:
559 chandransh 5537 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5538 
      oprot.writeI64(self.addressId)
5539 
      oprot.writeFieldEnd()
94 ashish 5540 
    oprot.writeFieldStop()
5541 
    oprot.writeStructEnd()
5542 
 
3431 rajveer 5543 
  def validate(self):
5544 
    return
5545 
 
5546 
 
94 ashish 5547 
  def __repr__(self):
5548 
    L = ['%s=%r' % (key, value)
5549 
      for key, value in self.__dict__.iteritems()]
5550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5551 
 
5552 
  def __eq__(self, other):
5553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5554 
 
5555 
  def __ne__(self, other):
5556 
    return not (self == other)
5557 
 
559 chandransh 5558 
class removeAddressForUser_result:
94 ashish 5559 
  """
5560 
  Attributes:
5561 
   - success
5562 
   - ucx
5563 
  """
5564 
 
5565 
  thrift_spec = (
5566 
    (0, TType.BOOL, 'success', None, None, ), # 0
5567 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5568 
  )
5569 
 
5570 
  def __init__(self, success=None, ucx=None,):
5571 
    self.success = success
5572 
    self.ucx = ucx
5573 
 
5574 
  def read(self, iprot):
5575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5577 
      return
5578 
    iprot.readStructBegin()
5579 
    while True:
5580 
      (fname, ftype, fid) = iprot.readFieldBegin()
5581 
      if ftype == TType.STOP:
5582 
        break
5583 
      if fid == 0:
5584 
        if ftype == TType.BOOL:
5585 
          self.success = iprot.readBool();
5586 
        else:
5587 
          iprot.skip(ftype)
5588 
      elif fid == 1:
5589 
        if ftype == TType.STRUCT:
5590 
          self.ucx = UserContextException()
5591 
          self.ucx.read(iprot)
5592 
        else:
5593 
          iprot.skip(ftype)
5594 
      else:
5595 
        iprot.skip(ftype)
5596 
      iprot.readFieldEnd()
5597 
    iprot.readStructEnd()
5598 
 
5599 
  def write(self, oprot):
5600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5602 
      return
559 chandransh 5603 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 5604 
    if self.success is not None:
94 ashish 5605 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5606 
      oprot.writeBool(self.success)
5607 
      oprot.writeFieldEnd()
3431 rajveer 5608 
    if self.ucx is not None:
94 ashish 5609 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5610 
      self.ucx.write(oprot)
5611 
      oprot.writeFieldEnd()
5612 
    oprot.writeFieldStop()
5613 
    oprot.writeStructEnd()
5614 
 
3431 rajveer 5615 
  def validate(self):
5616 
    return
5617 
 
5618 
 
94 ashish 5619 
  def __repr__(self):
5620 
    L = ['%s=%r' % (key, value)
5621 
      for key, value in self.__dict__.iteritems()]
5622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5623 
 
5624 
  def __eq__(self, other):
5625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5626 
 
5627 
  def __ne__(self, other):
5628 
    return not (self == other)
5629 
 
559 chandransh 5630 
class setUserAsLoggedIn_args:
94 ashish 5631 
  """
5632 
  Attributes:
559 chandransh 5633 
   - userId
94 ashish 5634 
   - timestamp
5635 
  """
5636 
 
5637 
  thrift_spec = (
5638 
    None, # 0
559 chandransh 5639 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5640 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5641 
  )
5642 
 
559 chandransh 5643 
  def __init__(self, userId=None, timestamp=None,):
5644 
    self.userId = userId
94 ashish 5645 
    self.timestamp = timestamp
5646 
 
5647 
  def read(self, iprot):
5648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5650 
      return
5651 
    iprot.readStructBegin()
5652 
    while True:
5653 
      (fname, ftype, fid) = iprot.readFieldBegin()
5654 
      if ftype == TType.STOP:
5655 
        break
5656 
      if fid == 1:
559 chandransh 5657 
        if ftype == TType.I64:
5658 
          self.userId = iprot.readI64();
94 ashish 5659 
        else:
5660 
          iprot.skip(ftype)
5661 
      elif fid == 2:
5662 
        if ftype == TType.I64:
5663 
          self.timestamp = iprot.readI64();
5664 
        else:
5665 
          iprot.skip(ftype)
5666 
      else:
5667 
        iprot.skip(ftype)
5668 
      iprot.readFieldEnd()
5669 
    iprot.readStructEnd()
5670 
 
5671 
  def write(self, oprot):
5672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5674 
      return
559 chandransh 5675 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 5676 
    if self.userId is not None:
559 chandransh 5677 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5678 
      oprot.writeI64(self.userId)
94 ashish 5679 
      oprot.writeFieldEnd()
3431 rajveer 5680 
    if self.timestamp is not None:
94 ashish 5681 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5682 
      oprot.writeI64(self.timestamp)
5683 
      oprot.writeFieldEnd()
5684 
    oprot.writeFieldStop()
5685 
    oprot.writeStructEnd()
5686 
 
3431 rajveer 5687 
  def validate(self):
5688 
    return
5689 
 
5690 
 
94 ashish 5691 
  def __repr__(self):
5692 
    L = ['%s=%r' % (key, value)
5693 
      for key, value in self.__dict__.iteritems()]
5694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5695 
 
5696 
  def __eq__(self, other):
5697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5698 
 
5699 
  def __ne__(self, other):
5700 
    return not (self == other)
5701 
 
559 chandransh 5702 
class setUserAsLoggedIn_result:
94 ashish 5703 
  """
5704 
  Attributes:
5705 
   - success
5706 
   - ucx
5707 
  """
5708 
 
5709 
  thrift_spec = (
5710 
    (0, TType.BOOL, 'success', None, None, ), # 0
5711 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5712 
  )
5713 
 
5714 
  def __init__(self, success=None, ucx=None,):
5715 
    self.success = success
5716 
    self.ucx = ucx
5717 
 
5718 
  def read(self, iprot):
5719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5721 
      return
5722 
    iprot.readStructBegin()
5723 
    while True:
5724 
      (fname, ftype, fid) = iprot.readFieldBegin()
5725 
      if ftype == TType.STOP:
5726 
        break
5727 
      if fid == 0:
5728 
        if ftype == TType.BOOL:
5729 
          self.success = iprot.readBool();
5730 
        else:
5731 
          iprot.skip(ftype)
5732 
      elif fid == 1:
5733 
        if ftype == TType.STRUCT:
5734 
          self.ucx = UserContextException()
5735 
          self.ucx.read(iprot)
5736 
        else:
5737 
          iprot.skip(ftype)
5738 
      else:
5739 
        iprot.skip(ftype)
5740 
      iprot.readFieldEnd()
5741 
    iprot.readStructEnd()
5742 
 
5743 
  def write(self, oprot):
5744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5746 
      return
559 chandransh 5747 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 5748 
    if self.success is not None:
94 ashish 5749 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5750 
      oprot.writeBool(self.success)
5751 
      oprot.writeFieldEnd()
3431 rajveer 5752 
    if self.ucx is not None:
94 ashish 5753 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5754 
      self.ucx.write(oprot)
5755 
      oprot.writeFieldEnd()
5756 
    oprot.writeFieldStop()
5757 
    oprot.writeStructEnd()
5758 
 
3431 rajveer 5759 
  def validate(self):
5760 
    return
5761 
 
5762 
 
94 ashish 5763 
  def __repr__(self):
5764 
    L = ['%s=%r' % (key, value)
5765 
      for key, value in self.__dict__.iteritems()]
5766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5767 
 
5768 
  def __eq__(self, other):
5769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5770 
 
5771 
  def __ne__(self, other):
5772 
    return not (self == other)
5773 
 
559 chandransh 5774 
class setUserAsLoggedOut_args:
94 ashish 5775 
  """
5776 
  Attributes:
5777 
   - userid
5778 
   - timestamp
5779 
  """
5780 
 
5781 
  thrift_spec = (
5782 
    None, # 0
559 chandransh 5783 
    (1, TType.I64, 'userid', None, None, ), # 1
5784 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5785 
  )
5786 
 
559 chandransh 5787 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5788 
    self.userid = userid
5789 
    self.timestamp = timestamp
5790 
 
5791 
  def read(self, iprot):
5792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5794 
      return
5795 
    iprot.readStructBegin()
5796 
    while True:
5797 
      (fname, ftype, fid) = iprot.readFieldBegin()
5798 
      if ftype == TType.STOP:
5799 
        break
5800 
      if fid == 1:
5801 
        if ftype == TType.I64:
5802 
          self.userid = iprot.readI64();
5803 
        else:
5804 
          iprot.skip(ftype)
559 chandransh 5805 
      elif fid == 2:
94 ashish 5806 
        if ftype == TType.I64:
5807 
          self.timestamp = iprot.readI64();
5808 
        else:
5809 
          iprot.skip(ftype)
5810 
      else:
5811 
        iprot.skip(ftype)
5812 
      iprot.readFieldEnd()
5813 
    iprot.readStructEnd()
5814 
 
5815 
  def write(self, oprot):
5816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5818 
      return
559 chandransh 5819 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 5820 
    if self.userid is not None:
559 chandransh 5821 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5822 
      oprot.writeI64(self.userid)
5823 
      oprot.writeFieldEnd()
3431 rajveer 5824 
    if self.timestamp is not None:
559 chandransh 5825 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5826 
      oprot.writeI64(self.timestamp)
5827 
      oprot.writeFieldEnd()
5828 
    oprot.writeFieldStop()
5829 
    oprot.writeStructEnd()
5830 
 
3431 rajveer 5831 
  def validate(self):
5832 
    return
5833 
 
5834 
 
94 ashish 5835 
  def __repr__(self):
5836 
    L = ['%s=%r' % (key, value)
5837 
      for key, value in self.__dict__.iteritems()]
5838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5839 
 
5840 
  def __eq__(self, other):
5841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5842 
 
5843 
  def __ne__(self, other):
5844 
    return not (self == other)
5845 
 
559 chandransh 5846 
class setUserAsLoggedOut_result:
94 ashish 5847 
  """
5848 
  Attributes:
5849 
   - success
5850 
   - ucx
5851 
  """
5852 
 
5853 
  thrift_spec = (
5854 
    (0, TType.BOOL, 'success', None, None, ), # 0
5855 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5856 
  )
5857 
 
5858 
  def __init__(self, success=None, ucx=None,):
5859 
    self.success = success
5860 
    self.ucx = ucx
5861 
 
5862 
  def read(self, iprot):
5863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5865 
      return
5866 
    iprot.readStructBegin()
5867 
    while True:
5868 
      (fname, ftype, fid) = iprot.readFieldBegin()
5869 
      if ftype == TType.STOP:
5870 
        break
5871 
      if fid == 0:
5872 
        if ftype == TType.BOOL:
5873 
          self.success = iprot.readBool();
5874 
        else:
5875 
          iprot.skip(ftype)
5876 
      elif fid == 1:
5877 
        if ftype == TType.STRUCT:
5878 
          self.ucx = UserContextException()
5879 
          self.ucx.read(iprot)
5880 
        else:
5881 
          iprot.skip(ftype)
5882 
      else:
5883 
        iprot.skip(ftype)
5884 
      iprot.readFieldEnd()
5885 
    iprot.readStructEnd()
5886 
 
5887 
  def write(self, oprot):
5888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5890 
      return
559 chandransh 5891 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 5892 
    if self.success is not None:
94 ashish 5893 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5894 
      oprot.writeBool(self.success)
5895 
      oprot.writeFieldEnd()
3431 rajveer 5896 
    if self.ucx is not None:
94 ashish 5897 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5898 
      self.ucx.write(oprot)
5899 
      oprot.writeFieldEnd()
5900 
    oprot.writeFieldStop()
5901 
    oprot.writeStructEnd()
5902 
 
3431 rajveer 5903 
  def validate(self):
5904 
    return
5905 
 
5906 
 
94 ashish 5907 
  def __repr__(self):
5908 
    L = ['%s=%r' % (key, value)
5909 
      for key, value in self.__dict__.iteritems()]
5910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5911 
 
5912 
  def __eq__(self, other):
5913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5914 
 
5915 
  def __ne__(self, other):
5916 
    return not (self == other)
5917 
 
559 chandransh 5918 
class setDefaultAddress_args:
94 ashish 5919 
  """
5920 
  Attributes:
5921 
   - userid
5922 
   - addressId
5923 
  """
5924 
 
5925 
  thrift_spec = (
5926 
    None, # 0
5927 
    (1, TType.I64, 'userid', None, None, ), # 1
5928 
    (2, TType.I64, 'addressId', None, None, ), # 2
5929 
  )
5930 
 
5931 
  def __init__(self, userid=None, addressId=None,):
5932 
    self.userid = userid
5933 
    self.addressId = addressId
5934 
 
5935 
  def read(self, iprot):
5936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5938 
      return
5939 
    iprot.readStructBegin()
5940 
    while True:
5941 
      (fname, ftype, fid) = iprot.readFieldBegin()
5942 
      if ftype == TType.STOP:
5943 
        break
5944 
      if fid == 1:
5945 
        if ftype == TType.I64:
5946 
          self.userid = iprot.readI64();
5947 
        else:
5948 
          iprot.skip(ftype)
5949 
      elif fid == 2:
5950 
        if ftype == TType.I64:
5951 
          self.addressId = iprot.readI64();
5952 
        else:
5953 
          iprot.skip(ftype)
5954 
      else:
5955 
        iprot.skip(ftype)
5956 
      iprot.readFieldEnd()
5957 
    iprot.readStructEnd()
5958 
 
5959 
  def write(self, oprot):
5960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5962 
      return
559 chandransh 5963 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 5964 
    if self.userid is not None:
94 ashish 5965 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5966 
      oprot.writeI64(self.userid)
5967 
      oprot.writeFieldEnd()
3431 rajveer 5968 
    if self.addressId is not None:
94 ashish 5969 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5970 
      oprot.writeI64(self.addressId)
5971 
      oprot.writeFieldEnd()
5972 
    oprot.writeFieldStop()
5973 
    oprot.writeStructEnd()
5974 
 
3431 rajveer 5975 
  def validate(self):
5976 
    return
5977 
 
5978 
 
94 ashish 5979 
  def __repr__(self):
5980 
    L = ['%s=%r' % (key, value)
5981 
      for key, value in self.__dict__.iteritems()]
5982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5983 
 
5984 
  def __eq__(self, other):
5985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5986 
 
5987 
  def __ne__(self, other):
5988 
    return not (self == other)
5989 
 
559 chandransh 5990 
class setDefaultAddress_result:
94 ashish 5991 
  """
5992 
  Attributes:
5993 
   - success
5994 
   - ucx
5995 
  """
5996 
 
5997 
  thrift_spec = (
5998 
    (0, TType.BOOL, 'success', None, None, ), # 0
5999 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6000 
  )
6001 
 
6002 
  def __init__(self, success=None, ucx=None,):
6003 
    self.success = success
6004 
    self.ucx = ucx
6005 
 
6006 
  def read(self, iprot):
6007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6009 
      return
6010 
    iprot.readStructBegin()
6011 
    while True:
6012 
      (fname, ftype, fid) = iprot.readFieldBegin()
6013 
      if ftype == TType.STOP:
6014 
        break
6015 
      if fid == 0:
6016 
        if ftype == TType.BOOL:
6017 
          self.success = iprot.readBool();
6018 
        else:
6019 
          iprot.skip(ftype)
6020 
      elif fid == 1:
6021 
        if ftype == TType.STRUCT:
6022 
          self.ucx = UserContextException()
6023 
          self.ucx.read(iprot)
6024 
        else:
6025 
          iprot.skip(ftype)
6026 
      else:
6027 
        iprot.skip(ftype)
6028 
      iprot.readFieldEnd()
6029 
    iprot.readStructEnd()
6030 
 
6031 
  def write(self, oprot):
6032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6034 
      return
559 chandransh 6035 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6036 
    if self.success is not None:
94 ashish 6037 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6038 
      oprot.writeBool(self.success)
6039 
      oprot.writeFieldEnd()
3431 rajveer 6040 
    if self.ucx is not None:
94 ashish 6041 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6042 
      self.ucx.write(oprot)
6043 
      oprot.writeFieldEnd()
6044 
    oprot.writeFieldStop()
6045 
    oprot.writeStructEnd()
6046 
 
3431 rajveer 6047 
  def validate(self):
6048 
    return
6049 
 
6050 
 
94 ashish 6051 
  def __repr__(self):
6052 
    L = ['%s=%r' % (key, value)
6053 
      for key, value in self.__dict__.iteritems()]
6054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6055 
 
6056 
  def __eq__(self, other):
6057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6058 
 
6059 
  def __ne__(self, other):
6060 
    return not (self == other)
6061 
 
559 chandransh 6062 
class updatePassword_args:
94 ashish 6063 
  """
6064 
  Attributes:
559 chandransh 6065 
   - userid
594 rajveer 6066 
   - oldPassword
6067 
   - newPassword
94 ashish 6068 
  """
6069 
 
6070 
  thrift_spec = (
6071 
    None, # 0
559 chandransh 6072 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6073 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6074 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6075 
  )
6076 
 
594 rajveer 6077 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6078 
    self.userid = userid
594 rajveer 6079 
    self.oldPassword = oldPassword
6080 
    self.newPassword = newPassword
94 ashish 6081 
 
6082 
  def read(self, iprot):
6083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6085 
      return
6086 
    iprot.readStructBegin()
6087 
    while True:
6088 
      (fname, ftype, fid) = iprot.readFieldBegin()
6089 
      if ftype == TType.STOP:
6090 
        break
6091 
      if fid == 1:
6092 
        if ftype == TType.I64:
559 chandransh 6093 
          self.userid = iprot.readI64();
94 ashish 6094 
        else:
6095 
          iprot.skip(ftype)
6096 
      elif fid == 2:
559 chandransh 6097 
        if ftype == TType.STRING:
594 rajveer 6098 
          self.oldPassword = iprot.readString();
94 ashish 6099 
        else:
6100 
          iprot.skip(ftype)
594 rajveer 6101 
      elif fid == 3:
6102 
        if ftype == TType.STRING:
6103 
          self.newPassword = iprot.readString();
6104 
        else:
6105 
          iprot.skip(ftype)
94 ashish 6106 
      else:
6107 
        iprot.skip(ftype)
6108 
      iprot.readFieldEnd()
6109 
    iprot.readStructEnd()
6110 
 
6111 
  def write(self, oprot):
6112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6114 
      return
559 chandransh 6115 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6116 
    if self.userid is not None:
559 chandransh 6117 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6118 
      oprot.writeI64(self.userid)
94 ashish 6119 
      oprot.writeFieldEnd()
3431 rajveer 6120 
    if self.oldPassword is not None:
594 rajveer 6121 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6122 
      oprot.writeString(self.oldPassword)
94 ashish 6123 
      oprot.writeFieldEnd()
3431 rajveer 6124 
    if self.newPassword is not None:
594 rajveer 6125 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6126 
      oprot.writeString(self.newPassword)
6127 
      oprot.writeFieldEnd()
94 ashish 6128 
    oprot.writeFieldStop()
6129 
    oprot.writeStructEnd()
6130 
 
3431 rajveer 6131 
  def validate(self):
6132 
    return
6133 
 
6134 
 
94 ashish 6135 
  def __repr__(self):
6136 
    L = ['%s=%r' % (key, value)
6137 
      for key, value in self.__dict__.iteritems()]
6138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6139 
 
6140 
  def __eq__(self, other):
6141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6142 
 
6143 
  def __ne__(self, other):
6144 
    return not (self == other)
6145 
 
559 chandransh 6146 
class updatePassword_result:
94 ashish 6147 
  """
6148 
  Attributes:
6149 
   - success
6150 
   - ucx
6151 
  """
6152 
 
6153 
  thrift_spec = (
6154 
    (0, TType.BOOL, 'success', None, None, ), # 0
6155 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6156 
  )
6157 
 
6158 
  def __init__(self, success=None, ucx=None,):
6159 
    self.success = success
6160 
    self.ucx = ucx
6161 
 
6162 
  def read(self, iprot):
6163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6165 
      return
6166 
    iprot.readStructBegin()
6167 
    while True:
6168 
      (fname, ftype, fid) = iprot.readFieldBegin()
6169 
      if ftype == TType.STOP:
6170 
        break
6171 
      if fid == 0:
6172 
        if ftype == TType.BOOL:
6173 
          self.success = iprot.readBool();
6174 
        else:
6175 
          iprot.skip(ftype)
6176 
      elif fid == 1:
6177 
        if ftype == TType.STRUCT:
6178 
          self.ucx = UserContextException()
6179 
          self.ucx.read(iprot)
6180 
        else:
6181 
          iprot.skip(ftype)
6182 
      else:
6183 
        iprot.skip(ftype)
6184 
      iprot.readFieldEnd()
6185 
    iprot.readStructEnd()
6186 
 
6187 
  def write(self, oprot):
6188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6190 
      return
559 chandransh 6191 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6192 
    if self.success is not None:
94 ashish 6193 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6194 
      oprot.writeBool(self.success)
6195 
      oprot.writeFieldEnd()
3431 rajveer 6196 
    if self.ucx is not None:
94 ashish 6197 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6198 
      self.ucx.write(oprot)
6199 
      oprot.writeFieldEnd()
6200 
    oprot.writeFieldStop()
6201 
    oprot.writeStructEnd()
6202 
 
3431 rajveer 6203 
  def validate(self):
6204 
    return
6205 
 
6206 
 
94 ashish 6207 
  def __repr__(self):
6208 
    L = ['%s=%r' % (key, value)
6209 
      for key, value in self.__dict__.iteritems()]
6210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6211 
 
6212 
  def __eq__(self, other):
6213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6214 
 
6215 
  def __ne__(self, other):
6216 
    return not (self == other)
6217 
 
581 rajveer 6218 
class forgotPassword_args:
6219 
  """
6220 
  Attributes:
6221 
   - email
884 rajveer 6222 
   - newPassword
581 rajveer 6223 
  """
6224 
 
6225 
  thrift_spec = (
6226 
    None, # 0
6227 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6228 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6229 
  )
6230 
 
884 rajveer 6231 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6232 
    self.email = email
884 rajveer 6233 
    self.newPassword = newPassword
581 rajveer 6234 
 
6235 
  def read(self, iprot):
6236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6238 
      return
6239 
    iprot.readStructBegin()
6240 
    while True:
6241 
      (fname, ftype, fid) = iprot.readFieldBegin()
6242 
      if ftype == TType.STOP:
6243 
        break
6244 
      if fid == 1:
6245 
        if ftype == TType.STRING:
6246 
          self.email = iprot.readString();
6247 
        else:
6248 
          iprot.skip(ftype)
884 rajveer 6249 
      elif fid == 2:
6250 
        if ftype == TType.STRING:
6251 
          self.newPassword = iprot.readString();
6252 
        else:
6253 
          iprot.skip(ftype)
581 rajveer 6254 
      else:
6255 
        iprot.skip(ftype)
6256 
      iprot.readFieldEnd()
6257 
    iprot.readStructEnd()
6258 
 
6259 
  def write(self, oprot):
6260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6262 
      return
6263 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6264 
    if self.email is not None:
581 rajveer 6265 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6266 
      oprot.writeString(self.email)
6267 
      oprot.writeFieldEnd()
3431 rajveer 6268 
    if self.newPassword is not None:
884 rajveer 6269 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6270 
      oprot.writeString(self.newPassword)
6271 
      oprot.writeFieldEnd()
581 rajveer 6272 
    oprot.writeFieldStop()
6273 
    oprot.writeStructEnd()
6274 
 
3431 rajveer 6275 
  def validate(self):
6276 
    return
6277 
 
6278 
 
581 rajveer 6279 
  def __repr__(self):
6280 
    L = ['%s=%r' % (key, value)
6281 
      for key, value in self.__dict__.iteritems()]
6282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6283 
 
6284 
  def __eq__(self, other):
6285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6286 
 
6287 
  def __ne__(self, other):
6288 
    return not (self == other)
6289 
 
6290 
class forgotPassword_result:
6291 
  """
6292 
  Attributes:
6293 
   - success
6294 
   - ucx
6295 
  """
6296 
 
6297 
  thrift_spec = (
6298 
    (0, TType.BOOL, 'success', None, None, ), # 0
6299 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6300 
  )
6301 
 
6302 
  def __init__(self, success=None, ucx=None,):
6303 
    self.success = success
6304 
    self.ucx = ucx
6305 
 
6306 
  def read(self, iprot):
6307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6309 
      return
6310 
    iprot.readStructBegin()
6311 
    while True:
6312 
      (fname, ftype, fid) = iprot.readFieldBegin()
6313 
      if ftype == TType.STOP:
6314 
        break
6315 
      if fid == 0:
6316 
        if ftype == TType.BOOL:
6317 
          self.success = iprot.readBool();
6318 
        else:
6319 
          iprot.skip(ftype)
6320 
      elif fid == 1:
6321 
        if ftype == TType.STRUCT:
6322 
          self.ucx = UserContextException()
6323 
          self.ucx.read(iprot)
6324 
        else:
6325 
          iprot.skip(ftype)
6326 
      else:
6327 
        iprot.skip(ftype)
6328 
      iprot.readFieldEnd()
6329 
    iprot.readStructEnd()
6330 
 
6331 
  def write(self, oprot):
6332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6334 
      return
6335 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6336 
    if self.success is not None:
581 rajveer 6337 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6338 
      oprot.writeBool(self.success)
6339 
      oprot.writeFieldEnd()
3431 rajveer 6340 
    if self.ucx is not None:
581 rajveer 6341 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6342 
      self.ucx.write(oprot)
6343 
      oprot.writeFieldEnd()
6344 
    oprot.writeFieldStop()
6345 
    oprot.writeStructEnd()
6346 
 
3431 rajveer 6347 
  def validate(self):
6348 
    return
6349 
 
6350 
 
581 rajveer 6351 
  def __repr__(self):
6352 
    L = ['%s=%r' % (key, value)
6353 
      for key, value in self.__dict__.iteritems()]
6354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6355 
 
6356 
  def __eq__(self, other):
6357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6358 
 
6359 
  def __ne__(self, other):
6360 
    return not (self == other)
6361 
 
594 rajveer 6362 
class getAllAddressesForUser_args:
6363 
  """
6364 
  Attributes:
6365 
   - userId
6366 
  """
6367 
 
6368 
  thrift_spec = (
6369 
    None, # 0
6370 
    (1, TType.I64, 'userId', None, None, ), # 1
6371 
  )
6372 
 
6373 
  def __init__(self, userId=None,):
6374 
    self.userId = userId
6375 
 
6376 
  def read(self, iprot):
6377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6379 
      return
6380 
    iprot.readStructBegin()
6381 
    while True:
6382 
      (fname, ftype, fid) = iprot.readFieldBegin()
6383 
      if ftype == TType.STOP:
6384 
        break
6385 
      if fid == 1:
6386 
        if ftype == TType.I64:
6387 
          self.userId = iprot.readI64();
6388 
        else:
6389 
          iprot.skip(ftype)
6390 
      else:
6391 
        iprot.skip(ftype)
6392 
      iprot.readFieldEnd()
6393 
    iprot.readStructEnd()
6394 
 
6395 
  def write(self, oprot):
6396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6398 
      return
6399 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6400 
    if self.userId is not None:
594 rajveer 6401 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6402 
      oprot.writeI64(self.userId)
6403 
      oprot.writeFieldEnd()
6404 
    oprot.writeFieldStop()
6405 
    oprot.writeStructEnd()
6406 
 
3431 rajveer 6407 
  def validate(self):
6408 
    return
6409 
 
6410 
 
594 rajveer 6411 
  def __repr__(self):
6412 
    L = ['%s=%r' % (key, value)
6413 
      for key, value in self.__dict__.iteritems()]
6414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6415 
 
6416 
  def __eq__(self, other):
6417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6418 
 
6419 
  def __ne__(self, other):
6420 
    return not (self == other)
6421 
 
6422 
class getAllAddressesForUser_result:
6423 
  """
6424 
  Attributes:
6425 
   - success
6426 
   - ucx
6427 
  """
6428 
 
6429 
  thrift_spec = (
6430 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6431 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6432 
  )
6433 
 
6434 
  def __init__(self, success=None, ucx=None,):
6435 
    self.success = success
6436 
    self.ucx = ucx
6437 
 
6438 
  def read(self, iprot):
6439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6441 
      return
6442 
    iprot.readStructBegin()
6443 
    while True:
6444 
      (fname, ftype, fid) = iprot.readFieldBegin()
6445 
      if ftype == TType.STOP:
6446 
        break
6447 
      if fid == 0:
6448 
        if ftype == TType.LIST:
6449 
          self.success = []
7746 amit.gupta 6450 
          (_etype93, _size90) = iprot.readListBegin()
6451 
          for _i94 in xrange(_size90):
6452 
            _elem95 = Address()
6453 
            _elem95.read(iprot)
6454 
            self.success.append(_elem95)
594 rajveer 6455 
          iprot.readListEnd()
6456 
        else:
6457 
          iprot.skip(ftype)
6458 
      elif fid == 1:
6459 
        if ftype == TType.STRUCT:
6460 
          self.ucx = UserContextException()
6461 
          self.ucx.read(iprot)
6462 
        else:
6463 
          iprot.skip(ftype)
6464 
      else:
6465 
        iprot.skip(ftype)
6466 
      iprot.readFieldEnd()
6467 
    iprot.readStructEnd()
6468 
 
6469 
  def write(self, oprot):
6470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6472 
      return
6473 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 6474 
    if self.success is not None:
594 rajveer 6475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 6477 
      for iter96 in self.success:
6478 
        iter96.write(oprot)
594 rajveer 6479 
      oprot.writeListEnd()
6480 
      oprot.writeFieldEnd()
3431 rajveer 6481 
    if self.ucx is not None:
594 rajveer 6482 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6483 
      self.ucx.write(oprot)
6484 
      oprot.writeFieldEnd()
6485 
    oprot.writeFieldStop()
6486 
    oprot.writeStructEnd()
6487 
 
3431 rajveer 6488 
  def validate(self):
6489 
    return
6490 
 
6491 
 
594 rajveer 6492 
  def __repr__(self):
6493 
    L = ['%s=%r' % (key, value)
6494 
      for key, value in self.__dict__.iteritems()]
6495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6496 
 
6497 
  def __eq__(self, other):
6498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6499 
 
6500 
  def __ne__(self, other):
6501 
    return not (self == other)
6502 
 
1894 vikas 6503 
class getAddressById_args:
6504 
  """
6505 
  Attributes:
6506 
   - addressId
6507 
  """
6508 
 
6509 
  thrift_spec = (
6510 
    None, # 0
6511 
    (1, TType.I64, 'addressId', None, None, ), # 1
6512 
  )
6513 
 
6514 
  def __init__(self, addressId=None,):
6515 
    self.addressId = addressId
6516 
 
6517 
  def read(self, iprot):
6518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6520 
      return
6521 
    iprot.readStructBegin()
6522 
    while True:
6523 
      (fname, ftype, fid) = iprot.readFieldBegin()
6524 
      if ftype == TType.STOP:
6525 
        break
6526 
      if fid == 1:
6527 
        if ftype == TType.I64:
6528 
          self.addressId = iprot.readI64();
6529 
        else:
6530 
          iprot.skip(ftype)
6531 
      else:
6532 
        iprot.skip(ftype)
6533 
      iprot.readFieldEnd()
6534 
    iprot.readStructEnd()
6535 
 
6536 
  def write(self, oprot):
6537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6539 
      return
6540 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 6541 
    if self.addressId is not None:
1894 vikas 6542 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6543 
      oprot.writeI64(self.addressId)
6544 
      oprot.writeFieldEnd()
6545 
    oprot.writeFieldStop()
6546 
    oprot.writeStructEnd()
6547 
 
3431 rajveer 6548 
  def validate(self):
6549 
    return
6550 
 
6551 
 
1894 vikas 6552 
  def __repr__(self):
6553 
    L = ['%s=%r' % (key, value)
6554 
      for key, value in self.__dict__.iteritems()]
6555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6556 
 
6557 
  def __eq__(self, other):
6558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6559 
 
6560 
  def __ne__(self, other):
6561 
    return not (self == other)
6562 
 
6563 
class getAddressById_result:
6564 
  """
6565 
  Attributes:
6566 
   - success
6567 
   - ucx
6568 
  """
6569 
 
6570 
  thrift_spec = (
6571 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6572 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6573 
  )
6574 
 
6575 
  def __init__(self, success=None, ucx=None,):
6576 
    self.success = success
6577 
    self.ucx = ucx
6578 
 
6579 
  def read(self, iprot):
6580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6582 
      return
6583 
    iprot.readStructBegin()
6584 
    while True:
6585 
      (fname, ftype, fid) = iprot.readFieldBegin()
6586 
      if ftype == TType.STOP:
6587 
        break
6588 
      if fid == 0:
6589 
        if ftype == TType.STRUCT:
6590 
          self.success = Address()
6591 
          self.success.read(iprot)
6592 
        else:
6593 
          iprot.skip(ftype)
6594 
      elif fid == 1:
6595 
        if ftype == TType.STRUCT:
6596 
          self.ucx = UserContextException()
6597 
          self.ucx.read(iprot)
6598 
        else:
6599 
          iprot.skip(ftype)
6600 
      else:
6601 
        iprot.skip(ftype)
6602 
      iprot.readFieldEnd()
6603 
    iprot.readStructEnd()
6604 
 
6605 
  def write(self, oprot):
6606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6608 
      return
6609 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 6610 
    if self.success is not None:
1894 vikas 6611 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6612 
      self.success.write(oprot)
6613 
      oprot.writeFieldEnd()
3431 rajveer 6614 
    if self.ucx is not None:
1894 vikas 6615 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6616 
      self.ucx.write(oprot)
6617 
      oprot.writeFieldEnd()
6618 
    oprot.writeFieldStop()
6619 
    oprot.writeStructEnd()
6620 
 
3431 rajveer 6621 
  def validate(self):
6622 
    return
6623 
 
6624 
 
1894 vikas 6625 
  def __repr__(self):
6626 
    L = ['%s=%r' % (key, value)
6627 
      for key, value in self.__dict__.iteritems()]
6628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6629 
 
6630 
  def __eq__(self, other):
6631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6632 
 
6633 
  def __ne__(self, other):
6634 
    return not (self == other)
6635 
 
594 rajveer 6636 
class getDefaultAddressId_args:
6637 
  """
6638 
  Attributes:
6639 
   - userId
6640 
  """
6641 
 
6642 
  thrift_spec = (
6643 
    None, # 0
6644 
    (1, TType.I64, 'userId', None, None, ), # 1
6645 
  )
6646 
 
6647 
  def __init__(self, userId=None,):
6648 
    self.userId = userId
6649 
 
6650 
  def read(self, iprot):
6651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6653 
      return
6654 
    iprot.readStructBegin()
6655 
    while True:
6656 
      (fname, ftype, fid) = iprot.readFieldBegin()
6657 
      if ftype == TType.STOP:
6658 
        break
6659 
      if fid == 1:
6660 
        if ftype == TType.I64:
6661 
          self.userId = iprot.readI64();
6662 
        else:
6663 
          iprot.skip(ftype)
6664 
      else:
6665 
        iprot.skip(ftype)
6666 
      iprot.readFieldEnd()
6667 
    iprot.readStructEnd()
6668 
 
6669 
  def write(self, oprot):
6670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6672 
      return
6673 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 6674 
    if self.userId is not None:
594 rajveer 6675 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6676 
      oprot.writeI64(self.userId)
6677 
      oprot.writeFieldEnd()
6678 
    oprot.writeFieldStop()
6679 
    oprot.writeStructEnd()
6680 
 
3431 rajveer 6681 
  def validate(self):
6682 
    return
6683 
 
6684 
 
594 rajveer 6685 
  def __repr__(self):
6686 
    L = ['%s=%r' % (key, value)
6687 
      for key, value in self.__dict__.iteritems()]
6688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6689 
 
6690 
  def __eq__(self, other):
6691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6692 
 
6693 
  def __ne__(self, other):
6694 
    return not (self == other)
6695 
 
6696 
class getDefaultAddressId_result:
6697 
  """
6698 
  Attributes:
6699 
   - success
6700 
   - ucx
6701 
  """
6702 
 
6703 
  thrift_spec = (
6704 
    (0, TType.I64, 'success', None, None, ), # 0
6705 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6706 
  )
6707 
 
6708 
  def __init__(self, success=None, ucx=None,):
6709 
    self.success = success
6710 
    self.ucx = ucx
6711 
 
6712 
  def read(self, iprot):
6713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6715 
      return
6716 
    iprot.readStructBegin()
6717 
    while True:
6718 
      (fname, ftype, fid) = iprot.readFieldBegin()
6719 
      if ftype == TType.STOP:
6720 
        break
6721 
      if fid == 0:
6722 
        if ftype == TType.I64:
6723 
          self.success = iprot.readI64();
6724 
        else:
6725 
          iprot.skip(ftype)
6726 
      elif fid == 1:
6727 
        if ftype == TType.STRUCT:
6728 
          self.ucx = UserContextException()
6729 
          self.ucx.read(iprot)
6730 
        else:
6731 
          iprot.skip(ftype)
6732 
      else:
6733 
        iprot.skip(ftype)
6734 
      iprot.readFieldEnd()
6735 
    iprot.readStructEnd()
6736 
 
6737 
  def write(self, oprot):
6738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6740 
      return
6741 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 6742 
    if self.success is not None:
594 rajveer 6743 
      oprot.writeFieldBegin('success', TType.I64, 0)
6744 
      oprot.writeI64(self.success)
6745 
      oprot.writeFieldEnd()
3431 rajveer 6746 
    if self.ucx is not None:
594 rajveer 6747 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6748 
      self.ucx.write(oprot)
6749 
      oprot.writeFieldEnd()
6750 
    oprot.writeFieldStop()
6751 
    oprot.writeStructEnd()
6752 
 
3431 rajveer 6753 
  def validate(self):
6754 
    return
6755 
 
6756 
 
594 rajveer 6757 
  def __repr__(self):
6758 
    L = ['%s=%r' % (key, value)
6759 
      for key, value in self.__dict__.iteritems()]
6760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6761 
 
6762 
  def __eq__(self, other):
6763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6764 
 
6765 
  def __ne__(self, other):
6766 
    return not (self == other)
6767 
 
785 rajveer 6768 
class getDefaultPincode_args:
6769 
  """
6770 
  Attributes:
6771 
   - userId
6772 
  """
6773 
 
6774 
  thrift_spec = (
6775 
    None, # 0
6776 
    (1, TType.I64, 'userId', None, None, ), # 1
6777 
  )
6778 
 
6779 
  def __init__(self, userId=None,):
6780 
    self.userId = userId
6781 
 
6782 
  def read(self, iprot):
6783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6785 
      return
6786 
    iprot.readStructBegin()
6787 
    while True:
6788 
      (fname, ftype, fid) = iprot.readFieldBegin()
6789 
      if ftype == TType.STOP:
6790 
        break
6791 
      if fid == 1:
6792 
        if ftype == TType.I64:
6793 
          self.userId = iprot.readI64();
6794 
        else:
6795 
          iprot.skip(ftype)
6796 
      else:
6797 
        iprot.skip(ftype)
6798 
      iprot.readFieldEnd()
6799 
    iprot.readStructEnd()
6800 
 
6801 
  def write(self, oprot):
6802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6804 
      return
6805 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 6806 
    if self.userId is not None:
785 rajveer 6807 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6808 
      oprot.writeI64(self.userId)
6809 
      oprot.writeFieldEnd()
6810 
    oprot.writeFieldStop()
6811 
    oprot.writeStructEnd()
6812 
 
3431 rajveer 6813 
  def validate(self):
6814 
    return
6815 
 
6816 
 
785 rajveer 6817 
  def __repr__(self):
6818 
    L = ['%s=%r' % (key, value)
6819 
      for key, value in self.__dict__.iteritems()]
6820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6821 
 
6822 
  def __eq__(self, other):
6823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6824 
 
6825 
  def __ne__(self, other):
6826 
    return not (self == other)
6827 
 
6828 
class getDefaultPincode_result:
6829 
  """
6830 
  Attributes:
6831 
   - success
6832 
   - ucx
6833 
  """
6834 
 
6835 
  thrift_spec = (
6836 
    (0, TType.STRING, 'success', None, None, ), # 0
6837 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6838 
  )
6839 
 
6840 
  def __init__(self, success=None, ucx=None,):
6841 
    self.success = success
6842 
    self.ucx = ucx
6843 
 
6844 
  def read(self, iprot):
6845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6847 
      return
6848 
    iprot.readStructBegin()
6849 
    while True:
6850 
      (fname, ftype, fid) = iprot.readFieldBegin()
6851 
      if ftype == TType.STOP:
6852 
        break
6853 
      if fid == 0:
6854 
        if ftype == TType.STRING:
6855 
          self.success = iprot.readString();
6856 
        else:
6857 
          iprot.skip(ftype)
6858 
      elif fid == 1:
6859 
        if ftype == TType.STRUCT:
6860 
          self.ucx = UserContextException()
6861 
          self.ucx.read(iprot)
6862 
        else:
6863 
          iprot.skip(ftype)
6864 
      else:
6865 
        iprot.skip(ftype)
6866 
      iprot.readFieldEnd()
6867 
    iprot.readStructEnd()
6868 
 
6869 
  def write(self, oprot):
6870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6872 
      return
6873 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 6874 
    if self.success is not None:
785 rajveer 6875 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6876 
      oprot.writeString(self.success)
6877 
      oprot.writeFieldEnd()
3431 rajveer 6878 
    if self.ucx is not None:
785 rajveer 6879 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6880 
      self.ucx.write(oprot)
6881 
      oprot.writeFieldEnd()
6882 
    oprot.writeFieldStop()
6883 
    oprot.writeStructEnd()
6884 
 
3431 rajveer 6885 
  def validate(self):
6886 
    return
6887 
 
6888 
 
785 rajveer 6889 
  def __repr__(self):
6890 
    L = ['%s=%r' % (key, value)
6891 
      for key, value in self.__dict__.iteritems()]
6892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6893 
 
6894 
  def __eq__(self, other):
6895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6896 
 
6897 
  def __ne__(self, other):
6898 
    return not (self == other)
6899 
 
1274 varun.gupt 6900 
class saveUserCommunication_args:
6901 
  """
6902 
  Attributes:
6903 
   - userId
6904 
   - replyTo
6905 
   - communicationType
6906 
   - orderId
6907 
   - airwaybillNo
6908 
   - productName
6909 
   - subject
6910 
   - message
6911 
  """
6912 
 
6913 
  thrift_spec = (
6914 
    None, # 0
6915 
    (1, TType.I64, 'userId', None, None, ), # 1
6916 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6917 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6918 
    (4, TType.I64, 'orderId', None, None, ), # 4
6919 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6920 
    (6, TType.STRING, 'productName', None, None, ), # 6
6921 
    (7, TType.STRING, 'subject', None, None, ), # 7
6922 
    (8, TType.STRING, 'message', None, None, ), # 8
6923 
  )
6924 
 
6925 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6926 
    self.userId = userId
6927 
    self.replyTo = replyTo
6928 
    self.communicationType = communicationType
6929 
    self.orderId = orderId
6930 
    self.airwaybillNo = airwaybillNo
6931 
    self.productName = productName
6932 
    self.subject = subject
6933 
    self.message = message
6934 
 
6935 
  def read(self, iprot):
6936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6938 
      return
6939 
    iprot.readStructBegin()
6940 
    while True:
6941 
      (fname, ftype, fid) = iprot.readFieldBegin()
6942 
      if ftype == TType.STOP:
6943 
        break
6944 
      if fid == 1:
6945 
        if ftype == TType.I64:
6946 
          self.userId = iprot.readI64();
6947 
        else:
6948 
          iprot.skip(ftype)
6949 
      elif fid == 2:
6950 
        if ftype == TType.STRING:
6951 
          self.replyTo = iprot.readString();
6952 
        else:
6953 
          iprot.skip(ftype)
6954 
      elif fid == 3:
6955 
        if ftype == TType.I64:
6956 
          self.communicationType = iprot.readI64();
6957 
        else:
6958 
          iprot.skip(ftype)
6959 
      elif fid == 4:
6960 
        if ftype == TType.I64:
6961 
          self.orderId = iprot.readI64();
6962 
        else:
6963 
          iprot.skip(ftype)
6964 
      elif fid == 5:
6965 
        if ftype == TType.STRING:
6966 
          self.airwaybillNo = iprot.readString();
6967 
        else:
6968 
          iprot.skip(ftype)
6969 
      elif fid == 6:
6970 
        if ftype == TType.STRING:
6971 
          self.productName = iprot.readString();
6972 
        else:
6973 
          iprot.skip(ftype)
6974 
      elif fid == 7:
6975 
        if ftype == TType.STRING:
6976 
          self.subject = iprot.readString();
6977 
        else:
6978 
          iprot.skip(ftype)
6979 
      elif fid == 8:
6980 
        if ftype == TType.STRING:
6981 
          self.message = iprot.readString();
6982 
        else:
6983 
          iprot.skip(ftype)
6984 
      else:
6985 
        iprot.skip(ftype)
6986 
      iprot.readFieldEnd()
6987 
    iprot.readStructEnd()
6988 
 
6989 
  def write(self, oprot):
6990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6992 
      return
6993 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 6994 
    if self.userId is not None:
1274 varun.gupt 6995 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6996 
      oprot.writeI64(self.userId)
6997 
      oprot.writeFieldEnd()
3431 rajveer 6998 
    if self.replyTo is not None:
1274 varun.gupt 6999 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7000 
      oprot.writeString(self.replyTo)
7001 
      oprot.writeFieldEnd()
3431 rajveer 7002 
    if self.communicationType is not None:
1274 varun.gupt 7003 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7004 
      oprot.writeI64(self.communicationType)
7005 
      oprot.writeFieldEnd()
3431 rajveer 7006 
    if self.orderId is not None:
1274 varun.gupt 7007 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7008 
      oprot.writeI64(self.orderId)
7009 
      oprot.writeFieldEnd()
3431 rajveer 7010 
    if self.airwaybillNo is not None:
1274 varun.gupt 7011 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7012 
      oprot.writeString(self.airwaybillNo)
7013 
      oprot.writeFieldEnd()
3431 rajveer 7014 
    if self.productName is not None:
1274 varun.gupt 7015 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7016 
      oprot.writeString(self.productName)
7017 
      oprot.writeFieldEnd()
3431 rajveer 7018 
    if self.subject is not None:
1274 varun.gupt 7019 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7020 
      oprot.writeString(self.subject)
7021 
      oprot.writeFieldEnd()
3431 rajveer 7022 
    if self.message is not None:
1274 varun.gupt 7023 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7024 
      oprot.writeString(self.message)
7025 
      oprot.writeFieldEnd()
7026 
    oprot.writeFieldStop()
7027 
    oprot.writeStructEnd()
7028 
 
3431 rajveer 7029 
  def validate(self):
7030 
    return
7031 
 
7032 
 
1274 varun.gupt 7033 
  def __repr__(self):
7034 
    L = ['%s=%r' % (key, value)
7035 
      for key, value in self.__dict__.iteritems()]
7036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7037 
 
7038 
  def __eq__(self, other):
7039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7040 
 
7041 
  def __ne__(self, other):
7042 
    return not (self == other)
7043 
 
7044 
class saveUserCommunication_result:
7045 
  """
7046 
  Attributes:
7047 
   - success
7048 
   - ucx
7049 
  """
7050 
 
7051 
  thrift_spec = (
7052 
    (0, TType.BOOL, 'success', None, None, ), # 0
7053 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7054 
  )
7055 
 
7056 
  def __init__(self, success=None, ucx=None,):
7057 
    self.success = success
7058 
    self.ucx = ucx
7059 
 
7060 
  def read(self, iprot):
7061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7063 
      return
7064 
    iprot.readStructBegin()
7065 
    while True:
7066 
      (fname, ftype, fid) = iprot.readFieldBegin()
7067 
      if ftype == TType.STOP:
7068 
        break
7069 
      if fid == 0:
7070 
        if ftype == TType.BOOL:
7071 
          self.success = iprot.readBool();
7072 
        else:
7073 
          iprot.skip(ftype)
7074 
      elif fid == 1:
7075 
        if ftype == TType.STRUCT:
7076 
          self.ucx = UserCommunicationException()
7077 
          self.ucx.read(iprot)
7078 
        else:
7079 
          iprot.skip(ftype)
7080 
      else:
7081 
        iprot.skip(ftype)
7082 
      iprot.readFieldEnd()
7083 
    iprot.readStructEnd()
7084 
 
7085 
  def write(self, oprot):
7086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7088 
      return
7089 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7090 
    if self.success is not None:
1274 varun.gupt 7091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7092 
      oprot.writeBool(self.success)
7093 
      oprot.writeFieldEnd()
3431 rajveer 7094 
    if self.ucx is not None:
1274 varun.gupt 7095 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7096 
      self.ucx.write(oprot)
7097 
      oprot.writeFieldEnd()
7098 
    oprot.writeFieldStop()
7099 
    oprot.writeStructEnd()
7100 
 
3431 rajveer 7101 
  def validate(self):
7102 
    return
7103 
 
7104 
 
1274 varun.gupt 7105 
  def __repr__(self):
7106 
    L = ['%s=%r' % (key, value)
7107 
      for key, value in self.__dict__.iteritems()]
7108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7109 
 
7110 
  def __eq__(self, other):
7111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7112 
 
7113 
  def __ne__(self, other):
7114 
    return not (self == other)
7115 
 
1590 varun.gupt 7116 
class getUserCommunicationById_args:
7117 
  """
7118 
  Attributes:
7119 
   - id
7120 
  """
7121 
 
7122 
  thrift_spec = (
7123 
    None, # 0
7124 
    (1, TType.I64, 'id', None, None, ), # 1
7125 
  )
7126 
 
7127 
  def __init__(self, id=None,):
7128 
    self.id = id
7129 
 
7130 
  def read(self, iprot):
7131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7133 
      return
7134 
    iprot.readStructBegin()
7135 
    while True:
7136 
      (fname, ftype, fid) = iprot.readFieldBegin()
7137 
      if ftype == TType.STOP:
7138 
        break
7139 
      if fid == 1:
7140 
        if ftype == TType.I64:
7141 
          self.id = iprot.readI64();
7142 
        else:
7143 
          iprot.skip(ftype)
7144 
      else:
7145 
        iprot.skip(ftype)
7146 
      iprot.readFieldEnd()
7147 
    iprot.readStructEnd()
7148 
 
7149 
  def write(self, oprot):
7150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7152 
      return
7153 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7154 
    if self.id is not None:
1590 varun.gupt 7155 
      oprot.writeFieldBegin('id', TType.I64, 1)
7156 
      oprot.writeI64(self.id)
7157 
      oprot.writeFieldEnd()
7158 
    oprot.writeFieldStop()
7159 
    oprot.writeStructEnd()
7160 
 
3431 rajveer 7161 
  def validate(self):
7162 
    return
7163 
 
7164 
 
1590 varun.gupt 7165 
  def __repr__(self):
7166 
    L = ['%s=%r' % (key, value)
7167 
      for key, value in self.__dict__.iteritems()]
7168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7169 
 
7170 
  def __eq__(self, other):
7171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7172 
 
7173 
  def __ne__(self, other):
7174 
    return not (self == other)
7175 
 
7176 
class getUserCommunicationById_result:
7177 
  """
7178 
  Attributes:
7179 
   - success
7180 
   - ucx
7181 
  """
7182 
 
7183 
  thrift_spec = (
7184 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7185 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7186 
  )
7187 
 
7188 
  def __init__(self, success=None, ucx=None,):
7189 
    self.success = success
7190 
    self.ucx = ucx
7191 
 
7192 
  def read(self, iprot):
7193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7195 
      return
7196 
    iprot.readStructBegin()
7197 
    while True:
7198 
      (fname, ftype, fid) = iprot.readFieldBegin()
7199 
      if ftype == TType.STOP:
7200 
        break
7201 
      if fid == 0:
7202 
        if ftype == TType.STRUCT:
7203 
          self.success = UserCommunication()
7204 
          self.success.read(iprot)
7205 
        else:
7206 
          iprot.skip(ftype)
7207 
      elif fid == 1:
7208 
        if ftype == TType.STRUCT:
7209 
          self.ucx = UserCommunicationException()
7210 
          self.ucx.read(iprot)
7211 
        else:
7212 
          iprot.skip(ftype)
7213 
      else:
7214 
        iprot.skip(ftype)
7215 
      iprot.readFieldEnd()
7216 
    iprot.readStructEnd()
7217 
 
7218 
  def write(self, oprot):
7219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7221 
      return
7222 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7223 
    if self.success is not None:
1590 varun.gupt 7224 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7225 
      self.success.write(oprot)
7226 
      oprot.writeFieldEnd()
3431 rajveer 7227 
    if self.ucx is not None:
1590 varun.gupt 7228 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7229 
      self.ucx.write(oprot)
7230 
      oprot.writeFieldEnd()
7231 
    oprot.writeFieldStop()
7232 
    oprot.writeStructEnd()
7233 
 
3431 rajveer 7234 
  def validate(self):
7235 
    return
7236 
 
7237 
 
1590 varun.gupt 7238 
  def __repr__(self):
7239 
    L = ['%s=%r' % (key, value)
7240 
      for key, value in self.__dict__.iteritems()]
7241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7242 
 
7243 
  def __eq__(self, other):
7244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7245 
 
7246 
  def __ne__(self, other):
7247 
    return not (self == other)
7248 
 
7249 
class getUserCommunicationByUser_args:
7250 
  """
7251 
  Attributes:
7252 
   - userId
7253 
  """
7254 
 
7255 
  thrift_spec = (
7256 
    None, # 0
7257 
    (1, TType.I64, 'userId', None, None, ), # 1
7258 
  )
7259 
 
7260 
  def __init__(self, userId=None,):
7261 
    self.userId = userId
7262 
 
7263 
  def read(self, iprot):
7264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7266 
      return
7267 
    iprot.readStructBegin()
7268 
    while True:
7269 
      (fname, ftype, fid) = iprot.readFieldBegin()
7270 
      if ftype == TType.STOP:
7271 
        break
7272 
      if fid == 1:
7273 
        if ftype == TType.I64:
7274 
          self.userId = iprot.readI64();
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      else:
7278 
        iprot.skip(ftype)
7279 
      iprot.readFieldEnd()
7280 
    iprot.readStructEnd()
7281 
 
7282 
  def write(self, oprot):
7283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7285 
      return
7286 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7287 
    if self.userId is not None:
1590 varun.gupt 7288 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7289 
      oprot.writeI64(self.userId)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
3431 rajveer 7294 
  def validate(self):
7295 
    return
7296 
 
7297 
 
1590 varun.gupt 7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
7309 
class getUserCommunicationByUser_result:
7310 
  """
7311 
  Attributes:
7312 
   - success
7313 
   - ucx
7314 
  """
7315 
 
7316 
  thrift_spec = (
7317 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7318 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7319 
  )
7320 
 
7321 
  def __init__(self, success=None, ucx=None,):
7322 
    self.success = success
7323 
    self.ucx = ucx
7324 
 
7325 
  def read(self, iprot):
7326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7328 
      return
7329 
    iprot.readStructBegin()
7330 
    while True:
7331 
      (fname, ftype, fid) = iprot.readFieldBegin()
7332 
      if ftype == TType.STOP:
7333 
        break
7334 
      if fid == 0:
7335 
        if ftype == TType.LIST:
7336 
          self.success = []
7746 amit.gupta 7337 
          (_etype100, _size97) = iprot.readListBegin()
7338 
          for _i101 in xrange(_size97):
7339 
            _elem102 = UserCommunication()
7340 
            _elem102.read(iprot)
7341 
            self.success.append(_elem102)
1590 varun.gupt 7342 
          iprot.readListEnd()
7343 
        else:
7344 
          iprot.skip(ftype)
7345 
      elif fid == 1:
7346 
        if ftype == TType.STRUCT:
7347 
          self.ucx = UserCommunicationException()
7348 
          self.ucx.read(iprot)
7349 
        else:
7350 
          iprot.skip(ftype)
7351 
      else:
7352 
        iprot.skip(ftype)
7353 
      iprot.readFieldEnd()
7354 
    iprot.readStructEnd()
7355 
 
7356 
  def write(self, oprot):
7357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7359 
      return
7360 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7361 
    if self.success is not None:
1590 varun.gupt 7362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7363 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 7364 
      for iter103 in self.success:
7365 
        iter103.write(oprot)
1590 varun.gupt 7366 
      oprot.writeListEnd()
7367 
      oprot.writeFieldEnd()
3431 rajveer 7368 
    if self.ucx is not None:
1590 varun.gupt 7369 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7370 
      self.ucx.write(oprot)
7371 
      oprot.writeFieldEnd()
7372 
    oprot.writeFieldStop()
7373 
    oprot.writeStructEnd()
7374 
 
3431 rajveer 7375 
  def validate(self):
7376 
    return
7377 
 
7378 
 
1590 varun.gupt 7379 
  def __repr__(self):
7380 
    L = ['%s=%r' % (key, value)
7381 
      for key, value in self.__dict__.iteritems()]
7382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7383 
 
7384 
  def __eq__(self, other):
7385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7386 
 
7387 
  def __ne__(self, other):
7388 
    return not (self == other)
7389 
 
7390 
class getAllUserCommunications_args:
7391 
 
7392 
  thrift_spec = (
7393 
  )
7394 
 
7395 
  def read(self, iprot):
7396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7398 
      return
7399 
    iprot.readStructBegin()
7400 
    while True:
7401 
      (fname, ftype, fid) = iprot.readFieldBegin()
7402 
      if ftype == TType.STOP:
7403 
        break
7404 
      else:
7405 
        iprot.skip(ftype)
7406 
      iprot.readFieldEnd()
7407 
    iprot.readStructEnd()
7408 
 
7409 
  def write(self, oprot):
7410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7412 
      return
7413 
    oprot.writeStructBegin('getAllUserCommunications_args')
7414 
    oprot.writeFieldStop()
7415 
    oprot.writeStructEnd()
7416 
 
3431 rajveer 7417 
  def validate(self):
7418 
    return
7419 
 
7420 
 
1590 varun.gupt 7421 
  def __repr__(self):
7422 
    L = ['%s=%r' % (key, value)
7423 
      for key, value in self.__dict__.iteritems()]
7424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7425 
 
7426 
  def __eq__(self, other):
7427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7428 
 
7429 
  def __ne__(self, other):
7430 
    return not (self == other)
7431 
 
7432 
class getAllUserCommunications_result:
7433 
  """
7434 
  Attributes:
7435 
   - success
7436 
   - ucx
7437 
  """
7438 
 
7439 
  thrift_spec = (
7440 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7441 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7442 
  )
7443 
 
7444 
  def __init__(self, success=None, ucx=None,):
7445 
    self.success = success
7446 
    self.ucx = ucx
7447 
 
7448 
  def read(self, iprot):
7449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7451 
      return
7452 
    iprot.readStructBegin()
7453 
    while True:
7454 
      (fname, ftype, fid) = iprot.readFieldBegin()
7455 
      if ftype == TType.STOP:
7456 
        break
7457 
      if fid == 0:
7458 
        if ftype == TType.LIST:
7459 
          self.success = []
7746 amit.gupta 7460 
          (_etype107, _size104) = iprot.readListBegin()
7461 
          for _i108 in xrange(_size104):
7462 
            _elem109 = UserCommunication()
7463 
            _elem109.read(iprot)
7464 
            self.success.append(_elem109)
1590 varun.gupt 7465 
          iprot.readListEnd()
7466 
        else:
7467 
          iprot.skip(ftype)
7468 
      elif fid == 1:
7469 
        if ftype == TType.STRUCT:
7470 
          self.ucx = UserCommunicationException()
7471 
          self.ucx.read(iprot)
7472 
        else:
7473 
          iprot.skip(ftype)
7474 
      else:
7475 
        iprot.skip(ftype)
7476 
      iprot.readFieldEnd()
7477 
    iprot.readStructEnd()
7478 
 
7479 
  def write(self, oprot):
7480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7482 
      return
7483 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 7484 
    if self.success is not None:
1590 varun.gupt 7485 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7486 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 7487 
      for iter110 in self.success:
7488 
        iter110.write(oprot)
1590 varun.gupt 7489 
      oprot.writeListEnd()
7490 
      oprot.writeFieldEnd()
3431 rajveer 7491 
    if self.ucx is not None:
1590 varun.gupt 7492 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7493 
      self.ucx.write(oprot)
7494 
      oprot.writeFieldEnd()
7495 
    oprot.writeFieldStop()
7496 
    oprot.writeStructEnd()
7497 
 
3431 rajveer 7498 
  def validate(self):
7499 
    return
7500 
 
7501 
 
1590 varun.gupt 7502 
  def __repr__(self):
7503 
    L = ['%s=%r' % (key, value)
7504 
      for key, value in self.__dict__.iteritems()]
7505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7506 
 
7507 
  def __eq__(self, other):
7508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7509 
 
7510 
  def __ne__(self, other):
7511 
    return not (self == other)
7512 
 
5407 amar.kumar 7513 
class removeUserCommunication_args:
7514 
  """
7515 
  Attributes:
7516 
   - id
7517 
  """
7518 
 
7519 
  thrift_spec = (
7520 
    None, # 0
7521 
    (1, TType.I64, 'id', None, None, ), # 1
7522 
  )
7523 
 
7524 
  def __init__(self, id=None,):
7525 
    self.id = id
7526 
 
7527 
  def read(self, iprot):
7528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7530 
      return
7531 
    iprot.readStructBegin()
7532 
    while True:
7533 
      (fname, ftype, fid) = iprot.readFieldBegin()
7534 
      if ftype == TType.STOP:
7535 
        break
7536 
      if fid == 1:
7537 
        if ftype == TType.I64:
7538 
          self.id = iprot.readI64();
7539 
        else:
7540 
          iprot.skip(ftype)
7541 
      else:
7542 
        iprot.skip(ftype)
7543 
      iprot.readFieldEnd()
7544 
    iprot.readStructEnd()
7545 
 
7546 
  def write(self, oprot):
7547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7549 
      return
7550 
    oprot.writeStructBegin('removeUserCommunication_args')
7551 
    if self.id is not None:
7552 
      oprot.writeFieldBegin('id', TType.I64, 1)
7553 
      oprot.writeI64(self.id)
7554 
      oprot.writeFieldEnd()
7555 
    oprot.writeFieldStop()
7556 
    oprot.writeStructEnd()
7557 
 
7558 
  def validate(self):
7559 
    return
7560 
 
7561 
 
7562 
  def __repr__(self):
7563 
    L = ['%s=%r' % (key, value)
7564 
      for key, value in self.__dict__.iteritems()]
7565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7566 
 
7567 
  def __eq__(self, other):
7568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7569 
 
7570 
  def __ne__(self, other):
7571 
    return not (self == other)
7572 
 
7573 
class removeUserCommunication_result:
7574 
  """
7575 
  Attributes:
7576 
   - ucx
7577 
  """
7578 
 
7579 
  thrift_spec = (
7580 
    None, # 0
7581 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7582 
  )
7583 
 
7584 
  def __init__(self, ucx=None,):
7585 
    self.ucx = ucx
7586 
 
7587 
  def read(self, iprot):
7588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7590 
      return
7591 
    iprot.readStructBegin()
7592 
    while True:
7593 
      (fname, ftype, fid) = iprot.readFieldBegin()
7594 
      if ftype == TType.STOP:
7595 
        break
7596 
      if fid == 1:
7597 
        if ftype == TType.STRUCT:
7598 
          self.ucx = UserCommunicationException()
7599 
          self.ucx.read(iprot)
7600 
        else:
7601 
          iprot.skip(ftype)
7602 
      else:
7603 
        iprot.skip(ftype)
7604 
      iprot.readFieldEnd()
7605 
    iprot.readStructEnd()
7606 
 
7607 
  def write(self, oprot):
7608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7610 
      return
7611 
    oprot.writeStructBegin('removeUserCommunication_result')
7612 
    if self.ucx is not None:
7613 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7614 
      self.ucx.write(oprot)
7615 
      oprot.writeFieldEnd()
7616 
    oprot.writeFieldStop()
7617 
    oprot.writeStructEnd()
7618 
 
7619 
  def validate(self):
7620 
    return
7621 
 
7622 
 
7623 
  def __repr__(self):
7624 
    L = ['%s=%r' % (key, value)
7625 
      for key, value in self.__dict__.iteritems()]
7626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7627 
 
7628 
  def __eq__(self, other):
7629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7630 
 
7631 
  def __ne__(self, other):
7632 
    return not (self == other)
7633 
 
1845 vikas 7634 
class createMasterAffiliate_args:
7635 
  """
7636 
  Attributes:
7637 
   - name
1859 vikas 7638 
   - addedOn
1845 vikas 7639 
  """
7640 
 
7641 
  thrift_spec = (
7642 
    None, # 0
7643 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7644 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7645 
  )
7646 
 
1859 vikas 7647 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7648 
    self.name = name
1859 vikas 7649 
    self.addedOn = addedOn
1845 vikas 7650 
 
7651 
  def read(self, iprot):
7652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7654 
      return
7655 
    iprot.readStructBegin()
7656 
    while True:
7657 
      (fname, ftype, fid) = iprot.readFieldBegin()
7658 
      if ftype == TType.STOP:
7659 
        break
7660 
      if fid == 1:
7661 
        if ftype == TType.STRING:
7662 
          self.name = iprot.readString();
7663 
        else:
7664 
          iprot.skip(ftype)
1859 vikas 7665 
      elif fid == 2:
7666 
        if ftype == TType.I64:
7667 
          self.addedOn = iprot.readI64();
7668 
        else:
7669 
          iprot.skip(ftype)
1845 vikas 7670 
      else:
7671 
        iprot.skip(ftype)
7672 
      iprot.readFieldEnd()
7673 
    iprot.readStructEnd()
7674 
 
7675 
  def write(self, oprot):
7676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7678 
      return
7679 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 7680 
    if self.name is not None:
1845 vikas 7681 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7682 
      oprot.writeString(self.name)
7683 
      oprot.writeFieldEnd()
3431 rajveer 7684 
    if self.addedOn is not None:
1859 vikas 7685 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7686 
      oprot.writeI64(self.addedOn)
7687 
      oprot.writeFieldEnd()
1845 vikas 7688 
    oprot.writeFieldStop()
7689 
    oprot.writeStructEnd()
7690 
 
3431 rajveer 7691 
  def validate(self):
7692 
    return
7693 
 
7694 
 
1845 vikas 7695 
  def __repr__(self):
7696 
    L = ['%s=%r' % (key, value)
7697 
      for key, value in self.__dict__.iteritems()]
7698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7699 
 
7700 
  def __eq__(self, other):
7701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7702 
 
7703 
  def __ne__(self, other):
7704 
    return not (self == other)
7705 
 
7706 
class createMasterAffiliate_result:
7707 
  """
7708 
  Attributes:
7709 
   - success
7710 
   - utx
7711 
  """
7712 
 
7713 
  thrift_spec = (
7714 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7715 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7716 
  )
7717 
 
7718 
  def __init__(self, success=None, utx=None,):
7719 
    self.success = success
7720 
    self.utx = utx
7721 
 
7722 
  def read(self, iprot):
7723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7725 
      return
7726 
    iprot.readStructBegin()
7727 
    while True:
7728 
      (fname, ftype, fid) = iprot.readFieldBegin()
7729 
      if ftype == TType.STOP:
7730 
        break
7731 
      if fid == 0:
7732 
        if ftype == TType.STRUCT:
7733 
          self.success = MasterAffiliate()
7734 
          self.success.read(iprot)
7735 
        else:
7736 
          iprot.skip(ftype)
7737 
      elif fid == 1:
7738 
        if ftype == TType.STRUCT:
1996 vikas 7739 
          self.utx = UserAffiliateException()
1845 vikas 7740 
          self.utx.read(iprot)
7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      else:
7744 
        iprot.skip(ftype)
7745 
      iprot.readFieldEnd()
7746 
    iprot.readStructEnd()
7747 
 
7748 
  def write(self, oprot):
7749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7751 
      return
7752 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 7753 
    if self.success is not None:
1845 vikas 7754 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7755 
      self.success.write(oprot)
7756 
      oprot.writeFieldEnd()
3431 rajveer 7757 
    if self.utx is not None:
1845 vikas 7758 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7759 
      self.utx.write(oprot)
7760 
      oprot.writeFieldEnd()
7761 
    oprot.writeFieldStop()
7762 
    oprot.writeStructEnd()
7763 
 
3431 rajveer 7764 
  def validate(self):
7765 
    return
7766 
 
7767 
 
1845 vikas 7768 
  def __repr__(self):
7769 
    L = ['%s=%r' % (key, value)
7770 
      for key, value in self.__dict__.iteritems()]
7771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7772 
 
7773 
  def __eq__(self, other):
7774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7775 
 
7776 
  def __ne__(self, other):
7777 
    return not (self == other)
7778 
 
1899 vikas 7779 
class getAllMasterAffiliates_args:
7780 
 
7781 
  thrift_spec = (
7782 
  )
7783 
 
7784 
  def read(self, iprot):
7785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7787 
      return
7788 
    iprot.readStructBegin()
7789 
    while True:
7790 
      (fname, ftype, fid) = iprot.readFieldBegin()
7791 
      if ftype == TType.STOP:
7792 
        break
7793 
      else:
7794 
        iprot.skip(ftype)
7795 
      iprot.readFieldEnd()
7796 
    iprot.readStructEnd()
7797 
 
7798 
  def write(self, oprot):
7799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7801 
      return
7802 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7803 
    oprot.writeFieldStop()
7804 
    oprot.writeStructEnd()
7805 
 
3431 rajveer 7806 
  def validate(self):
7807 
    return
7808 
 
7809 
 
1899 vikas 7810 
  def __repr__(self):
7811 
    L = ['%s=%r' % (key, value)
7812 
      for key, value in self.__dict__.iteritems()]
7813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7814 
 
7815 
  def __eq__(self, other):
7816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7817 
 
7818 
  def __ne__(self, other):
7819 
    return not (self == other)
7820 
 
7821 
class getAllMasterAffiliates_result:
7822 
  """
7823 
  Attributes:
7824 
   - success
7825 
   - utx
7826 
  """
7827 
 
7828 
  thrift_spec = (
7829 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7830 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7831 
  )
7832 
 
7833 
  def __init__(self, success=None, utx=None,):
7834 
    self.success = success
7835 
    self.utx = utx
7836 
 
7837 
  def read(self, iprot):
7838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7840 
      return
7841 
    iprot.readStructBegin()
7842 
    while True:
7843 
      (fname, ftype, fid) = iprot.readFieldBegin()
7844 
      if ftype == TType.STOP:
7845 
        break
7846 
      if fid == 0:
7847 
        if ftype == TType.LIST:
7848 
          self.success = []
7746 amit.gupta 7849 
          (_etype114, _size111) = iprot.readListBegin()
7850 
          for _i115 in xrange(_size111):
7851 
            _elem116 = MasterAffiliate()
7852 
            _elem116.read(iprot)
7853 
            self.success.append(_elem116)
1899 vikas 7854 
          iprot.readListEnd()
7855 
        else:
7856 
          iprot.skip(ftype)
7857 
      elif fid == 1:
7858 
        if ftype == TType.STRUCT:
1996 vikas 7859 
          self.utx = UserAffiliateException()
1899 vikas 7860 
          self.utx.read(iprot)
7861 
        else:
7862 
          iprot.skip(ftype)
7863 
      else:
7864 
        iprot.skip(ftype)
7865 
      iprot.readFieldEnd()
7866 
    iprot.readStructEnd()
7867 
 
7868 
  def write(self, oprot):
7869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7871 
      return
7872 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 7873 
    if self.success is not None:
1899 vikas 7874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 7876 
      for iter117 in self.success:
7877 
        iter117.write(oprot)
1899 vikas 7878 
      oprot.writeListEnd()
7879 
      oprot.writeFieldEnd()
3431 rajveer 7880 
    if self.utx is not None:
1899 vikas 7881 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7882 
      self.utx.write(oprot)
7883 
      oprot.writeFieldEnd()
7884 
    oprot.writeFieldStop()
7885 
    oprot.writeStructEnd()
7886 
 
3431 rajveer 7887 
  def validate(self):
7888 
    return
7889 
 
7890 
 
1899 vikas 7891 
  def __repr__(self):
7892 
    L = ['%s=%r' % (key, value)
7893 
      for key, value in self.__dict__.iteritems()]
7894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7895 
 
7896 
  def __eq__(self, other):
7897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7898 
 
7899 
  def __ne__(self, other):
7900 
    return not (self == other)
7901 
 
1845 vikas 7902 
class getMasterAffiliateById_args:
7903 
  """
7904 
  Attributes:
7905 
   - id
7906 
  """
7907 
 
7908 
  thrift_spec = (
7909 
    None, # 0
7910 
    (1, TType.I64, 'id', None, None, ), # 1
7911 
  )
7912 
 
7913 
  def __init__(self, id=None,):
7914 
    self.id = id
7915 
 
7916 
  def read(self, iprot):
7917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7919 
      return
7920 
    iprot.readStructBegin()
7921 
    while True:
7922 
      (fname, ftype, fid) = iprot.readFieldBegin()
7923 
      if ftype == TType.STOP:
7924 
        break
7925 
      if fid == 1:
7926 
        if ftype == TType.I64:
7927 
          self.id = iprot.readI64();
7928 
        else:
7929 
          iprot.skip(ftype)
7930 
      else:
7931 
        iprot.skip(ftype)
7932 
      iprot.readFieldEnd()
7933 
    iprot.readStructEnd()
7934 
 
7935 
  def write(self, oprot):
7936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7938 
      return
7939 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 7940 
    if self.id is not None:
1845 vikas 7941 
      oprot.writeFieldBegin('id', TType.I64, 1)
7942 
      oprot.writeI64(self.id)
7943 
      oprot.writeFieldEnd()
7944 
    oprot.writeFieldStop()
7945 
    oprot.writeStructEnd()
7946 
 
3431 rajveer 7947 
  def validate(self):
7948 
    return
7949 
 
7950 
 
1845 vikas 7951 
  def __repr__(self):
7952 
    L = ['%s=%r' % (key, value)
7953 
      for key, value in self.__dict__.iteritems()]
7954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7955 
 
7956 
  def __eq__(self, other):
7957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7958 
 
7959 
  def __ne__(self, other):
7960 
    return not (self == other)
7961 
 
7962 
class getMasterAffiliateById_result:
7963 
  """
7964 
  Attributes:
7965 
   - success
7966 
   - utx
7967 
  """
7968 
 
7969 
  thrift_spec = (
7970 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7971 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7972 
  )
7973 
 
7974 
  def __init__(self, success=None, utx=None,):
7975 
    self.success = success
7976 
    self.utx = utx
7977 
 
7978 
  def read(self, iprot):
7979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7981 
      return
7982 
    iprot.readStructBegin()
7983 
    while True:
7984 
      (fname, ftype, fid) = iprot.readFieldBegin()
7985 
      if ftype == TType.STOP:
7986 
        break
7987 
      if fid == 0:
7988 
        if ftype == TType.STRUCT:
7989 
          self.success = MasterAffiliate()
7990 
          self.success.read(iprot)
7991 
        else:
7992 
          iprot.skip(ftype)
7993 
      elif fid == 1:
7994 
        if ftype == TType.STRUCT:
1996 vikas 7995 
          self.utx = UserAffiliateException()
1845 vikas 7996 
          self.utx.read(iprot)
7997 
        else:
7998 
          iprot.skip(ftype)
7999 
      else:
8000 
        iprot.skip(ftype)
8001 
      iprot.readFieldEnd()
8002 
    iprot.readStructEnd()
8003 
 
8004 
  def write(self, oprot):
8005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8007 
      return
8008 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8009 
    if self.success is not None:
1845 vikas 8010 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8011 
      self.success.write(oprot)
8012 
      oprot.writeFieldEnd()
3431 rajveer 8013 
    if self.utx is not None:
1845 vikas 8014 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8015 
      self.utx.write(oprot)
8016 
      oprot.writeFieldEnd()
8017 
    oprot.writeFieldStop()
8018 
    oprot.writeStructEnd()
8019 
 
3431 rajveer 8020 
  def validate(self):
8021 
    return
8022 
 
8023 
 
1845 vikas 8024 
  def __repr__(self):
8025 
    L = ['%s=%r' % (key, value)
8026 
      for key, value in self.__dict__.iteritems()]
8027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8028 
 
8029 
  def __eq__(self, other):
8030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8031 
 
8032 
  def __ne__(self, other):
8033 
    return not (self == other)
8034 
 
8035 
class getMasterAffiliateByName_args:
8036 
  """
8037 
  Attributes:
8038 
   - name
8039 
  """
8040 
 
8041 
  thrift_spec = (
8042 
    None, # 0
8043 
    (1, TType.STRING, 'name', None, None, ), # 1
8044 
  )
8045 
 
8046 
  def __init__(self, name=None,):
8047 
    self.name = name
8048 
 
8049 
  def read(self, iprot):
8050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8052 
      return
8053 
    iprot.readStructBegin()
8054 
    while True:
8055 
      (fname, ftype, fid) = iprot.readFieldBegin()
8056 
      if ftype == TType.STOP:
8057 
        break
8058 
      if fid == 1:
8059 
        if ftype == TType.STRING:
8060 
          self.name = iprot.readString();
8061 
        else:
8062 
          iprot.skip(ftype)
8063 
      else:
8064 
        iprot.skip(ftype)
8065 
      iprot.readFieldEnd()
8066 
    iprot.readStructEnd()
8067 
 
8068 
  def write(self, oprot):
8069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8071 
      return
8072 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8073 
    if self.name is not None:
1845 vikas 8074 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8075 
      oprot.writeString(self.name)
8076 
      oprot.writeFieldEnd()
8077 
    oprot.writeFieldStop()
8078 
    oprot.writeStructEnd()
8079 
 
3431 rajveer 8080 
  def validate(self):
8081 
    return
8082 
 
8083 
 
1845 vikas 8084 
  def __repr__(self):
8085 
    L = ['%s=%r' % (key, value)
8086 
      for key, value in self.__dict__.iteritems()]
8087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8088 
 
8089 
  def __eq__(self, other):
8090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8091 
 
8092 
  def __ne__(self, other):
8093 
    return not (self == other)
8094 
 
8095 
class getMasterAffiliateByName_result:
8096 
  """
8097 
  Attributes:
8098 
   - success
8099 
   - utx
8100 
  """
8101 
 
8102 
  thrift_spec = (
8103 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8104 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8105 
  )
8106 
 
8107 
  def __init__(self, success=None, utx=None,):
8108 
    self.success = success
8109 
    self.utx = utx
8110 
 
8111 
  def read(self, iprot):
8112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8114 
      return
8115 
    iprot.readStructBegin()
8116 
    while True:
8117 
      (fname, ftype, fid) = iprot.readFieldBegin()
8118 
      if ftype == TType.STOP:
8119 
        break
8120 
      if fid == 0:
8121 
        if ftype == TType.STRUCT:
8122 
          self.success = MasterAffiliate()
8123 
          self.success.read(iprot)
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      elif fid == 1:
8127 
        if ftype == TType.STRUCT:
1996 vikas 8128 
          self.utx = UserAffiliateException()
1845 vikas 8129 
          self.utx.read(iprot)
8130 
        else:
8131 
          iprot.skip(ftype)
8132 
      else:
8133 
        iprot.skip(ftype)
8134 
      iprot.readFieldEnd()
8135 
    iprot.readStructEnd()
8136 
 
8137 
  def write(self, oprot):
8138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8140 
      return
8141 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8142 
    if self.success is not None:
1845 vikas 8143 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8144 
      self.success.write(oprot)
8145 
      oprot.writeFieldEnd()
3431 rajveer 8146 
    if self.utx is not None:
1845 vikas 8147 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8148 
      self.utx.write(oprot)
8149 
      oprot.writeFieldEnd()
8150 
    oprot.writeFieldStop()
8151 
    oprot.writeStructEnd()
8152 
 
3431 rajveer 8153 
  def validate(self):
8154 
    return
8155 
 
8156 
 
1845 vikas 8157 
  def __repr__(self):
8158 
    L = ['%s=%r' % (key, value)
8159 
      for key, value in self.__dict__.iteritems()]
8160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8161 
 
8162 
  def __eq__(self, other):
8163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8164 
 
8165 
  def __ne__(self, other):
8166 
    return not (self == other)
8167 
 
8168 
class createAffiliate_args:
8169 
  """
8170 
  Attributes:
8171 
   - name
8172 
   - url
8173 
   - masterAffiliateId
1859 vikas 8174 
   - addedOn
1845 vikas 8175 
  """
8176 
 
8177 
  thrift_spec = (
8178 
    None, # 0
8179 
    (1, TType.STRING, 'name', None, None, ), # 1
8180 
    (2, TType.STRING, 'url', None, None, ), # 2
8181 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8182 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8183 
  )
8184 
 
1859 vikas 8185 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8186 
    self.name = name
8187 
    self.url = url
8188 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8189 
    self.addedOn = addedOn
1845 vikas 8190 
 
8191 
  def read(self, iprot):
8192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8194 
      return
8195 
    iprot.readStructBegin()
8196 
    while True:
8197 
      (fname, ftype, fid) = iprot.readFieldBegin()
8198 
      if ftype == TType.STOP:
8199 
        break
8200 
      if fid == 1:
8201 
        if ftype == TType.STRING:
8202 
          self.name = iprot.readString();
8203 
        else:
8204 
          iprot.skip(ftype)
8205 
      elif fid == 2:
8206 
        if ftype == TType.STRING:
8207 
          self.url = iprot.readString();
8208 
        else:
8209 
          iprot.skip(ftype)
8210 
      elif fid == 3:
8211 
        if ftype == TType.I64:
8212 
          self.masterAffiliateId = iprot.readI64();
8213 
        else:
8214 
          iprot.skip(ftype)
1859 vikas 8215 
      elif fid == 4:
8216 
        if ftype == TType.I64:
8217 
          self.addedOn = iprot.readI64();
8218 
        else:
8219 
          iprot.skip(ftype)
1845 vikas 8220 
      else:
8221 
        iprot.skip(ftype)
8222 
      iprot.readFieldEnd()
8223 
    iprot.readStructEnd()
8224 
 
8225 
  def write(self, oprot):
8226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8228 
      return
8229 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8230 
    if self.name is not None:
1845 vikas 8231 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8232 
      oprot.writeString(self.name)
8233 
      oprot.writeFieldEnd()
3431 rajveer 8234 
    if self.url is not None:
1845 vikas 8235 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8236 
      oprot.writeString(self.url)
8237 
      oprot.writeFieldEnd()
3431 rajveer 8238 
    if self.masterAffiliateId is not None:
1845 vikas 8239 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8240 
      oprot.writeI64(self.masterAffiliateId)
8241 
      oprot.writeFieldEnd()
3431 rajveer 8242 
    if self.addedOn is not None:
1859 vikas 8243 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8244 
      oprot.writeI64(self.addedOn)
8245 
      oprot.writeFieldEnd()
1845 vikas 8246 
    oprot.writeFieldStop()
8247 
    oprot.writeStructEnd()
8248 
 
3431 rajveer 8249 
  def validate(self):
8250 
    return
8251 
 
8252 
 
1845 vikas 8253 
  def __repr__(self):
8254 
    L = ['%s=%r' % (key, value)
8255 
      for key, value in self.__dict__.iteritems()]
8256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8257 
 
8258 
  def __eq__(self, other):
8259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8260 
 
8261 
  def __ne__(self, other):
8262 
    return not (self == other)
8263 
 
8264 
class createAffiliate_result:
8265 
  """
8266 
  Attributes:
8267 
   - success
8268 
   - utx
8269 
  """
8270 
 
8271 
  thrift_spec = (
8272 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8273 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8274 
  )
8275 
 
8276 
  def __init__(self, success=None, utx=None,):
8277 
    self.success = success
8278 
    self.utx = utx
8279 
 
8280 
  def read(self, iprot):
8281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8283 
      return
8284 
    iprot.readStructBegin()
8285 
    while True:
8286 
      (fname, ftype, fid) = iprot.readFieldBegin()
8287 
      if ftype == TType.STOP:
8288 
        break
8289 
      if fid == 0:
8290 
        if ftype == TType.STRUCT:
8291 
          self.success = Affiliate()
8292 
          self.success.read(iprot)
8293 
        else:
8294 
          iprot.skip(ftype)
8295 
      elif fid == 1:
8296 
        if ftype == TType.STRUCT:
1996 vikas 8297 
          self.utx = UserAffiliateException()
1845 vikas 8298 
          self.utx.read(iprot)
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      else:
8302 
        iprot.skip(ftype)
8303 
      iprot.readFieldEnd()
8304 
    iprot.readStructEnd()
8305 
 
8306 
  def write(self, oprot):
8307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8309 
      return
8310 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8311 
    if self.success is not None:
1845 vikas 8312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8313 
      self.success.write(oprot)
8314 
      oprot.writeFieldEnd()
3431 rajveer 8315 
    if self.utx is not None:
1845 vikas 8316 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8317 
      self.utx.write(oprot)
8318 
      oprot.writeFieldEnd()
8319 
    oprot.writeFieldStop()
8320 
    oprot.writeStructEnd()
8321 
 
3431 rajveer 8322 
  def validate(self):
8323 
    return
8324 
 
8325 
 
1845 vikas 8326 
  def __repr__(self):
8327 
    L = ['%s=%r' % (key, value)
8328 
      for key, value in self.__dict__.iteritems()]
8329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8330 
 
8331 
  def __eq__(self, other):
8332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8333 
 
8334 
  def __ne__(self, other):
8335 
    return not (self == other)
8336 
 
8337 
class getAffiliateById_args:
8338 
  """
8339 
  Attributes:
8340 
   - id
8341 
  """
8342 
 
8343 
  thrift_spec = (
8344 
    None, # 0
8345 
    (1, TType.I64, 'id', None, None, ), # 1
8346 
  )
8347 
 
8348 
  def __init__(self, id=None,):
8349 
    self.id = id
8350 
 
8351 
  def read(self, iprot):
8352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8354 
      return
8355 
    iprot.readStructBegin()
8356 
    while True:
8357 
      (fname, ftype, fid) = iprot.readFieldBegin()
8358 
      if ftype == TType.STOP:
8359 
        break
8360 
      if fid == 1:
8361 
        if ftype == TType.I64:
8362 
          self.id = iprot.readI64();
8363 
        else:
8364 
          iprot.skip(ftype)
8365 
      else:
8366 
        iprot.skip(ftype)
8367 
      iprot.readFieldEnd()
8368 
    iprot.readStructEnd()
8369 
 
8370 
  def write(self, oprot):
8371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8373 
      return
8374 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8375 
    if self.id is not None:
1845 vikas 8376 
      oprot.writeFieldBegin('id', TType.I64, 1)
8377 
      oprot.writeI64(self.id)
8378 
      oprot.writeFieldEnd()
8379 
    oprot.writeFieldStop()
8380 
    oprot.writeStructEnd()
8381 
 
3431 rajveer 8382 
  def validate(self):
8383 
    return
8384 
 
8385 
 
1845 vikas 8386 
  def __repr__(self):
8387 
    L = ['%s=%r' % (key, value)
8388 
      for key, value in self.__dict__.iteritems()]
8389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8390 
 
8391 
  def __eq__(self, other):
8392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8393 
 
8394 
  def __ne__(self, other):
8395 
    return not (self == other)
8396 
 
8397 
class getAffiliateById_result:
8398 
  """
8399 
  Attributes:
8400 
   - success
8401 
   - utx
8402 
  """
8403 
 
8404 
  thrift_spec = (
8405 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8406 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8407 
  )
8408 
 
8409 
  def __init__(self, success=None, utx=None,):
8410 
    self.success = success
8411 
    self.utx = utx
8412 
 
8413 
  def read(self, iprot):
8414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8416 
      return
8417 
    iprot.readStructBegin()
8418 
    while True:
8419 
      (fname, ftype, fid) = iprot.readFieldBegin()
8420 
      if ftype == TType.STOP:
8421 
        break
8422 
      if fid == 0:
8423 
        if ftype == TType.STRUCT:
8424 
          self.success = Affiliate()
8425 
          self.success.read(iprot)
8426 
        else:
8427 
          iprot.skip(ftype)
8428 
      elif fid == 1:
8429 
        if ftype == TType.STRUCT:
1996 vikas 8430 
          self.utx = UserAffiliateException()
1845 vikas 8431 
          self.utx.read(iprot)
8432 
        else:
8433 
          iprot.skip(ftype)
8434 
      else:
8435 
        iprot.skip(ftype)
8436 
      iprot.readFieldEnd()
8437 
    iprot.readStructEnd()
8438 
 
8439 
  def write(self, oprot):
8440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8442 
      return
8443 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 8444 
    if self.success is not None:
1845 vikas 8445 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8446 
      self.success.write(oprot)
8447 
      oprot.writeFieldEnd()
3431 rajveer 8448 
    if self.utx is not None:
1845 vikas 8449 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8450 
      self.utx.write(oprot)
8451 
      oprot.writeFieldEnd()
8452 
    oprot.writeFieldStop()
8453 
    oprot.writeStructEnd()
8454 
 
3431 rajveer 8455 
  def validate(self):
8456 
    return
8457 
 
8458 
 
1845 vikas 8459 
  def __repr__(self):
8460 
    L = ['%s=%r' % (key, value)
8461 
      for key, value in self.__dict__.iteritems()]
8462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8463 
 
8464 
  def __eq__(self, other):
8465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8466 
 
8467 
  def __ne__(self, other):
8468 
    return not (self == other)
8469 
 
8470 
class getAffiliateByName_args:
8471 
  """
8472 
  Attributes:
8473 
   - name
8474 
  """
8475 
 
8476 
  thrift_spec = (
8477 
    None, # 0
8478 
    (1, TType.STRING, 'name', None, None, ), # 1
8479 
  )
8480 
 
8481 
  def __init__(self, name=None,):
8482 
    self.name = name
8483 
 
8484 
  def read(self, iprot):
8485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8487 
      return
8488 
    iprot.readStructBegin()
8489 
    while True:
8490 
      (fname, ftype, fid) = iprot.readFieldBegin()
8491 
      if ftype == TType.STOP:
8492 
        break
8493 
      if fid == 1:
8494 
        if ftype == TType.STRING:
8495 
          self.name = iprot.readString();
8496 
        else:
8497 
          iprot.skip(ftype)
8498 
      else:
8499 
        iprot.skip(ftype)
8500 
      iprot.readFieldEnd()
8501 
    iprot.readStructEnd()
8502 
 
8503 
  def write(self, oprot):
8504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8506 
      return
8507 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 8508 
    if self.name is not None:
1845 vikas 8509 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8510 
      oprot.writeString(self.name)
8511 
      oprot.writeFieldEnd()
8512 
    oprot.writeFieldStop()
8513 
    oprot.writeStructEnd()
8514 
 
3431 rajveer 8515 
  def validate(self):
8516 
    return
8517 
 
8518 
 
1845 vikas 8519 
  def __repr__(self):
8520 
    L = ['%s=%r' % (key, value)
8521 
      for key, value in self.__dict__.iteritems()]
8522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8523 
 
8524 
  def __eq__(self, other):
8525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8526 
 
8527 
  def __ne__(self, other):
8528 
    return not (self == other)
8529 
 
8530 
class getAffiliateByName_result:
8531 
  """
8532 
  Attributes:
8533 
   - success
8534 
   - utx
8535 
  """
8536 
 
8537 
  thrift_spec = (
8538 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8539 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8540 
  )
8541 
 
8542 
  def __init__(self, success=None, utx=None,):
8543 
    self.success = success
8544 
    self.utx = utx
8545 
 
8546 
  def read(self, iprot):
8547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8549 
      return
8550 
    iprot.readStructBegin()
8551 
    while True:
8552 
      (fname, ftype, fid) = iprot.readFieldBegin()
8553 
      if ftype == TType.STOP:
8554 
        break
8555 
      if fid == 0:
8556 
        if ftype == TType.STRUCT:
8557 
          self.success = Affiliate()
8558 
          self.success.read(iprot)
8559 
        else:
8560 
          iprot.skip(ftype)
8561 
      elif fid == 1:
8562 
        if ftype == TType.STRUCT:
1996 vikas 8563 
          self.utx = UserAffiliateException()
1845 vikas 8564 
          self.utx.read(iprot)
8565 
        else:
8566 
          iprot.skip(ftype)
8567 
      else:
8568 
        iprot.skip(ftype)
8569 
      iprot.readFieldEnd()
8570 
    iprot.readStructEnd()
8571 
 
8572 
  def write(self, oprot):
8573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8575 
      return
8576 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 8577 
    if self.success is not None:
1845 vikas 8578 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8579 
      self.success.write(oprot)
8580 
      oprot.writeFieldEnd()
3431 rajveer 8581 
    if self.utx is not None:
1845 vikas 8582 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8583 
      self.utx.write(oprot)
8584 
      oprot.writeFieldEnd()
8585 
    oprot.writeFieldStop()
8586 
    oprot.writeStructEnd()
8587 
 
3431 rajveer 8588 
  def validate(self):
8589 
    return
8590 
 
8591 
 
1845 vikas 8592 
  def __repr__(self):
8593 
    L = ['%s=%r' % (key, value)
8594 
      for key, value in self.__dict__.iteritems()]
8595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8596 
 
8597 
  def __eq__(self, other):
8598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8599 
 
8600 
  def __ne__(self, other):
8601 
    return not (self == other)
8602 
 
1996 vikas 8603 
class getTrackerById_args:
1845 vikas 8604 
  """
8605 
  Attributes:
8606 
   - id
8607 
  """
8608 
 
8609 
  thrift_spec = (
8610 
    None, # 0
8611 
    (1, TType.I64, 'id', None, None, ), # 1
8612 
  )
8613 
 
8614 
  def __init__(self, id=None,):
8615 
    self.id = id
8616 
 
8617 
  def read(self, iprot):
8618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8620 
      return
8621 
    iprot.readStructBegin()
8622 
    while True:
8623 
      (fname, ftype, fid) = iprot.readFieldBegin()
8624 
      if ftype == TType.STOP:
8625 
        break
8626 
      if fid == 1:
8627 
        if ftype == TType.I64:
8628 
          self.id = iprot.readI64();
8629 
        else:
8630 
          iprot.skip(ftype)
8631 
      else:
8632 
        iprot.skip(ftype)
8633 
      iprot.readFieldEnd()
8634 
    iprot.readStructEnd()
8635 
 
8636 
  def write(self, oprot):
8637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8639 
      return
1996 vikas 8640 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 8641 
    if self.id is not None:
1845 vikas 8642 
      oprot.writeFieldBegin('id', TType.I64, 1)
8643 
      oprot.writeI64(self.id)
8644 
      oprot.writeFieldEnd()
8645 
    oprot.writeFieldStop()
8646 
    oprot.writeStructEnd()
8647 
 
3431 rajveer 8648 
  def validate(self):
8649 
    return
8650 
 
8651 
 
1845 vikas 8652 
  def __repr__(self):
8653 
    L = ['%s=%r' % (key, value)
8654 
      for key, value in self.__dict__.iteritems()]
8655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8656 
 
8657 
  def __eq__(self, other):
8658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8659 
 
8660 
  def __ne__(self, other):
8661 
    return not (self == other)
8662 
 
8663 
class getTrackerById_result:
8664 
  """
8665 
  Attributes:
8666 
   - success
8667 
   - utx
8668 
  """
8669 
 
8670 
  thrift_spec = (
8671 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8672 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8673 
  )
8674 
 
8675 
  def __init__(self, success=None, utx=None,):
8676 
    self.success = success
8677 
    self.utx = utx
8678 
 
8679 
  def read(self, iprot):
8680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8682 
      return
8683 
    iprot.readStructBegin()
8684 
    while True:
8685 
      (fname, ftype, fid) = iprot.readFieldBegin()
8686 
      if ftype == TType.STOP:
8687 
        break
8688 
      if fid == 0:
8689 
        if ftype == TType.STRUCT:
8690 
          self.success = Tracker()
8691 
          self.success.read(iprot)
8692 
        else:
8693 
          iprot.skip(ftype)
8694 
      elif fid == 1:
8695 
        if ftype == TType.STRUCT:
1996 vikas 8696 
          self.utx = UserAffiliateException()
1845 vikas 8697 
          self.utx.read(iprot)
8698 
        else:
8699 
          iprot.skip(ftype)
8700 
      else:
8701 
        iprot.skip(ftype)
8702 
      iprot.readFieldEnd()
8703 
    iprot.readStructEnd()
8704 
 
8705 
  def write(self, oprot):
8706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8708 
      return
8709 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 8710 
    if self.success is not None:
1845 vikas 8711 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8712 
      self.success.write(oprot)
8713 
      oprot.writeFieldEnd()
3431 rajveer 8714 
    if self.utx is not None:
1845 vikas 8715 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8716 
      self.utx.write(oprot)
8717 
      oprot.writeFieldEnd()
8718 
    oprot.writeFieldStop()
8719 
    oprot.writeStructEnd()
8720 
 
3431 rajveer 8721 
  def validate(self):
8722 
    return
8723 
 
8724 
 
1845 vikas 8725 
  def __repr__(self):
8726 
    L = ['%s=%r' % (key, value)
8727 
      for key, value in self.__dict__.iteritems()]
8728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8729 
 
8730 
  def __eq__(self, other):
8731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8732 
 
8733 
  def __ne__(self, other):
8734 
    return not (self == other)
8735 
 
1996 vikas 8736 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8737 
  """
8738 
  Attributes:
1996 vikas 8739 
   - id
1845 vikas 8740 
  """
8741 
 
8742 
  thrift_spec = (
8743 
    None, # 0
1996 vikas 8744 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8745 
  )
8746 
 
1996 vikas 8747 
  def __init__(self, id=None,):
8748 
    self.id = id
1845 vikas 8749 
 
8750 
  def read(self, iprot):
8751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8753 
      return
8754 
    iprot.readStructBegin()
8755 
    while True:
8756 
      (fname, ftype, fid) = iprot.readFieldBegin()
8757 
      if ftype == TType.STOP:
8758 
        break
8759 
      if fid == 1:
8760 
        if ftype == TType.I64:
1996 vikas 8761 
          self.id = iprot.readI64();
1845 vikas 8762 
        else:
8763 
          iprot.skip(ftype)
8764 
      else:
8765 
        iprot.skip(ftype)
8766 
      iprot.readFieldEnd()
8767 
    iprot.readStructEnd()
8768 
 
8769 
  def write(self, oprot):
8770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8772 
      return
1996 vikas 8773 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 8774 
    if self.id is not None:
1996 vikas 8775 
      oprot.writeFieldBegin('id', TType.I64, 1)
8776 
      oprot.writeI64(self.id)
1845 vikas 8777 
      oprot.writeFieldEnd()
8778 
    oprot.writeFieldStop()
8779 
    oprot.writeStructEnd()
8780 
 
3431 rajveer 8781 
  def validate(self):
8782 
    return
8783 
 
8784 
 
1845 vikas 8785 
  def __repr__(self):
8786 
    L = ['%s=%r' % (key, value)
8787 
      for key, value in self.__dict__.iteritems()]
8788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8789 
 
8790 
  def __eq__(self, other):
8791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8792 
 
8793 
  def __ne__(self, other):
8794 
    return not (self == other)
8795 
 
1996 vikas 8796 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8797 
  """
8798 
  Attributes:
8799 
   - success
8800 
   - utx
8801 
  """
8802 
 
8803 
  thrift_spec = (
1996 vikas 8804 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8805 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8806 
  )
8807 
 
8808 
  def __init__(self, success=None, utx=None,):
8809 
    self.success = success
8810 
    self.utx = utx
8811 
 
8812 
  def read(self, iprot):
8813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8815 
      return
8816 
    iprot.readStructBegin()
8817 
    while True:
8818 
      (fname, ftype, fid) = iprot.readFieldBegin()
8819 
      if ftype == TType.STOP:
8820 
        break
8821 
      if fid == 0:
8822 
        if ftype == TType.LIST:
8823 
          self.success = []
7746 amit.gupta 8824 
          (_etype121, _size118) = iprot.readListBegin()
8825 
          for _i122 in xrange(_size118):
8826 
            _elem123 = Affiliate()
8827 
            _elem123.read(iprot)
8828 
            self.success.append(_elem123)
1845 vikas 8829 
          iprot.readListEnd()
8830 
        else:
8831 
          iprot.skip(ftype)
8832 
      elif fid == 1:
8833 
        if ftype == TType.STRUCT:
1996 vikas 8834 
          self.utx = UserAffiliateException()
1845 vikas 8835 
          self.utx.read(iprot)
8836 
        else:
8837 
          iprot.skip(ftype)
8838 
      else:
8839 
        iprot.skip(ftype)
8840 
      iprot.readFieldEnd()
8841 
    iprot.readStructEnd()
8842 
 
8843 
  def write(self, oprot):
8844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8846 
      return
1996 vikas 8847 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 8848 
    if self.success is not None:
1845 vikas 8849 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8850 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 8851 
      for iter124 in self.success:
8852 
        iter124.write(oprot)
1845 vikas 8853 
      oprot.writeListEnd()
8854 
      oprot.writeFieldEnd()
3431 rajveer 8855 
    if self.utx is not None:
1845 vikas 8856 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8857 
      self.utx.write(oprot)
8858 
      oprot.writeFieldEnd()
8859 
    oprot.writeFieldStop()
8860 
    oprot.writeStructEnd()
8861 
 
3431 rajveer 8862 
  def validate(self):
8863 
    return
8864 
 
8865 
 
1845 vikas 8866 
  def __repr__(self):
8867 
    L = ['%s=%r' % (key, value)
8868 
      for key, value in self.__dict__.iteritems()]
8869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8870 
 
8871 
  def __eq__(self, other):
8872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8873 
 
8874 
  def __ne__(self, other):
8875 
    return not (self == other)
8876 
 
8877 
class addTrackLog_args:
8878 
  """
8879 
  Attributes:
1996 vikas 8880 
   - affiliateId
1845 vikas 8881 
   - userId
8882 
   - event
8883 
   - url
8884 
   - data
1859 vikas 8885 
   - addedOn
1845 vikas 8886 
  """
8887 
 
8888 
  thrift_spec = (
8889 
    None, # 0
1996 vikas 8890 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8891 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 8892 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 8893 
    (4, TType.STRING, 'url', None, None, ), # 4
8894 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8895 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8896 
  )
8897 
 
1996 vikas 8898 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8899 
    self.affiliateId = affiliateId
1845 vikas 8900 
    self.userId = userId
8901 
    self.event = event
8902 
    self.url = url
8903 
    self.data = data
1859 vikas 8904 
    self.addedOn = addedOn
1845 vikas 8905 
 
8906 
  def read(self, iprot):
8907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8909 
      return
8910 
    iprot.readStructBegin()
8911 
    while True:
8912 
      (fname, ftype, fid) = iprot.readFieldBegin()
8913 
      if ftype == TType.STOP:
8914 
        break
8915 
      if fid == 1:
8916 
        if ftype == TType.I64:
1996 vikas 8917 
          self.affiliateId = iprot.readI64();
1845 vikas 8918 
        else:
8919 
          iprot.skip(ftype)
8920 
      elif fid == 2:
8921 
        if ftype == TType.I64:
8922 
          self.userId = iprot.readI64();
8923 
        else:
8924 
          iprot.skip(ftype)
8925 
      elif fid == 3:
3378 vikas 8926 
        if ftype == TType.I32:
8927 
          self.event = iprot.readI32();
1845 vikas 8928 
        else:
8929 
          iprot.skip(ftype)
8930 
      elif fid == 4:
8931 
        if ftype == TType.STRING:
8932 
          self.url = iprot.readString();
8933 
        else:
8934 
          iprot.skip(ftype)
8935 
      elif fid == 5:
8936 
        if ftype == TType.STRING:
8937 
          self.data = iprot.readString();
8938 
        else:
8939 
          iprot.skip(ftype)
1859 vikas 8940 
      elif fid == 6:
8941 
        if ftype == TType.I64:
8942 
          self.addedOn = iprot.readI64();
8943 
        else:
8944 
          iprot.skip(ftype)
1845 vikas 8945 
      else:
8946 
        iprot.skip(ftype)
8947 
      iprot.readFieldEnd()
8948 
    iprot.readStructEnd()
8949 
 
8950 
  def write(self, oprot):
8951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8953 
      return
8954 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 8955 
    if self.affiliateId is not None:
1996 vikas 8956 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8957 
      oprot.writeI64(self.affiliateId)
1845 vikas 8958 
      oprot.writeFieldEnd()
3431 rajveer 8959 
    if self.userId is not None:
1845 vikas 8960 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8961 
      oprot.writeI64(self.userId)
8962 
      oprot.writeFieldEnd()
3431 rajveer 8963 
    if self.event is not None:
3378 vikas 8964 
      oprot.writeFieldBegin('event', TType.I32, 3)
8965 
      oprot.writeI32(self.event)
1845 vikas 8966 
      oprot.writeFieldEnd()
3431 rajveer 8967 
    if self.url is not None:
1845 vikas 8968 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8969 
      oprot.writeString(self.url)
8970 
      oprot.writeFieldEnd()
3431 rajveer 8971 
    if self.data is not None:
1845 vikas 8972 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8973 
      oprot.writeString(self.data)
8974 
      oprot.writeFieldEnd()
3431 rajveer 8975 
    if self.addedOn is not None:
1859 vikas 8976 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8977 
      oprot.writeI64(self.addedOn)
8978 
      oprot.writeFieldEnd()
1845 vikas 8979 
    oprot.writeFieldStop()
8980 
    oprot.writeStructEnd()
8981 
 
3431 rajveer 8982 
  def validate(self):
8983 
    return
8984 
 
8985 
 
1845 vikas 8986 
  def __repr__(self):
8987 
    L = ['%s=%r' % (key, value)
8988 
      for key, value in self.__dict__.iteritems()]
8989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8990 
 
8991 
  def __eq__(self, other):
8992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8993 
 
8994 
  def __ne__(self, other):
8995 
    return not (self == other)
8996 
 
8997 
class addTrackLog_result:
8998 
  """
8999 
  Attributes:
9000 
   - success
9001 
   - utx
9002 
  """
9003 
 
9004 
  thrift_spec = (
9005 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9006 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9007 
  )
9008 
 
9009 
  def __init__(self, success=None, utx=None,):
9010 
    self.success = success
9011 
    self.utx = utx
9012 
 
9013 
  def read(self, iprot):
9014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9016 
      return
9017 
    iprot.readStructBegin()
9018 
    while True:
9019 
      (fname, ftype, fid) = iprot.readFieldBegin()
9020 
      if ftype == TType.STOP:
9021 
        break
9022 
      if fid == 0:
9023 
        if ftype == TType.I64:
9024 
          self.success = iprot.readI64();
9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      elif fid == 1:
9028 
        if ftype == TType.STRUCT:
1996 vikas 9029 
          self.utx = UserAffiliateException()
1845 vikas 9030 
          self.utx.read(iprot)
9031 
        else:
9032 
          iprot.skip(ftype)
9033 
      else:
9034 
        iprot.skip(ftype)
9035 
      iprot.readFieldEnd()
9036 
    iprot.readStructEnd()
9037 
 
9038 
  def write(self, oprot):
9039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9041 
      return
9042 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9043 
    if self.success is not None:
1845 vikas 9044 
      oprot.writeFieldBegin('success', TType.I64, 0)
9045 
      oprot.writeI64(self.success)
9046 
      oprot.writeFieldEnd()
3431 rajveer 9047 
    if self.utx is not None:
1845 vikas 9048 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9049 
      self.utx.write(oprot)
9050 
      oprot.writeFieldEnd()
9051 
    oprot.writeFieldStop()
9052 
    oprot.writeStructEnd()
9053 
 
3431 rajveer 9054 
  def validate(self):
9055 
    return
9056 
 
9057 
 
1845 vikas 9058 
  def __repr__(self):
9059 
    L = ['%s=%r' % (key, value)
9060 
      for key, value in self.__dict__.iteritems()]
9061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9062 
 
9063 
  def __eq__(self, other):
9064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9065 
 
9066 
  def __ne__(self, other):
9067 
    return not (self == other)
9068 
 
9069 
class getTrackLogById_args:
9070 
  """
9071 
  Attributes:
9072 
   - id
9073 
  """
9074 
 
9075 
  thrift_spec = (
9076 
    None, # 0
9077 
    (1, TType.I64, 'id', None, None, ), # 1
9078 
  )
9079 
 
9080 
  def __init__(self, id=None,):
9081 
    self.id = id
9082 
 
9083 
  def read(self, iprot):
9084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9086 
      return
9087 
    iprot.readStructBegin()
9088 
    while True:
9089 
      (fname, ftype, fid) = iprot.readFieldBegin()
9090 
      if ftype == TType.STOP:
9091 
        break
9092 
      if fid == 1:
9093 
        if ftype == TType.I64:
9094 
          self.id = iprot.readI64();
9095 
        else:
9096 
          iprot.skip(ftype)
9097 
      else:
9098 
        iprot.skip(ftype)
9099 
      iprot.readFieldEnd()
9100 
    iprot.readStructEnd()
9101 
 
9102 
  def write(self, oprot):
9103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9105 
      return
9106 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9107 
    if self.id is not None:
1845 vikas 9108 
      oprot.writeFieldBegin('id', TType.I64, 1)
9109 
      oprot.writeI64(self.id)
9110 
      oprot.writeFieldEnd()
9111 
    oprot.writeFieldStop()
9112 
    oprot.writeStructEnd()
9113 
 
3431 rajveer 9114 
  def validate(self):
9115 
    return
9116 
 
9117 
 
1845 vikas 9118 
  def __repr__(self):
9119 
    L = ['%s=%r' % (key, value)
9120 
      for key, value in self.__dict__.iteritems()]
9121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9122 
 
9123 
  def __eq__(self, other):
9124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9125 
 
9126 
  def __ne__(self, other):
9127 
    return not (self == other)
9128 
 
9129 
class getTrackLogById_result:
9130 
  """
9131 
  Attributes:
9132 
   - success
9133 
   - utx
9134 
  """
9135 
 
9136 
  thrift_spec = (
9137 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9138 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9139 
  )
9140 
 
9141 
  def __init__(self, success=None, utx=None,):
9142 
    self.success = success
9143 
    self.utx = utx
9144 
 
9145 
  def read(self, iprot):
9146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9148 
      return
9149 
    iprot.readStructBegin()
9150 
    while True:
9151 
      (fname, ftype, fid) = iprot.readFieldBegin()
9152 
      if ftype == TType.STOP:
9153 
        break
9154 
      if fid == 0:
9155 
        if ftype == TType.STRUCT:
9156 
          self.success = TrackLog()
9157 
          self.success.read(iprot)
9158 
        else:
9159 
          iprot.skip(ftype)
9160 
      elif fid == 1:
9161 
        if ftype == TType.STRUCT:
1996 vikas 9162 
          self.utx = UserAffiliateException()
1845 vikas 9163 
          self.utx.read(iprot)
9164 
        else:
9165 
          iprot.skip(ftype)
9166 
      else:
9167 
        iprot.skip(ftype)
9168 
      iprot.readFieldEnd()
9169 
    iprot.readStructEnd()
9170 
 
9171 
  def write(self, oprot):
9172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9174 
      return
9175 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9176 
    if self.success is not None:
1845 vikas 9177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9178 
      self.success.write(oprot)
9179 
      oprot.writeFieldEnd()
3431 rajveer 9180 
    if self.utx is not None:
1845 vikas 9181 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9182 
      self.utx.write(oprot)
9183 
      oprot.writeFieldEnd()
9184 
    oprot.writeFieldStop()
9185 
    oprot.writeStructEnd()
9186 
 
3431 rajveer 9187 
  def validate(self):
9188 
    return
9189 
 
9190 
 
1845 vikas 9191 
  def __repr__(self):
9192 
    L = ['%s=%r' % (key, value)
9193 
      for key, value in self.__dict__.iteritems()]
9194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9195 
 
9196 
  def __eq__(self, other):
9197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9198 
 
9199 
  def __ne__(self, other):
9200 
    return not (self == other)
9201 
 
1996 vikas 9202 
class getTrackLogsByAffiliate_args:
1845 vikas 9203 
  """
9204 
  Attributes:
1996 vikas 9205 
   - affiliateId
3293 vikas 9206 
   - startDate
9207 
   - endDate
1845 vikas 9208 
  """
9209 
 
9210 
  thrift_spec = (
9211 
    None, # 0
1996 vikas 9212 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9213 
    (2, TType.I64, 'startDate', None, None, ), # 2
9214 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9215 
  )
9216 
 
3293 vikas 9217 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9218 
    self.affiliateId = affiliateId
3293 vikas 9219 
    self.startDate = startDate
9220 
    self.endDate = endDate
1845 vikas 9221 
 
9222 
  def read(self, iprot):
9223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9225 
      return
9226 
    iprot.readStructBegin()
9227 
    while True:
9228 
      (fname, ftype, fid) = iprot.readFieldBegin()
9229 
      if ftype == TType.STOP:
9230 
        break
9231 
      if fid == 1:
9232 
        if ftype == TType.I64:
1996 vikas 9233 
          self.affiliateId = iprot.readI64();
1845 vikas 9234 
        else:
9235 
          iprot.skip(ftype)
3293 vikas 9236 
      elif fid == 2:
9237 
        if ftype == TType.I64:
9238 
          self.startDate = iprot.readI64();
9239 
        else:
9240 
          iprot.skip(ftype)
9241 
      elif fid == 3:
9242 
        if ftype == TType.I64:
9243 
          self.endDate = iprot.readI64();
9244 
        else:
9245 
          iprot.skip(ftype)
1845 vikas 9246 
      else:
9247 
        iprot.skip(ftype)
9248 
      iprot.readFieldEnd()
9249 
    iprot.readStructEnd()
9250 
 
9251 
  def write(self, oprot):
9252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9254 
      return
1996 vikas 9255 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9256 
    if self.affiliateId is not None:
1996 vikas 9257 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9258 
      oprot.writeI64(self.affiliateId)
1845 vikas 9259 
      oprot.writeFieldEnd()
3431 rajveer 9260 
    if self.startDate is not None:
3293 vikas 9261 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9262 
      oprot.writeI64(self.startDate)
9263 
      oprot.writeFieldEnd()
3431 rajveer 9264 
    if self.endDate is not None:
3293 vikas 9265 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9266 
      oprot.writeI64(self.endDate)
9267 
      oprot.writeFieldEnd()
1845 vikas 9268 
    oprot.writeFieldStop()
9269 
    oprot.writeStructEnd()
9270 
 
3431 rajveer 9271 
  def validate(self):
9272 
    return
9273 
 
9274 
 
1845 vikas 9275 
  def __repr__(self):
9276 
    L = ['%s=%r' % (key, value)
9277 
      for key, value in self.__dict__.iteritems()]
9278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9279 
 
9280 
  def __eq__(self, other):
9281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9282 
 
9283 
  def __ne__(self, other):
9284 
    return not (self == other)
9285 
 
1996 vikas 9286 
class getTrackLogsByAffiliate_result:
1845 vikas 9287 
  """
9288 
  Attributes:
9289 
   - success
9290 
   - utx
9291 
  """
9292 
 
9293 
  thrift_spec = (
9294 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9295 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9296 
  )
9297 
 
9298 
  def __init__(self, success=None, utx=None,):
9299 
    self.success = success
9300 
    self.utx = utx
9301 
 
9302 
  def read(self, iprot):
9303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9305 
      return
9306 
    iprot.readStructBegin()
9307 
    while True:
9308 
      (fname, ftype, fid) = iprot.readFieldBegin()
9309 
      if ftype == TType.STOP:
9310 
        break
9311 
      if fid == 0:
9312 
        if ftype == TType.LIST:
9313 
          self.success = []
7746 amit.gupta 9314 
          (_etype128, _size125) = iprot.readListBegin()
9315 
          for _i129 in xrange(_size125):
9316 
            _elem130 = TrackLog()
9317 
            _elem130.read(iprot)
9318 
            self.success.append(_elem130)
1845 vikas 9319 
          iprot.readListEnd()
9320 
        else:
9321 
          iprot.skip(ftype)
9322 
      elif fid == 1:
9323 
        if ftype == TType.STRUCT:
1996 vikas 9324 
          self.utx = UserAffiliateException()
1845 vikas 9325 
          self.utx.read(iprot)
9326 
        else:
9327 
          iprot.skip(ftype)
9328 
      else:
9329 
        iprot.skip(ftype)
9330 
      iprot.readFieldEnd()
9331 
    iprot.readStructEnd()
9332 
 
9333 
  def write(self, oprot):
9334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9336 
      return
1996 vikas 9337 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9338 
    if self.success is not None:
1845 vikas 9339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9340 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 9341 
      for iter131 in self.success:
9342 
        iter131.write(oprot)
1845 vikas 9343 
      oprot.writeListEnd()
9344 
      oprot.writeFieldEnd()
3431 rajveer 9345 
    if self.utx is not None:
1845 vikas 9346 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9347 
      self.utx.write(oprot)
9348 
      oprot.writeFieldEnd()
9349 
    oprot.writeFieldStop()
9350 
    oprot.writeStructEnd()
9351 
 
3431 rajveer 9352 
  def validate(self):
9353 
    return
9354 
 
9355 
 
1845 vikas 9356 
  def __repr__(self):
9357 
    L = ['%s=%r' % (key, value)
9358 
      for key, value in self.__dict__.iteritems()]
9359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9360 
 
9361 
  def __eq__(self, other):
9362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9363 
 
9364 
  def __ne__(self, other):
9365 
    return not (self == other)
9366 
 
9367 
class getTrackLogsByUser_args:
9368 
  """
9369 
  Attributes:
9370 
   - userId
9371 
  """
9372 
 
9373 
  thrift_spec = (
9374 
    None, # 0
9375 
    (1, TType.I64, 'userId', None, None, ), # 1
9376 
  )
9377 
 
9378 
  def __init__(self, userId=None,):
9379 
    self.userId = userId
9380 
 
9381 
  def read(self, iprot):
9382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9384 
      return
9385 
    iprot.readStructBegin()
9386 
    while True:
9387 
      (fname, ftype, fid) = iprot.readFieldBegin()
9388 
      if ftype == TType.STOP:
9389 
        break
9390 
      if fid == 1:
9391 
        if ftype == TType.I64:
9392 
          self.userId = iprot.readI64();
9393 
        else:
9394 
          iprot.skip(ftype)
9395 
      else:
9396 
        iprot.skip(ftype)
9397 
      iprot.readFieldEnd()
9398 
    iprot.readStructEnd()
9399 
 
9400 
  def write(self, oprot):
9401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9403 
      return
9404 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9405 
    if self.userId is not None:
1845 vikas 9406 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9407 
      oprot.writeI64(self.userId)
9408 
      oprot.writeFieldEnd()
9409 
    oprot.writeFieldStop()
9410 
    oprot.writeStructEnd()
9411 
 
3431 rajveer 9412 
  def validate(self):
9413 
    return
9414 
 
9415 
 
1845 vikas 9416 
  def __repr__(self):
9417 
    L = ['%s=%r' % (key, value)
9418 
      for key, value in self.__dict__.iteritems()]
9419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9420 
 
9421 
  def __eq__(self, other):
9422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9423 
 
9424 
  def __ne__(self, other):
9425 
    return not (self == other)
9426 
 
9427 
class getTrackLogsByUser_result:
9428 
  """
9429 
  Attributes:
9430 
   - success
9431 
   - utx
9432 
  """
9433 
 
9434 
  thrift_spec = (
9435 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9436 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9437 
  )
9438 
 
9439 
  def __init__(self, success=None, utx=None,):
9440 
    self.success = success
9441 
    self.utx = utx
9442 
 
9443 
  def read(self, iprot):
9444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9446 
      return
9447 
    iprot.readStructBegin()
9448 
    while True:
9449 
      (fname, ftype, fid) = iprot.readFieldBegin()
9450 
      if ftype == TType.STOP:
9451 
        break
9452 
      if fid == 0:
9453 
        if ftype == TType.LIST:
9454 
          self.success = []
7746 amit.gupta 9455 
          (_etype135, _size132) = iprot.readListBegin()
9456 
          for _i136 in xrange(_size132):
9457 
            _elem137 = TrackLog()
9458 
            _elem137.read(iprot)
9459 
            self.success.append(_elem137)
1845 vikas 9460 
          iprot.readListEnd()
9461 
        else:
9462 
          iprot.skip(ftype)
9463 
      elif fid == 1:
9464 
        if ftype == TType.STRUCT:
1996 vikas 9465 
          self.utx = UserAffiliateException()
1845 vikas 9466 
          self.utx.read(iprot)
9467 
        else:
9468 
          iprot.skip(ftype)
9469 
      else:
9470 
        iprot.skip(ftype)
9471 
      iprot.readFieldEnd()
9472 
    iprot.readStructEnd()
9473 
 
9474 
  def write(self, oprot):
9475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9477 
      return
9478 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 9479 
    if self.success is not None:
1845 vikas 9480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 9482 
      for iter138 in self.success:
9483 
        iter138.write(oprot)
1845 vikas 9484 
      oprot.writeListEnd()
9485 
      oprot.writeFieldEnd()
3431 rajveer 9486 
    if self.utx is not None:
1845 vikas 9487 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9488 
      self.utx.write(oprot)
9489 
      oprot.writeFieldEnd()
9490 
    oprot.writeFieldStop()
9491 
    oprot.writeStructEnd()
9492 
 
3431 rajveer 9493 
  def validate(self):
9494 
    return
9495 
 
9496 
 
1845 vikas 9497 
  def __repr__(self):
9498 
    L = ['%s=%r' % (key, value)
9499 
      for key, value in self.__dict__.iteritems()]
9500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9501 
 
9502 
  def __eq__(self, other):
9503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9504 
 
9505 
  def __ne__(self, other):
9506 
    return not (self == other)
9507 
 
9508 
class getTrackLogs_args:
9509 
  """
9510 
  Attributes:
9511 
   - userId
9512 
   - event
9513 
   - url
9514 
  """
9515 
 
9516 
  thrift_spec = (
9517 
    None, # 0
1996 vikas 9518 
    (1, TType.I64, 'userId', None, None, ), # 1
9519 
    (2, TType.STRING, 'event', None, None, ), # 2
9520 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9521 
  )
9522 
 
1996 vikas 9523 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9524 
    self.userId = userId
9525 
    self.event = event
9526 
    self.url = url
9527 
 
9528 
  def read(self, iprot):
9529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9531 
      return
9532 
    iprot.readStructBegin()
9533 
    while True:
9534 
      (fname, ftype, fid) = iprot.readFieldBegin()
9535 
      if ftype == TType.STOP:
9536 
        break
9537 
      if fid == 1:
9538 
        if ftype == TType.I64:
1996 vikas 9539 
          self.userId = iprot.readI64();
1845 vikas 9540 
        else:
9541 
          iprot.skip(ftype)
9542 
      elif fid == 2:
9543 
        if ftype == TType.STRING:
9544 
          self.event = iprot.readString();
9545 
        else:
9546 
          iprot.skip(ftype)
1996 vikas 9547 
      elif fid == 3:
1845 vikas 9548 
        if ftype == TType.STRING:
9549 
          self.url = iprot.readString();
9550 
        else:
9551 
          iprot.skip(ftype)
9552 
      else:
9553 
        iprot.skip(ftype)
9554 
      iprot.readFieldEnd()
9555 
    iprot.readStructEnd()
9556 
 
9557 
  def write(self, oprot):
9558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9560 
      return
9561 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 9562 
    if self.userId is not None:
1996 vikas 9563 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9564 
      oprot.writeI64(self.userId)
9565 
      oprot.writeFieldEnd()
3431 rajveer 9566 
    if self.event is not None:
1996 vikas 9567 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9568 
      oprot.writeString(self.event)
9569 
      oprot.writeFieldEnd()
3431 rajveer 9570 
    if self.url is not None:
1996 vikas 9571 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9572 
      oprot.writeString(self.url)
9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
3431 rajveer 9577 
  def validate(self):
9578 
    return
9579 
 
9580 
 
1845 vikas 9581 
  def __repr__(self):
9582 
    L = ['%s=%r' % (key, value)
9583 
      for key, value in self.__dict__.iteritems()]
9584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9585 
 
9586 
  def __eq__(self, other):
9587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9588 
 
9589 
  def __ne__(self, other):
9590 
    return not (self == other)
9591 
 
9592 
class getTrackLogs_result:
9593 
  """
9594 
  Attributes:
9595 
   - success
9596 
   - utx
9597 
  """
9598 
 
9599 
  thrift_spec = (
9600 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9601 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9602 
  )
9603 
 
9604 
  def __init__(self, success=None, utx=None,):
9605 
    self.success = success
9606 
    self.utx = utx
9607 
 
9608 
  def read(self, iprot):
9609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9611 
      return
9612 
    iprot.readStructBegin()
9613 
    while True:
9614 
      (fname, ftype, fid) = iprot.readFieldBegin()
9615 
      if ftype == TType.STOP:
9616 
        break
9617 
      if fid == 0:
9618 
        if ftype == TType.LIST:
9619 
          self.success = []
7746 amit.gupta 9620 
          (_etype142, _size139) = iprot.readListBegin()
9621 
          for _i143 in xrange(_size139):
9622 
            _elem144 = TrackLog()
9623 
            _elem144.read(iprot)
9624 
            self.success.append(_elem144)
1845 vikas 9625 
          iprot.readListEnd()
9626 
        else:
9627 
          iprot.skip(ftype)
9628 
      elif fid == 1:
9629 
        if ftype == TType.STRUCT:
1996 vikas 9630 
          self.utx = UserAffiliateException()
1845 vikas 9631 
          self.utx.read(iprot)
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      else:
9635 
        iprot.skip(ftype)
9636 
      iprot.readFieldEnd()
9637 
    iprot.readStructEnd()
9638 
 
9639 
  def write(self, oprot):
9640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9642 
      return
9643 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 9644 
    if self.success is not None:
1845 vikas 9645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9646 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 9647 
      for iter145 in self.success:
9648 
        iter145.write(oprot)
1845 vikas 9649 
      oprot.writeListEnd()
9650 
      oprot.writeFieldEnd()
3431 rajveer 9651 
    if self.utx is not None:
1845 vikas 9652 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9653 
      self.utx.write(oprot)
9654 
      oprot.writeFieldEnd()
9655 
    oprot.writeFieldStop()
9656 
    oprot.writeStructEnd()
9657 
 
3431 rajveer 9658 
  def validate(self):
9659 
    return
9660 
 
9661 
 
1845 vikas 9662 
  def __repr__(self):
9663 
    L = ['%s=%r' % (key, value)
9664 
      for key, value in self.__dict__.iteritems()]
9665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9666 
 
9667 
  def __eq__(self, other):
9668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9669 
 
9670 
  def __ne__(self, other):
9671 
    return not (self == other)
9672 
 
559 chandransh 9673 
class getCurrentCart_args:
94 ashish 9674 
  """
9675 
  Attributes:
559 chandransh 9676 
   - userId
9677 
  """
9678 
 
9679 
  thrift_spec = (
9680 
    None, # 0
9681 
    (1, TType.I64, 'userId', None, None, ), # 1
9682 
  )
9683 
 
9684 
  def __init__(self, userId=None,):
9685 
    self.userId = userId
9686 
 
9687 
  def read(self, iprot):
9688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9690 
      return
9691 
    iprot.readStructBegin()
9692 
    while True:
9693 
      (fname, ftype, fid) = iprot.readFieldBegin()
9694 
      if ftype == TType.STOP:
9695 
        break
9696 
      if fid == 1:
9697 
        if ftype == TType.I64:
9698 
          self.userId = iprot.readI64();
9699 
        else:
9700 
          iprot.skip(ftype)
9701 
      else:
9702 
        iprot.skip(ftype)
9703 
      iprot.readFieldEnd()
9704 
    iprot.readStructEnd()
9705 
 
9706 
  def write(self, oprot):
9707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9709 
      return
9710 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 9711 
    if self.userId is not None:
559 chandransh 9712 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9713 
      oprot.writeI64(self.userId)
9714 
      oprot.writeFieldEnd()
9715 
    oprot.writeFieldStop()
9716 
    oprot.writeStructEnd()
9717 
 
3431 rajveer 9718 
  def validate(self):
9719 
    return
9720 
 
9721 
 
559 chandransh 9722 
  def __repr__(self):
9723 
    L = ['%s=%r' % (key, value)
9724 
      for key, value in self.__dict__.iteritems()]
9725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9726 
 
9727 
  def __eq__(self, other):
9728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9729 
 
9730 
  def __ne__(self, other):
9731 
    return not (self == other)
9732 
 
9733 
class getCurrentCart_result:
9734 
  """
9735 
  Attributes:
94 ashish 9736 
   - success
559 chandransh 9737 
   - scx
94 ashish 9738 
  """
9739 
 
9740 
  thrift_spec = (
559 chandransh 9741 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9742 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9743 
  )
9744 
 
559 chandransh 9745 
  def __init__(self, success=None, scx=None,):
94 ashish 9746 
    self.success = success
559 chandransh 9747 
    self.scx = scx
94 ashish 9748 
 
9749 
  def read(self, iprot):
9750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9752 
      return
9753 
    iprot.readStructBegin()
9754 
    while True:
9755 
      (fname, ftype, fid) = iprot.readFieldBegin()
9756 
      if ftype == TType.STOP:
9757 
        break
9758 
      if fid == 0:
559 chandransh 9759 
        if ftype == TType.STRUCT:
9760 
          self.success = Cart()
9761 
          self.success.read(iprot)
94 ashish 9762 
        else:
9763 
          iprot.skip(ftype)
9764 
      elif fid == 1:
9765 
        if ftype == TType.STRUCT:
559 chandransh 9766 
          self.scx = ShoppingCartException()
9767 
          self.scx.read(iprot)
94 ashish 9768 
        else:
9769 
          iprot.skip(ftype)
9770 
      else:
9771 
        iprot.skip(ftype)
9772 
      iprot.readFieldEnd()
9773 
    iprot.readStructEnd()
9774 
 
9775 
  def write(self, oprot):
9776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9778 
      return
559 chandransh 9779 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 9780 
    if self.success is not None:
559 chandransh 9781 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9782 
      self.success.write(oprot)
94 ashish 9783 
      oprot.writeFieldEnd()
3431 rajveer 9784 
    if self.scx is not None:
559 chandransh 9785 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9786 
      self.scx.write(oprot)
94 ashish 9787 
      oprot.writeFieldEnd()
9788 
    oprot.writeFieldStop()
9789 
    oprot.writeStructEnd()
9790 
 
3431 rajveer 9791 
  def validate(self):
9792 
    return
9793 
 
9794 
 
94 ashish 9795 
  def __repr__(self):
9796 
    L = ['%s=%r' % (key, value)
9797 
      for key, value in self.__dict__.iteritems()]
9798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9799 
 
9800 
  def __eq__(self, other):
9801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9802 
 
9803 
  def __ne__(self, other):
9804 
    return not (self == other)
9805 
 
559 chandransh 9806 
class getCart_args:
504 rajveer 9807 
  """
9808 
  Attributes:
559 chandransh 9809 
   - cartId
504 rajveer 9810 
  """
9811 
 
9812 
  thrift_spec = (
9813 
    None, # 0
559 chandransh 9814 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9815 
  )
9816 
 
559 chandransh 9817 
  def __init__(self, cartId=None,):
9818 
    self.cartId = cartId
504 rajveer 9819 
 
9820 
  def read(self, iprot):
9821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9823 
      return
9824 
    iprot.readStructBegin()
9825 
    while True:
9826 
      (fname, ftype, fid) = iprot.readFieldBegin()
9827 
      if ftype == TType.STOP:
9828 
        break
9829 
      if fid == 1:
9830 
        if ftype == TType.I64:
559 chandransh 9831 
          self.cartId = iprot.readI64();
504 rajveer 9832 
        else:
9833 
          iprot.skip(ftype)
9834 
      else:
9835 
        iprot.skip(ftype)
9836 
      iprot.readFieldEnd()
9837 
    iprot.readStructEnd()
9838 
 
9839 
  def write(self, oprot):
9840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9842 
      return
559 chandransh 9843 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 9844 
    if self.cartId is not None:
559 chandransh 9845 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9846 
      oprot.writeI64(self.cartId)
504 rajveer 9847 
      oprot.writeFieldEnd()
9848 
    oprot.writeFieldStop()
9849 
    oprot.writeStructEnd()
9850 
 
3431 rajveer 9851 
  def validate(self):
9852 
    return
9853 
 
9854 
 
504 rajveer 9855 
  def __repr__(self):
9856 
    L = ['%s=%r' % (key, value)
9857 
      for key, value in self.__dict__.iteritems()]
9858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9859 
 
9860 
  def __eq__(self, other):
9861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9862 
 
9863 
  def __ne__(self, other):
9864 
    return not (self == other)
9865 
 
559 chandransh 9866 
class getCart_result:
504 rajveer 9867 
  """
9868 
  Attributes:
9869 
   - success
559 chandransh 9870 
   - scx
504 rajveer 9871 
  """
9872 
 
9873 
  thrift_spec = (
559 chandransh 9874 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9875 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9876 
  )
9877 
 
559 chandransh 9878 
  def __init__(self, success=None, scx=None,):
504 rajveer 9879 
    self.success = success
559 chandransh 9880 
    self.scx = scx
504 rajveer 9881 
 
9882 
  def read(self, iprot):
9883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9885 
      return
9886 
    iprot.readStructBegin()
9887 
    while True:
9888 
      (fname, ftype, fid) = iprot.readFieldBegin()
9889 
      if ftype == TType.STOP:
9890 
        break
9891 
      if fid == 0:
559 chandransh 9892 
        if ftype == TType.STRUCT:
9893 
          self.success = Cart()
9894 
          self.success.read(iprot)
504 rajveer 9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      elif fid == 1:
9898 
        if ftype == TType.STRUCT:
559 chandransh 9899 
          self.scx = ShoppingCartException()
9900 
          self.scx.read(iprot)
504 rajveer 9901 
        else:
9902 
          iprot.skip(ftype)
9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
559 chandransh 9912 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 9913 
    if self.success is not None:
559 chandransh 9914 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9915 
      self.success.write(oprot)
504 rajveer 9916 
      oprot.writeFieldEnd()
3431 rajveer 9917 
    if self.scx is not None:
559 chandransh 9918 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9919 
      self.scx.write(oprot)
504 rajveer 9920 
      oprot.writeFieldEnd()
9921 
    oprot.writeFieldStop()
9922 
    oprot.writeStructEnd()
9923 
 
3431 rajveer 9924 
  def validate(self):
9925 
    return
9926 
 
9927 
 
504 rajveer 9928 
  def __repr__(self):
9929 
    L = ['%s=%r' % (key, value)
9930 
      for key, value in self.__dict__.iteritems()]
9931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9932 
 
9933 
  def __eq__(self, other):
9934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9935 
 
9936 
  def __ne__(self, other):
9937 
    return not (self == other)
9938 
 
559 chandransh 9939 
class getCartsByTime_args:
9940 
  """
9941 
  Attributes:
9942 
   - from_time
9943 
   - to_time
9944 
   - status
9945 
  """
9946 
 
9947 
  thrift_spec = (
9948 
    None, # 0
9949 
    (1, TType.I64, 'from_time', None, None, ), # 1
9950 
    (2, TType.I64, 'to_time', None, None, ), # 2
9951 
    (3, TType.I32, 'status', None, None, ), # 3
9952 
  )
9953 
 
9954 
  def __init__(self, from_time=None, to_time=None, status=None,):
9955 
    self.from_time = from_time
9956 
    self.to_time = to_time
9957 
    self.status = status
9958 
 
9959 
  def read(self, iprot):
9960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9962 
      return
9963 
    iprot.readStructBegin()
9964 
    while True:
9965 
      (fname, ftype, fid) = iprot.readFieldBegin()
9966 
      if ftype == TType.STOP:
9967 
        break
9968 
      if fid == 1:
94 ashish 9969 
        if ftype == TType.I64:
559 chandransh 9970 
          self.from_time = iprot.readI64();
94 ashish 9971 
        else:
9972 
          iprot.skip(ftype)
122 ashish 9973 
      elif fid == 2:
559 chandransh 9974 
        if ftype == TType.I64:
9975 
          self.to_time = iprot.readI64();
122 ashish 9976 
        else:
9977 
          iprot.skip(ftype)
559 chandransh 9978 
      elif fid == 3:
9979 
        if ftype == TType.I32:
9980 
          self.status = iprot.readI32();
9981 
        else:
9982 
          iprot.skip(ftype)
94 ashish 9983 
      else:
9984 
        iprot.skip(ftype)
9985 
      iprot.readFieldEnd()
9986 
    iprot.readStructEnd()
9987 
 
9988 
  def write(self, oprot):
9989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9991 
      return
559 chandransh 9992 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 9993 
    if self.from_time is not None:
559 chandransh 9994 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9995 
      oprot.writeI64(self.from_time)
94 ashish 9996 
      oprot.writeFieldEnd()
3431 rajveer 9997 
    if self.to_time is not None:
559 chandransh 9998 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9999 
      oprot.writeI64(self.to_time)
122 ashish 10000 
      oprot.writeFieldEnd()
3431 rajveer 10001 
    if self.status is not None:
559 chandransh 10002 
      oprot.writeFieldBegin('status', TType.I32, 3)
10003 
      oprot.writeI32(self.status)
10004 
      oprot.writeFieldEnd()
94 ashish 10005 
    oprot.writeFieldStop()
10006 
    oprot.writeStructEnd()
10007 
 
3431 rajveer 10008 
  def validate(self):
10009 
    return
10010 
 
10011 
 
94 ashish 10012 
  def __repr__(self):
10013 
    L = ['%s=%r' % (key, value)
10014 
      for key, value in self.__dict__.iteritems()]
10015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10016 
 
10017 
  def __eq__(self, other):
10018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10019 
 
10020 
  def __ne__(self, other):
10021 
    return not (self == other)
10022 
 
559 chandransh 10023 
class getCartsByTime_result:
94 ashish 10024 
  """
10025 
  Attributes:
10026 
   - success
559 chandransh 10027 
   - scx
94 ashish 10028 
  """
10029 
 
10030 
  thrift_spec = (
559 chandransh 10031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10032 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10033 
  )
10034 
 
559 chandransh 10035 
  def __init__(self, success=None, scx=None,):
94 ashish 10036 
    self.success = success
559 chandransh 10037 
    self.scx = scx
94 ashish 10038 
 
10039 
  def read(self, iprot):
10040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10042 
      return
10043 
    iprot.readStructBegin()
10044 
    while True:
10045 
      (fname, ftype, fid) = iprot.readFieldBegin()
10046 
      if ftype == TType.STOP:
10047 
        break
10048 
      if fid == 0:
559 chandransh 10049 
        if ftype == TType.LIST:
10050 
          self.success = []
7746 amit.gupta 10051 
          (_etype149, _size146) = iprot.readListBegin()
10052 
          for _i150 in xrange(_size146):
10053 
            _elem151 = Cart()
10054 
            _elem151.read(iprot)
10055 
            self.success.append(_elem151)
559 chandransh 10056 
          iprot.readListEnd()
94 ashish 10057 
        else:
10058 
          iprot.skip(ftype)
10059 
      elif fid == 1:
10060 
        if ftype == TType.STRUCT:
559 chandransh 10061 
          self.scx = ShoppingCartException()
10062 
          self.scx.read(iprot)
94 ashish 10063 
        else:
10064 
          iprot.skip(ftype)
10065 
      else:
10066 
        iprot.skip(ftype)
10067 
      iprot.readFieldEnd()
10068 
    iprot.readStructEnd()
10069 
 
10070 
  def write(self, oprot):
10071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10073 
      return
559 chandransh 10074 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10075 
    if self.success is not None:
559 chandransh 10076 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10077 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 10078 
      for iter152 in self.success:
10079 
        iter152.write(oprot)
559 chandransh 10080 
      oprot.writeListEnd()
94 ashish 10081 
      oprot.writeFieldEnd()
3431 rajveer 10082 
    if self.scx is not None:
559 chandransh 10083 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10084 
      self.scx.write(oprot)
94 ashish 10085 
      oprot.writeFieldEnd()
10086 
    oprot.writeFieldStop()
10087 
    oprot.writeStructEnd()
10088 
 
3431 rajveer 10089 
  def validate(self):
10090 
    return
10091 
 
10092 
 
94 ashish 10093 
  def __repr__(self):
10094 
    L = ['%s=%r' % (key, value)
10095 
      for key, value in self.__dict__.iteritems()]
10096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10097 
 
10098 
  def __eq__(self, other):
10099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10100 
 
10101 
  def __ne__(self, other):
10102 
    return not (self == other)
10103 
 
559 chandransh 10104 
class addItemToCart_args:
10105 
  """
10106 
  Attributes:
10107 
   - cartId
10108 
   - itemId
10109 
   - quantity
3557 rajveer 10110 
   - sourceId
559 chandransh 10111 
  """
10112 
 
10113 
  thrift_spec = (
10114 
    None, # 0
10115 
    (1, TType.I64, 'cartId', None, None, ), # 1
10116 
    (2, TType.I64, 'itemId', None, None, ), # 2
10117 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10118 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10119 
  )
10120 
 
3557 rajveer 10121 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10122 
    self.cartId = cartId
10123 
    self.itemId = itemId
10124 
    self.quantity = quantity
3557 rajveer 10125 
    self.sourceId = sourceId
559 chandransh 10126 
 
10127 
  def read(self, iprot):
10128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10130 
      return
10131 
    iprot.readStructBegin()
10132 
    while True:
10133 
      (fname, ftype, fid) = iprot.readFieldBegin()
10134 
      if ftype == TType.STOP:
10135 
        break
10136 
      if fid == 1:
10137 
        if ftype == TType.I64:
10138 
          self.cartId = iprot.readI64();
10139 
        else:
10140 
          iprot.skip(ftype)
10141 
      elif fid == 2:
10142 
        if ftype == TType.I64:
10143 
          self.itemId = iprot.readI64();
10144 
        else:
10145 
          iprot.skip(ftype)
10146 
      elif fid == 3:
10147 
        if ftype == TType.I64:
10148 
          self.quantity = iprot.readI64();
10149 
        else:
10150 
          iprot.skip(ftype)
3557 rajveer 10151 
      elif fid == 4:
10152 
        if ftype == TType.I64:
10153 
          self.sourceId = iprot.readI64();
10154 
        else:
10155 
          iprot.skip(ftype)
559 chandransh 10156 
      else:
10157 
        iprot.skip(ftype)
10158 
      iprot.readFieldEnd()
10159 
    iprot.readStructEnd()
10160 
 
10161 
  def write(self, oprot):
10162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10164 
      return
10165 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10166 
    if self.cartId is not None:
559 chandransh 10167 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10168 
      oprot.writeI64(self.cartId)
10169 
      oprot.writeFieldEnd()
3431 rajveer 10170 
    if self.itemId is not None:
559 chandransh 10171 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10172 
      oprot.writeI64(self.itemId)
10173 
      oprot.writeFieldEnd()
3431 rajveer 10174 
    if self.quantity is not None:
559 chandransh 10175 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10176 
      oprot.writeI64(self.quantity)
10177 
      oprot.writeFieldEnd()
3557 rajveer 10178 
    if self.sourceId is not None:
10179 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10180 
      oprot.writeI64(self.sourceId)
10181 
      oprot.writeFieldEnd()
559 chandransh 10182 
    oprot.writeFieldStop()
10183 
    oprot.writeStructEnd()
10184 
 
3431 rajveer 10185 
  def validate(self):
10186 
    return
10187 
 
10188 
 
559 chandransh 10189 
  def __repr__(self):
10190 
    L = ['%s=%r' % (key, value)
10191 
      for key, value in self.__dict__.iteritems()]
10192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10193 
 
10194 
  def __eq__(self, other):
10195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10196 
 
10197 
  def __ne__(self, other):
10198 
    return not (self == other)
10199 
 
10200 
class addItemToCart_result:
10201 
  """
10202 
  Attributes:
2035 rajveer 10203 
   - success
559 chandransh 10204 
   - scx
10205 
  """
10206 
 
10207 
  thrift_spec = (
2035 rajveer 10208 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10209 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10210 
  )
10211 
 
2035 rajveer 10212 
  def __init__(self, success=None, scx=None,):
10213 
    self.success = success
559 chandransh 10214 
    self.scx = scx
10215 
 
10216 
  def read(self, iprot):
10217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10219 
      return
10220 
    iprot.readStructBegin()
10221 
    while True:
10222 
      (fname, ftype, fid) = iprot.readFieldBegin()
10223 
      if ftype == TType.STOP:
10224 
        break
2035 rajveer 10225 
      if fid == 0:
10226 
        if ftype == TType.STRING:
10227 
          self.success = iprot.readString();
10228 
        else:
10229 
          iprot.skip(ftype)
10230 
      elif fid == 1:
559 chandransh 10231 
        if ftype == TType.STRUCT:
10232 
          self.scx = ShoppingCartException()
10233 
          self.scx.read(iprot)
10234 
        else:
10235 
          iprot.skip(ftype)
10236 
      else:
10237 
        iprot.skip(ftype)
10238 
      iprot.readFieldEnd()
10239 
    iprot.readStructEnd()
10240 
 
10241 
  def write(self, oprot):
10242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10244 
      return
10245 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10246 
    if self.success is not None:
2035 rajveer 10247 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10248 
      oprot.writeString(self.success)
10249 
      oprot.writeFieldEnd()
3431 rajveer 10250 
    if self.scx is not None:
559 chandransh 10251 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10252 
      self.scx.write(oprot)
10253 
      oprot.writeFieldEnd()
10254 
    oprot.writeFieldStop()
10255 
    oprot.writeStructEnd()
10256 
 
3431 rajveer 10257 
  def validate(self):
10258 
    return
10259 
 
10260 
 
559 chandransh 10261 
  def __repr__(self):
10262 
    L = ['%s=%r' % (key, value)
10263 
      for key, value in self.__dict__.iteritems()]
10264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10265 
 
10266 
  def __eq__(self, other):
10267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10268 
 
10269 
  def __ne__(self, other):
10270 
    return not (self == other)
10271 
 
10272 
class deleteItemFromCart_args:
10273 
  """
10274 
  Attributes:
10275 
   - cartId
10276 
   - itemId
10277 
  """
10278 
 
10279 
  thrift_spec = (
10280 
    None, # 0
10281 
    (1, TType.I64, 'cartId', None, None, ), # 1
10282 
    (2, TType.I64, 'itemId', None, None, ), # 2
10283 
  )
10284 
 
10285 
  def __init__(self, cartId=None, itemId=None,):
10286 
    self.cartId = cartId
10287 
    self.itemId = itemId
10288 
 
10289 
  def read(self, iprot):
10290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10292 
      return
10293 
    iprot.readStructBegin()
10294 
    while True:
10295 
      (fname, ftype, fid) = iprot.readFieldBegin()
10296 
      if ftype == TType.STOP:
10297 
        break
10298 
      if fid == 1:
10299 
        if ftype == TType.I64:
10300 
          self.cartId = iprot.readI64();
10301 
        else:
10302 
          iprot.skip(ftype)
10303 
      elif fid == 2:
10304 
        if ftype == TType.I64:
10305 
          self.itemId = iprot.readI64();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      else:
10309 
        iprot.skip(ftype)
10310 
      iprot.readFieldEnd()
10311 
    iprot.readStructEnd()
10312 
 
10313 
  def write(self, oprot):
10314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10316 
      return
10317 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10318 
    if self.cartId is not None:
559 chandransh 10319 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10320 
      oprot.writeI64(self.cartId)
10321 
      oprot.writeFieldEnd()
3431 rajveer 10322 
    if self.itemId is not None:
559 chandransh 10323 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10324 
      oprot.writeI64(self.itemId)
10325 
      oprot.writeFieldEnd()
10326 
    oprot.writeFieldStop()
10327 
    oprot.writeStructEnd()
10328 
 
3431 rajveer 10329 
  def validate(self):
10330 
    return
10331 
 
10332 
 
559 chandransh 10333 
  def __repr__(self):
10334 
    L = ['%s=%r' % (key, value)
10335 
      for key, value in self.__dict__.iteritems()]
10336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10337 
 
10338 
  def __eq__(self, other):
10339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10340 
 
10341 
  def __ne__(self, other):
10342 
    return not (self == other)
10343 
 
10344 
class deleteItemFromCart_result:
10345 
  """
10346 
  Attributes:
10347 
   - scx
10348 
  """
10349 
 
10350 
  thrift_spec = (
10351 
    None, # 0
10352 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10353 
  )
10354 
 
10355 
  def __init__(self, scx=None,):
10356 
    self.scx = scx
10357 
 
10358 
  def read(self, iprot):
10359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10361 
      return
10362 
    iprot.readStructBegin()
10363 
    while True:
10364 
      (fname, ftype, fid) = iprot.readFieldBegin()
10365 
      if ftype == TType.STOP:
10366 
        break
10367 
      if fid == 1:
10368 
        if ftype == TType.STRUCT:
10369 
          self.scx = ShoppingCartException()
10370 
          self.scx.read(iprot)
10371 
        else:
10372 
          iprot.skip(ftype)
10373 
      else:
10374 
        iprot.skip(ftype)
10375 
      iprot.readFieldEnd()
10376 
    iprot.readStructEnd()
10377 
 
10378 
  def write(self, oprot):
10379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10381 
      return
10382 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10383 
    if self.scx is not None:
559 chandransh 10384 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10385 
      self.scx.write(oprot)
10386 
      oprot.writeFieldEnd()
10387 
    oprot.writeFieldStop()
10388 
    oprot.writeStructEnd()
10389 
 
3431 rajveer 10390 
  def validate(self):
10391 
    return
10392 
 
10393 
 
559 chandransh 10394 
  def __repr__(self):
10395 
    L = ['%s=%r' % (key, value)
10396 
      for key, value in self.__dict__.iteritems()]
10397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10398 
 
10399 
  def __eq__(self, other):
10400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10401 
 
10402 
  def __ne__(self, other):
10403 
    return not (self == other)
10404 
 
10405 
class addAddressToCart_args:
10406 
  """
10407 
  Attributes:
10408 
   - cartId
10409 
   - addressId
10410 
  """
10411 
 
10412 
  thrift_spec = (
10413 
    None, # 0
10414 
    (1, TType.I64, 'cartId', None, None, ), # 1
10415 
    (2, TType.I64, 'addressId', None, None, ), # 2
10416 
  )
10417 
 
10418 
  def __init__(self, cartId=None, addressId=None,):
10419 
    self.cartId = cartId
10420 
    self.addressId = addressId
10421 
 
10422 
  def read(self, iprot):
10423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10425 
      return
10426 
    iprot.readStructBegin()
10427 
    while True:
10428 
      (fname, ftype, fid) = iprot.readFieldBegin()
10429 
      if ftype == TType.STOP:
10430 
        break
10431 
      if fid == 1:
10432 
        if ftype == TType.I64:
10433 
          self.cartId = iprot.readI64();
10434 
        else:
10435 
          iprot.skip(ftype)
10436 
      elif fid == 2:
10437 
        if ftype == TType.I64:
10438 
          self.addressId = iprot.readI64();
10439 
        else:
10440 
          iprot.skip(ftype)
10441 
      else:
10442 
        iprot.skip(ftype)
10443 
      iprot.readFieldEnd()
10444 
    iprot.readStructEnd()
10445 
 
10446 
  def write(self, oprot):
10447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10449 
      return
10450 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 10451 
    if self.cartId is not None:
559 chandransh 10452 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10453 
      oprot.writeI64(self.cartId)
10454 
      oprot.writeFieldEnd()
3431 rajveer 10455 
    if self.addressId is not None:
559 chandransh 10456 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10457 
      oprot.writeI64(self.addressId)
10458 
      oprot.writeFieldEnd()
10459 
    oprot.writeFieldStop()
10460 
    oprot.writeStructEnd()
10461 
 
3431 rajveer 10462 
  def validate(self):
10463 
    return
10464 
 
10465 
 
559 chandransh 10466 
  def __repr__(self):
10467 
    L = ['%s=%r' % (key, value)
10468 
      for key, value in self.__dict__.iteritems()]
10469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10470 
 
10471 
  def __eq__(self, other):
10472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10473 
 
10474 
  def __ne__(self, other):
10475 
    return not (self == other)
10476 
 
10477 
class addAddressToCart_result:
575 chandransh 10478 
  """
10479 
  Attributes:
10480 
   - scx
10481 
  """
559 chandransh 10482 
 
10483 
  thrift_spec = (
575 chandransh 10484 
    None, # 0
10485 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10486 
  )
10487 
 
575 chandransh 10488 
  def __init__(self, scx=None,):
10489 
    self.scx = scx
10490 
 
559 chandransh 10491 
  def read(self, iprot):
10492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10494 
      return
10495 
    iprot.readStructBegin()
10496 
    while True:
10497 
      (fname, ftype, fid) = iprot.readFieldBegin()
10498 
      if ftype == TType.STOP:
10499 
        break
575 chandransh 10500 
      if fid == 1:
10501 
        if ftype == TType.STRUCT:
10502 
          self.scx = ShoppingCartException()
10503 
          self.scx.read(iprot)
10504 
        else:
10505 
          iprot.skip(ftype)
559 chandransh 10506 
      else:
10507 
        iprot.skip(ftype)
10508 
      iprot.readFieldEnd()
10509 
    iprot.readStructEnd()
10510 
 
10511 
  def write(self, oprot):
10512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10514 
      return
10515 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 10516 
    if self.scx is not None:
575 chandransh 10517 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10518 
      self.scx.write(oprot)
10519 
      oprot.writeFieldEnd()
559 chandransh 10520 
    oprot.writeFieldStop()
10521 
    oprot.writeStructEnd()
10522 
 
3431 rajveer 10523 
  def validate(self):
10524 
    return
10525 
 
10526 
 
559 chandransh 10527 
  def __repr__(self):
10528 
    L = ['%s=%r' % (key, value)
10529 
      for key, value in self.__dict__.iteritems()]
10530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10531 
 
10532 
  def __eq__(self, other):
10533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10534 
 
10535 
  def __ne__(self, other):
10536 
    return not (self == other)
10537 
 
5553 rajveer 10538 
class addStoreToCart_args:
10539 
  """
10540 
  Attributes:
10541 
   - cartId
10542 
   - storeId
10543 
  """
10544 
 
10545 
  thrift_spec = (
10546 
    None, # 0
10547 
    (1, TType.I64, 'cartId', None, None, ), # 1
10548 
    (2, TType.I64, 'storeId', None, None, ), # 2
10549 
  )
10550 
 
10551 
  def __init__(self, cartId=None, storeId=None,):
10552 
    self.cartId = cartId
10553 
    self.storeId = storeId
10554 
 
10555 
  def read(self, iprot):
10556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10558 
      return
10559 
    iprot.readStructBegin()
10560 
    while True:
10561 
      (fname, ftype, fid) = iprot.readFieldBegin()
10562 
      if ftype == TType.STOP:
10563 
        break
10564 
      if fid == 1:
10565 
        if ftype == TType.I64:
10566 
          self.cartId = iprot.readI64();
10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      elif fid == 2:
10570 
        if ftype == TType.I64:
10571 
          self.storeId = iprot.readI64();
10572 
        else:
10573 
          iprot.skip(ftype)
10574 
      else:
10575 
        iprot.skip(ftype)
10576 
      iprot.readFieldEnd()
10577 
    iprot.readStructEnd()
10578 
 
10579 
  def write(self, oprot):
10580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10582 
      return
10583 
    oprot.writeStructBegin('addStoreToCart_args')
10584 
    if self.cartId is not None:
10585 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10586 
      oprot.writeI64(self.cartId)
10587 
      oprot.writeFieldEnd()
10588 
    if self.storeId is not None:
10589 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
10590 
      oprot.writeI64(self.storeId)
10591 
      oprot.writeFieldEnd()
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
10610 
class addStoreToCart_result:
10611 
  """
10612 
  Attributes:
10613 
   - scx
10614 
  """
10615 
 
10616 
  thrift_spec = (
10617 
    None, # 0
10618 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10619 
  )
10620 
 
10621 
  def __init__(self, scx=None,):
10622 
    self.scx = scx
10623 
 
10624 
  def read(self, iprot):
10625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10627 
      return
10628 
    iprot.readStructBegin()
10629 
    while True:
10630 
      (fname, ftype, fid) = iprot.readFieldBegin()
10631 
      if ftype == TType.STOP:
10632 
        break
10633 
      if fid == 1:
10634 
        if ftype == TType.STRUCT:
10635 
          self.scx = ShoppingCartException()
10636 
          self.scx.read(iprot)
10637 
        else:
10638 
          iprot.skip(ftype)
10639 
      else:
10640 
        iprot.skip(ftype)
10641 
      iprot.readFieldEnd()
10642 
    iprot.readStructEnd()
10643 
 
10644 
  def write(self, oprot):
10645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10647 
      return
10648 
    oprot.writeStructBegin('addStoreToCart_result')
10649 
    if self.scx is not None:
10650 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10651 
      self.scx.write(oprot)
10652 
      oprot.writeFieldEnd()
10653 
    oprot.writeFieldStop()
10654 
    oprot.writeStructEnd()
10655 
 
10656 
  def validate(self):
10657 
    return
10658 
 
10659 
 
10660 
  def __repr__(self):
10661 
    L = ['%s=%r' % (key, value)
10662 
      for key, value in self.__dict__.iteritems()]
10663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10664 
 
10665 
  def __eq__(self, other):
10666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10667 
 
10668 
  def __ne__(self, other):
10669 
    return not (self == other)
10670 
 
1976 varun.gupt 10671 
class applyCouponToCart_args:
10672 
  """
10673 
  Attributes:
6922 anupam.sin 10674 
   - cart
1976 varun.gupt 10675 
   - couponCode
10676 
  """
10677 
 
10678 
  thrift_spec = (
10679 
    None, # 0
6922 anupam.sin 10680 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 10681 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10682 
  )
10683 
 
6922 anupam.sin 10684 
  def __init__(self, cart=None, couponCode=None,):
10685 
    self.cart = cart
1976 varun.gupt 10686 
    self.couponCode = couponCode
10687 
 
10688 
  def read(self, iprot):
10689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10691 
      return
10692 
    iprot.readStructBegin()
10693 
    while True:
10694 
      (fname, ftype, fid) = iprot.readFieldBegin()
10695 
      if ftype == TType.STOP:
10696 
        break
10697 
      if fid == 1:
6922 anupam.sin 10698 
        if ftype == TType.STRUCT:
10699 
          self.cart = Cart()
10700 
          self.cart.read(iprot)
1976 varun.gupt 10701 
        else:
10702 
          iprot.skip(ftype)
10703 
      elif fid == 2:
10704 
        if ftype == TType.STRING:
10705 
          self.couponCode = iprot.readString();
10706 
        else:
10707 
          iprot.skip(ftype)
10708 
      else:
10709 
        iprot.skip(ftype)
10710 
      iprot.readFieldEnd()
10711 
    iprot.readStructEnd()
10712 
 
10713 
  def write(self, oprot):
10714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10716 
      return
10717 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 10718 
    if self.cart is not None:
10719 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
10720 
      self.cart.write(oprot)
1976 varun.gupt 10721 
      oprot.writeFieldEnd()
3431 rajveer 10722 
    if self.couponCode is not None:
1976 varun.gupt 10723 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10724 
      oprot.writeString(self.couponCode)
10725 
      oprot.writeFieldEnd()
10726 
    oprot.writeFieldStop()
10727 
    oprot.writeStructEnd()
10728 
 
3431 rajveer 10729 
  def validate(self):
10730 
    return
10731 
 
10732 
 
1976 varun.gupt 10733 
  def __repr__(self):
10734 
    L = ['%s=%r' % (key, value)
10735 
      for key, value in self.__dict__.iteritems()]
10736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10737 
 
10738 
  def __eq__(self, other):
10739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10740 
 
10741 
  def __ne__(self, other):
10742 
    return not (self == other)
10743 
 
10744 
class applyCouponToCart_result:
10745 
  """
10746 
  Attributes:
10747 
   - scx
10748 
  """
10749 
 
10750 
  thrift_spec = (
10751 
    None, # 0
10752 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10753 
  )
10754 
 
10755 
  def __init__(self, scx=None,):
10756 
    self.scx = scx
10757 
 
10758 
  def read(self, iprot):
10759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10761 
      return
10762 
    iprot.readStructBegin()
10763 
    while True:
10764 
      (fname, ftype, fid) = iprot.readFieldBegin()
10765 
      if ftype == TType.STOP:
10766 
        break
10767 
      if fid == 1:
10768 
        if ftype == TType.STRUCT:
10769 
          self.scx = ShoppingCartException()
10770 
          self.scx.read(iprot)
10771 
        else:
10772 
          iprot.skip(ftype)
10773 
      else:
10774 
        iprot.skip(ftype)
10775 
      iprot.readFieldEnd()
10776 
    iprot.readStructEnd()
10777 
 
10778 
  def write(self, oprot):
10779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10781 
      return
10782 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 10783 
    if self.scx is not None:
1976 varun.gupt 10784 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10785 
      self.scx.write(oprot)
10786 
      oprot.writeFieldEnd()
10787 
    oprot.writeFieldStop()
10788 
    oprot.writeStructEnd()
10789 
 
3431 rajveer 10790 
  def validate(self):
10791 
    return
10792 
 
10793 
 
1976 varun.gupt 10794 
  def __repr__(self):
10795 
    L = ['%s=%r' % (key, value)
10796 
      for key, value in self.__dict__.iteritems()]
10797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10798 
 
10799 
  def __eq__(self, other):
10800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10801 
 
10802 
  def __ne__(self, other):
10803 
    return not (self == other)
10804 
 
10805 
class removeCoupon_args:
10806 
  """
10807 
  Attributes:
10808 
   - cartId
10809 
  """
10810 
 
10811 
  thrift_spec = (
10812 
    None, # 0
10813 
    (1, TType.I64, 'cartId', None, None, ), # 1
10814 
  )
10815 
 
10816 
  def __init__(self, cartId=None,):
10817 
    self.cartId = cartId
10818 
 
10819 
  def read(self, iprot):
10820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10822 
      return
10823 
    iprot.readStructBegin()
10824 
    while True:
10825 
      (fname, ftype, fid) = iprot.readFieldBegin()
10826 
      if ftype == TType.STOP:
10827 
        break
10828 
      if fid == 1:
10829 
        if ftype == TType.I64:
10830 
          self.cartId = iprot.readI64();
10831 
        else:
10832 
          iprot.skip(ftype)
10833 
      else:
10834 
        iprot.skip(ftype)
10835 
      iprot.readFieldEnd()
10836 
    iprot.readStructEnd()
10837 
 
10838 
  def write(self, oprot):
10839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10841 
      return
10842 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 10843 
    if self.cartId is not None:
1976 varun.gupt 10844 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10845 
      oprot.writeI64(self.cartId)
10846 
      oprot.writeFieldEnd()
10847 
    oprot.writeFieldStop()
10848 
    oprot.writeStructEnd()
10849 
 
3431 rajveer 10850 
  def validate(self):
10851 
    return
10852 
 
10853 
 
1976 varun.gupt 10854 
  def __repr__(self):
10855 
    L = ['%s=%r' % (key, value)
10856 
      for key, value in self.__dict__.iteritems()]
10857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10858 
 
10859 
  def __eq__(self, other):
10860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10861 
 
10862 
  def __ne__(self, other):
10863 
    return not (self == other)
10864 
 
10865 
class removeCoupon_result:
10866 
  """
10867 
  Attributes:
10868 
   - scx
10869 
  """
10870 
 
10871 
  thrift_spec = (
10872 
    None, # 0
10873 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10874 
  )
10875 
 
10876 
  def __init__(self, scx=None,):
10877 
    self.scx = scx
10878 
 
10879 
  def read(self, iprot):
10880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10882 
      return
10883 
    iprot.readStructBegin()
10884 
    while True:
10885 
      (fname, ftype, fid) = iprot.readFieldBegin()
10886 
      if ftype == TType.STOP:
10887 
        break
10888 
      if fid == 1:
10889 
        if ftype == TType.STRUCT:
10890 
          self.scx = ShoppingCartException()
10891 
          self.scx.read(iprot)
10892 
        else:
10893 
          iprot.skip(ftype)
10894 
      else:
10895 
        iprot.skip(ftype)
10896 
      iprot.readFieldEnd()
10897 
    iprot.readStructEnd()
10898 
 
10899 
  def write(self, oprot):
10900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10902 
      return
10903 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 10904 
    if self.scx is not None:
1976 varun.gupt 10905 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10906 
      self.scx.write(oprot)
10907 
      oprot.writeFieldEnd()
10908 
    oprot.writeFieldStop()
10909 
    oprot.writeStructEnd()
10910 
 
3431 rajveer 10911 
  def validate(self):
10912 
    return
10913 
 
10914 
 
1976 varun.gupt 10915 
  def __repr__(self):
10916 
    L = ['%s=%r' % (key, value)
10917 
      for key, value in self.__dict__.iteritems()]
10918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10919 
 
10920 
  def __eq__(self, other):
10921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10922 
 
10923 
  def __ne__(self, other):
10924 
    return not (self == other)
10925 
 
3554 varun.gupt 10926 
class deleteDiscountsFromCart_args:
10927 
  """
10928 
  Attributes:
10929 
   - cartId
10930 
  """
10931 
 
10932 
  thrift_spec = (
10933 
    None, # 0
10934 
    (1, TType.I64, 'cartId', None, None, ), # 1
10935 
  )
10936 
 
10937 
  def __init__(self, cartId=None,):
10938 
    self.cartId = cartId
10939 
 
10940 
  def read(self, iprot):
10941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10943 
      return
10944 
    iprot.readStructBegin()
10945 
    while True:
10946 
      (fname, ftype, fid) = iprot.readFieldBegin()
10947 
      if ftype == TType.STOP:
10948 
        break
10949 
      if fid == 1:
10950 
        if ftype == TType.I64:
10951 
          self.cartId = iprot.readI64();
10952 
        else:
10953 
          iprot.skip(ftype)
10954 
      else:
10955 
        iprot.skip(ftype)
10956 
      iprot.readFieldEnd()
10957 
    iprot.readStructEnd()
10958 
 
10959 
  def write(self, oprot):
10960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10962 
      return
10963 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
10964 
    if self.cartId is not None:
10965 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10966 
      oprot.writeI64(self.cartId)
10967 
      oprot.writeFieldEnd()
10968 
    oprot.writeFieldStop()
10969 
    oprot.writeStructEnd()
10970 
 
10971 
  def validate(self):
10972 
    return
10973 
 
10974 
 
10975 
  def __repr__(self):
10976 
    L = ['%s=%r' % (key, value)
10977 
      for key, value in self.__dict__.iteritems()]
10978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10979 
 
10980 
  def __eq__(self, other):
10981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10982 
 
10983 
  def __ne__(self, other):
10984 
    return not (self == other)
10985 
 
10986 
class deleteDiscountsFromCart_result:
10987 
  """
10988 
  Attributes:
10989 
   - scx
10990 
  """
10991 
 
10992 
  thrift_spec = (
10993 
    None, # 0
10994 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10995 
  )
10996 
 
10997 
  def __init__(self, scx=None,):
10998 
    self.scx = scx
10999 
 
11000 
  def read(self, iprot):
11001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11003 
      return
11004 
    iprot.readStructBegin()
11005 
    while True:
11006 
      (fname, ftype, fid) = iprot.readFieldBegin()
11007 
      if ftype == TType.STOP:
11008 
        break
11009 
      if fid == 1:
11010 
        if ftype == TType.STRUCT:
11011 
          self.scx = ShoppingCartException()
11012 
          self.scx.read(iprot)
11013 
        else:
11014 
          iprot.skip(ftype)
11015 
      else:
11016 
        iprot.skip(ftype)
11017 
      iprot.readFieldEnd()
11018 
    iprot.readStructEnd()
11019 
 
11020 
  def write(self, oprot):
11021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11023 
      return
11024 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11025 
    if self.scx is not None:
11026 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11027 
      self.scx.write(oprot)
11028 
      oprot.writeFieldEnd()
11029 
    oprot.writeFieldStop()
11030 
    oprot.writeStructEnd()
11031 
 
11032 
  def validate(self):
11033 
    return
11034 
 
11035 
 
11036 
  def __repr__(self):
11037 
    L = ['%s=%r' % (key, value)
11038 
      for key, value in self.__dict__.iteritems()]
11039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11040 
 
11041 
  def __eq__(self, other):
11042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11043 
 
11044 
  def __ne__(self, other):
11045 
    return not (self == other)
11046 
 
11047 
class saveDiscounts_args:
11048 
  """
11049 
  Attributes:
11050 
   - discounts
11051 
  """
11052 
 
11053 
  thrift_spec = (
11054 
    None, # 0
11055 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11056 
  )
11057 
 
11058 
  def __init__(self, discounts=None,):
11059 
    self.discounts = discounts
11060 
 
11061 
  def read(self, iprot):
11062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11064 
      return
11065 
    iprot.readStructBegin()
11066 
    while True:
11067 
      (fname, ftype, fid) = iprot.readFieldBegin()
11068 
      if ftype == TType.STOP:
11069 
        break
11070 
      if fid == 1:
11071 
        if ftype == TType.LIST:
11072 
          self.discounts = []
7746 amit.gupta 11073 
          (_etype156, _size153) = iprot.readListBegin()
11074 
          for _i157 in xrange(_size153):
11075 
            _elem158 = Discount()
11076 
            _elem158.read(iprot)
11077 
            self.discounts.append(_elem158)
3554 varun.gupt 11078 
          iprot.readListEnd()
11079 
        else:
11080 
          iprot.skip(ftype)
11081 
      else:
11082 
        iprot.skip(ftype)
11083 
      iprot.readFieldEnd()
11084 
    iprot.readStructEnd()
11085 
 
11086 
  def write(self, oprot):
11087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11089 
      return
11090 
    oprot.writeStructBegin('saveDiscounts_args')
11091 
    if self.discounts is not None:
11092 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11093 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
7746 amit.gupta 11094 
      for iter159 in self.discounts:
11095 
        iter159.write(oprot)
3554 varun.gupt 11096 
      oprot.writeListEnd()
11097 
      oprot.writeFieldEnd()
11098 
    oprot.writeFieldStop()
11099 
    oprot.writeStructEnd()
11100 
 
11101 
  def validate(self):
11102 
    return
11103 
 
11104 
 
11105 
  def __repr__(self):
11106 
    L = ['%s=%r' % (key, value)
11107 
      for key, value in self.__dict__.iteritems()]
11108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11109 
 
11110 
  def __eq__(self, other):
11111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11112 
 
11113 
  def __ne__(self, other):
11114 
    return not (self == other)
11115 
 
11116 
class saveDiscounts_result:
11117 
  """
11118 
  Attributes:
11119 
   - scx
11120 
  """
11121 
 
11122 
  thrift_spec = (
11123 
    None, # 0
11124 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11125 
  )
11126 
 
11127 
  def __init__(self, scx=None,):
11128 
    self.scx = scx
11129 
 
11130 
  def read(self, iprot):
11131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11133 
      return
11134 
    iprot.readStructBegin()
11135 
    while True:
11136 
      (fname, ftype, fid) = iprot.readFieldBegin()
11137 
      if ftype == TType.STOP:
11138 
        break
11139 
      if fid == 1:
11140 
        if ftype == TType.STRUCT:
11141 
          self.scx = ShoppingCartException()
11142 
          self.scx.read(iprot)
11143 
        else:
11144 
          iprot.skip(ftype)
11145 
      else:
11146 
        iprot.skip(ftype)
11147 
      iprot.readFieldEnd()
11148 
    iprot.readStructEnd()
11149 
 
11150 
  def write(self, oprot):
11151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11153 
      return
11154 
    oprot.writeStructBegin('saveDiscounts_result')
11155 
    if self.scx is not None:
11156 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11157 
      self.scx.write(oprot)
11158 
      oprot.writeFieldEnd()
11159 
    oprot.writeFieldStop()
11160 
    oprot.writeStructEnd()
11161 
 
11162 
  def validate(self):
11163 
    return
11164 
 
11165 
 
11166 
  def __repr__(self):
11167 
    L = ['%s=%r' % (key, value)
11168 
      for key, value in self.__dict__.iteritems()]
11169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11170 
 
11171 
  def __eq__(self, other):
11172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11173 
 
11174 
  def __ne__(self, other):
11175 
    return not (self == other)
11176 
 
690 chandransh 11177 
class createOrders_args:
559 chandransh 11178 
  """
11179 
  Attributes:
11180 
   - cartId
2815 vikas 11181 
   - sessionSource
11182 
   - sessionStartTime
3858 vikas 11183 
   - firstSource
11184 
   - firstSourceTime
5326 rajveer 11185 
   - userId
6389 rajveer 11186 
   - schemeId
559 chandransh 11187 
  """
11188 
 
11189 
  thrift_spec = (
11190 
    None, # 0
11191 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11192 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11193 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11194 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11195 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11196 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11197 
    (7, TType.I64, 'schemeId', None, None, ), # 7
559 chandransh 11198 
  )
11199 
 
6389 rajveer 11200 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None,):
559 chandransh 11201 
    self.cartId = cartId
2815 vikas 11202 
    self.sessionSource = sessionSource
11203 
    self.sessionStartTime = sessionStartTime
3858 vikas 11204 
    self.firstSource = firstSource
11205 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11206 
    self.userId = userId
6389 rajveer 11207 
    self.schemeId = schemeId
559 chandransh 11208 
 
11209 
  def read(self, iprot):
11210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11212 
      return
11213 
    iprot.readStructBegin()
11214 
    while True:
11215 
      (fname, ftype, fid) = iprot.readFieldBegin()
11216 
      if ftype == TType.STOP:
11217 
        break
11218 
      if fid == 1:
11219 
        if ftype == TType.I64:
11220 
          self.cartId = iprot.readI64();
11221 
        else:
11222 
          iprot.skip(ftype)
2815 vikas 11223 
      elif fid == 2:
11224 
        if ftype == TType.STRING:
11225 
          self.sessionSource = iprot.readString();
11226 
        else:
11227 
          iprot.skip(ftype)
11228 
      elif fid == 3:
11229 
        if ftype == TType.I64:
11230 
          self.sessionStartTime = iprot.readI64();
11231 
        else:
11232 
          iprot.skip(ftype)
3858 vikas 11233 
      elif fid == 4:
11234 
        if ftype == TType.STRING:
11235 
          self.firstSource = iprot.readString();
11236 
        else:
11237 
          iprot.skip(ftype)
11238 
      elif fid == 5:
11239 
        if ftype == TType.I64:
11240 
          self.firstSourceTime = iprot.readI64();
11241 
        else:
11242 
          iprot.skip(ftype)
5326 rajveer 11243 
      elif fid == 6:
11244 
        if ftype == TType.I64:
11245 
          self.userId = iprot.readI64();
11246 
        else:
11247 
          iprot.skip(ftype)
6389 rajveer 11248 
      elif fid == 7:
11249 
        if ftype == TType.I64:
11250 
          self.schemeId = iprot.readI64();
11251 
        else:
11252 
          iprot.skip(ftype)
559 chandransh 11253 
      else:
11254 
        iprot.skip(ftype)
11255 
      iprot.readFieldEnd()
11256 
    iprot.readStructEnd()
11257 
 
11258 
  def write(self, oprot):
11259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11261 
      return
690 chandransh 11262 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11263 
    if self.cartId is not None:
559 chandransh 11264 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11265 
      oprot.writeI64(self.cartId)
11266 
      oprot.writeFieldEnd()
3431 rajveer 11267 
    if self.sessionSource is not None:
2815 vikas 11268 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11269 
      oprot.writeString(self.sessionSource)
11270 
      oprot.writeFieldEnd()
3431 rajveer 11271 
    if self.sessionStartTime is not None:
2815 vikas 11272 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11273 
      oprot.writeI64(self.sessionStartTime)
11274 
      oprot.writeFieldEnd()
3858 vikas 11275 
    if self.firstSource is not None:
11276 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11277 
      oprot.writeString(self.firstSource)
11278 
      oprot.writeFieldEnd()
11279 
    if self.firstSourceTime is not None:
11280 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11281 
      oprot.writeI64(self.firstSourceTime)
11282 
      oprot.writeFieldEnd()
5326 rajveer 11283 
    if self.userId is not None:
11284 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11285 
      oprot.writeI64(self.userId)
11286 
      oprot.writeFieldEnd()
6389 rajveer 11287 
    if self.schemeId is not None:
11288 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11289 
      oprot.writeI64(self.schemeId)
11290 
      oprot.writeFieldEnd()
559 chandransh 11291 
    oprot.writeFieldStop()
11292 
    oprot.writeStructEnd()
11293 
 
3431 rajveer 11294 
  def validate(self):
11295 
    return
11296 
 
11297 
 
559 chandransh 11298 
  def __repr__(self):
11299 
    L = ['%s=%r' % (key, value)
11300 
      for key, value in self.__dict__.iteritems()]
11301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11302 
 
11303 
  def __eq__(self, other):
11304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11305 
 
11306 
  def __ne__(self, other):
11307 
    return not (self == other)
11308 
 
690 chandransh 11309 
class createOrders_result:
559 chandransh 11310 
  """
11311 
  Attributes:
94 ashish 11312 
   - success
559 chandransh 11313 
   - scx
94 ashish 11314 
  """
11315 
 
11316 
  thrift_spec = (
575 chandransh 11317 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11318 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11319 
  )
11320 
 
559 chandransh 11321 
  def __init__(self, success=None, scx=None,):
94 ashish 11322 
    self.success = success
559 chandransh 11323 
    self.scx = scx
94 ashish 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 == 0:
575 chandransh 11335 
        if ftype == TType.I64:
11336 
          self.success = iprot.readI64();
94 ashish 11337 
        else:
11338 
          iprot.skip(ftype)
11339 
      elif fid == 1:
11340 
        if ftype == TType.STRUCT:
559 chandransh 11341 
          self.scx = ShoppingCartException()
11342 
          self.scx.read(iprot)
94 ashish 11343 
        else:
11344 
          iprot.skip(ftype)
11345 
      else:
11346 
        iprot.skip(ftype)
11347 
      iprot.readFieldEnd()
11348 
    iprot.readStructEnd()
11349 
 
11350 
  def write(self, oprot):
11351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11353 
      return
690 chandransh 11354 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11355 
    if self.success is not None:
575 chandransh 11356 
      oprot.writeFieldBegin('success', TType.I64, 0)
11357 
      oprot.writeI64(self.success)
94 ashish 11358 
      oprot.writeFieldEnd()
3431 rajveer 11359 
    if self.scx is not None:
559 chandransh 11360 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11361 
      self.scx.write(oprot)
94 ashish 11362 
      oprot.writeFieldEnd()
11363 
    oprot.writeFieldStop()
11364 
    oprot.writeStructEnd()
11365 
 
3431 rajveer 11366 
  def validate(self):
11367 
    return
11368 
 
11369 
 
94 ashish 11370 
  def __repr__(self):
11371 
    L = ['%s=%r' % (key, value)
11372 
      for key, value in self.__dict__.iteritems()]
11373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11374 
 
11375 
  def __eq__(self, other):
11376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11377 
 
11378 
  def __ne__(self, other):
11379 
    return not (self == other)
11380 
 
559 chandransh 11381 
class validateCart_args:
94 ashish 11382 
  """
11383 
  Attributes:
559 chandransh 11384 
   - cartId
3557 rajveer 11385 
   - sourceId
94 ashish 11386 
  """
11387 
 
11388 
  thrift_spec = (
11389 
    None, # 0
559 chandransh 11390 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11391 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11392 
  )
11393 
 
3557 rajveer 11394 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11395 
    self.cartId = cartId
3557 rajveer 11396 
    self.sourceId = sourceId
94 ashish 11397 
 
11398 
  def read(self, iprot):
11399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11401 
      return
11402 
    iprot.readStructBegin()
11403 
    while True:
11404 
      (fname, ftype, fid) = iprot.readFieldBegin()
11405 
      if ftype == TType.STOP:
11406 
        break
11407 
      if fid == 1:
11408 
        if ftype == TType.I64:
559 chandransh 11409 
          self.cartId = iprot.readI64();
94 ashish 11410 
        else:
11411 
          iprot.skip(ftype)
3557 rajveer 11412 
      elif fid == 2:
11413 
        if ftype == TType.I64:
11414 
          self.sourceId = iprot.readI64();
11415 
        else:
11416 
          iprot.skip(ftype)
94 ashish 11417 
      else:
11418 
        iprot.skip(ftype)
11419 
      iprot.readFieldEnd()
11420 
    iprot.readStructEnd()
11421 
 
11422 
  def write(self, oprot):
11423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11425 
      return
559 chandransh 11426 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 11427 
    if self.cartId is not None:
559 chandransh 11428 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11429 
      oprot.writeI64(self.cartId)
94 ashish 11430 
      oprot.writeFieldEnd()
3557 rajveer 11431 
    if self.sourceId is not None:
11432 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11433 
      oprot.writeI64(self.sourceId)
11434 
      oprot.writeFieldEnd()
94 ashish 11435 
    oprot.writeFieldStop()
11436 
    oprot.writeStructEnd()
11437 
 
3431 rajveer 11438 
  def validate(self):
11439 
    return
11440 
 
11441 
 
94 ashish 11442 
  def __repr__(self):
11443 
    L = ['%s=%r' % (key, value)
11444 
      for key, value in self.__dict__.iteritems()]
11445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11446 
 
11447 
  def __eq__(self, other):
11448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11449 
 
11450 
  def __ne__(self, other):
11451 
    return not (self == other)
11452 
 
559 chandransh 11453 
class validateCart_result:
94 ashish 11454 
  """
11455 
  Attributes:
11456 
   - success
575 chandransh 11457 
   - scex
94 ashish 11458 
  """
11459 
 
11460 
  thrift_spec = (
6736 amit.gupta 11461 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 11462 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11463 
  )
11464 
 
575 chandransh 11465 
  def __init__(self, success=None, scex=None,):
94 ashish 11466 
    self.success = success
575 chandransh 11467 
    self.scex = scex
94 ashish 11468 
 
11469 
  def read(self, iprot):
11470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11472 
      return
11473 
    iprot.readStructBegin()
11474 
    while True:
11475 
      (fname, ftype, fid) = iprot.readFieldBegin()
11476 
      if ftype == TType.STOP:
11477 
        break
11478 
      if fid == 0:
6736 amit.gupta 11479 
        if ftype == TType.LIST:
11480 
          self.success = []
7746 amit.gupta 11481 
          (_etype163, _size160) = iprot.readListBegin()
11482 
          for _i164 in xrange(_size160):
11483 
            _elem165 = iprot.readString();
11484 
            self.success.append(_elem165)
6736 amit.gupta 11485 
          iprot.readListEnd()
94 ashish 11486 
        else:
11487 
          iprot.skip(ftype)
575 chandransh 11488 
      elif fid == 1:
11489 
        if ftype == TType.STRUCT:
11490 
          self.scex = ShoppingCartException()
11491 
          self.scex.read(iprot)
11492 
        else:
11493 
          iprot.skip(ftype)
94 ashish 11494 
      else:
11495 
        iprot.skip(ftype)
11496 
      iprot.readFieldEnd()
11497 
    iprot.readStructEnd()
11498 
 
11499 
  def write(self, oprot):
11500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11502 
      return
559 chandransh 11503 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 11504 
    if self.success is not None:
6736 amit.gupta 11505 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11506 
      oprot.writeListBegin(TType.STRING, len(self.success))
7746 amit.gupta 11507 
      for iter166 in self.success:
11508 
        oprot.writeString(iter166)
6736 amit.gupta 11509 
      oprot.writeListEnd()
94 ashish 11510 
      oprot.writeFieldEnd()
3431 rajveer 11511 
    if self.scex is not None:
575 chandransh 11512 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11513 
      self.scex.write(oprot)
11514 
      oprot.writeFieldEnd()
559 chandransh 11515 
    oprot.writeFieldStop()
11516 
    oprot.writeStructEnd()
11517 
 
3431 rajveer 11518 
  def validate(self):
11519 
    return
11520 
 
11521 
 
559 chandransh 11522 
  def __repr__(self):
11523 
    L = ['%s=%r' % (key, value)
11524 
      for key, value in self.__dict__.iteritems()]
11525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11526 
 
11527 
  def __eq__(self, other):
11528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11529 
 
11530 
  def __ne__(self, other):
11531 
    return not (self == other)
11532 
 
690 chandransh 11533 
class mergeCart_args:
575 chandransh 11534 
  """
11535 
  Attributes:
690 chandransh 11536 
   - fromCartId
11537 
   - toCartId
11538 
  """
11539 
 
11540 
  thrift_spec = (
11541 
    None, # 0
11542 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11543 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11544 
  )
11545 
 
11546 
  def __init__(self, fromCartId=None, toCartId=None,):
11547 
    self.fromCartId = fromCartId
11548 
    self.toCartId = toCartId
11549 
 
11550 
  def read(self, iprot):
11551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11553 
      return
11554 
    iprot.readStructBegin()
11555 
    while True:
11556 
      (fname, ftype, fid) = iprot.readFieldBegin()
11557 
      if ftype == TType.STOP:
11558 
        break
11559 
      if fid == 1:
11560 
        if ftype == TType.I64:
11561 
          self.fromCartId = iprot.readI64();
11562 
        else:
11563 
          iprot.skip(ftype)
11564 
      elif fid == 2:
11565 
        if ftype == TType.I64:
11566 
          self.toCartId = iprot.readI64();
11567 
        else:
11568 
          iprot.skip(ftype)
11569 
      else:
11570 
        iprot.skip(ftype)
11571 
      iprot.readFieldEnd()
11572 
    iprot.readStructEnd()
11573 
 
11574 
  def write(self, oprot):
11575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11577 
      return
11578 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 11579 
    if self.fromCartId is not None:
690 chandransh 11580 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11581 
      oprot.writeI64(self.fromCartId)
11582 
      oprot.writeFieldEnd()
3431 rajveer 11583 
    if self.toCartId is not None:
690 chandransh 11584 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11585 
      oprot.writeI64(self.toCartId)
11586 
      oprot.writeFieldEnd()
11587 
    oprot.writeFieldStop()
11588 
    oprot.writeStructEnd()
11589 
 
3431 rajveer 11590 
  def validate(self):
11591 
    return
11592 
 
11593 
 
690 chandransh 11594 
  def __repr__(self):
11595 
    L = ['%s=%r' % (key, value)
11596 
      for key, value in self.__dict__.iteritems()]
11597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11598 
 
11599 
  def __eq__(self, other):
11600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11601 
 
11602 
  def __ne__(self, other):
11603 
    return not (self == other)
11604 
 
11605 
class mergeCart_result:
11606 
 
11607 
  thrift_spec = (
11608 
  )
11609 
 
11610 
  def read(self, iprot):
11611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11613 
      return
11614 
    iprot.readStructBegin()
11615 
    while True:
11616 
      (fname, ftype, fid) = iprot.readFieldBegin()
11617 
      if ftype == TType.STOP:
11618 
        break
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
11628 
    oprot.writeStructBegin('mergeCart_result')
11629 
    oprot.writeFieldStop()
11630 
    oprot.writeStructEnd()
11631 
 
3431 rajveer 11632 
  def validate(self):
11633 
    return
11634 
 
11635 
 
690 chandransh 11636 
  def __repr__(self):
11637 
    L = ['%s=%r' % (key, value)
11638 
      for key, value in self.__dict__.iteritems()]
11639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11640 
 
11641 
  def __eq__(self, other):
11642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11643 
 
11644 
  def __ne__(self, other):
11645 
    return not (self == other)
11646 
 
11647 
class checkOut_args:
11648 
  """
11649 
  Attributes:
575 chandransh 11650 
   - cartId
11651 
  """
11652 
 
11653 
  thrift_spec = (
11654 
    None, # 0
11655 
    (1, TType.I64, 'cartId', None, None, ), # 1
11656 
  )
11657 
 
11658 
  def __init__(self, cartId=None,):
11659 
    self.cartId = cartId
11660 
 
11661 
  def read(self, iprot):
11662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11664 
      return
11665 
    iprot.readStructBegin()
11666 
    while True:
11667 
      (fname, ftype, fid) = iprot.readFieldBegin()
11668 
      if ftype == TType.STOP:
11669 
        break
11670 
      if fid == 1:
11671 
        if ftype == TType.I64:
11672 
          self.cartId = iprot.readI64();
11673 
        else:
11674 
          iprot.skip(ftype)
11675 
      else:
11676 
        iprot.skip(ftype)
11677 
      iprot.readFieldEnd()
11678 
    iprot.readStructEnd()
11679 
 
11680 
  def write(self, oprot):
11681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11683 
      return
690 chandransh 11684 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 11685 
    if self.cartId is not None:
575 chandransh 11686 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11687 
      oprot.writeI64(self.cartId)
11688 
      oprot.writeFieldEnd()
11689 
    oprot.writeFieldStop()
11690 
    oprot.writeStructEnd()
11691 
 
3431 rajveer 11692 
  def validate(self):
11693 
    return
11694 
 
11695 
 
575 chandransh 11696 
  def __repr__(self):
11697 
    L = ['%s=%r' % (key, value)
11698 
      for key, value in self.__dict__.iteritems()]
11699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11700 
 
11701 
  def __eq__(self, other):
11702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11703 
 
11704 
  def __ne__(self, other):
11705 
    return not (self == other)
11706 
 
690 chandransh 11707 
class checkOut_result:
575 chandransh 11708 
  """
11709 
  Attributes:
11710 
   - success
11711 
   - scex
11712 
  """
11713 
 
11714 
  thrift_spec = (
11715 
    (0, TType.BOOL, 'success', None, None, ), # 0
11716 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11717 
  )
11718 
 
11719 
  def __init__(self, success=None, scex=None,):
11720 
    self.success = success
11721 
    self.scex = scex
11722 
 
11723 
  def read(self, iprot):
11724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11726 
      return
11727 
    iprot.readStructBegin()
11728 
    while True:
11729 
      (fname, ftype, fid) = iprot.readFieldBegin()
11730 
      if ftype == TType.STOP:
11731 
        break
11732 
      if fid == 0:
11733 
        if ftype == TType.BOOL:
11734 
          self.success = iprot.readBool();
11735 
        else:
11736 
          iprot.skip(ftype)
11737 
      elif fid == 1:
11738 
        if ftype == TType.STRUCT:
11739 
          self.scex = ShoppingCartException()
11740 
          self.scex.read(iprot)
11741 
        else:
11742 
          iprot.skip(ftype)
11743 
      else:
11744 
        iprot.skip(ftype)
11745 
      iprot.readFieldEnd()
11746 
    iprot.readStructEnd()
11747 
 
11748 
  def write(self, oprot):
11749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11751 
      return
690 chandransh 11752 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 11753 
    if self.success is not None:
575 chandransh 11754 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11755 
      oprot.writeBool(self.success)
11756 
      oprot.writeFieldEnd()
3431 rajveer 11757 
    if self.scex is not None:
575 chandransh 11758 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11759 
      self.scex.write(oprot)
11760 
      oprot.writeFieldEnd()
11761 
    oprot.writeFieldStop()
11762 
    oprot.writeStructEnd()
11763 
 
3431 rajveer 11764 
  def validate(self):
11765 
    return
11766 
 
11767 
 
575 chandransh 11768 
  def __repr__(self):
11769 
    L = ['%s=%r' % (key, value)
11770 
      for key, value in self.__dict__.iteritems()]
11771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11772 
 
11773 
  def __eq__(self, other):
11774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11775 
 
11776 
  def __ne__(self, other):
11777 
    return not (self == other)
11778 
 
690 chandransh 11779 
class resetCart_args:
559 chandransh 11780 
  """
11781 
  Attributes:
690 chandransh 11782 
   - cartId
11783 
   - items
559 chandransh 11784 
  """
11785 
 
11786 
  thrift_spec = (
11787 
    None, # 0
690 chandransh 11788 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11789 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11790 
  )
11791 
 
690 chandransh 11792 
  def __init__(self, cartId=None, items=None,):
11793 
    self.cartId = cartId
11794 
    self.items = items
559 chandransh 11795 
 
11796 
  def read(self, iprot):
11797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11799 
      return
11800 
    iprot.readStructBegin()
11801 
    while True:
11802 
      (fname, ftype, fid) = iprot.readFieldBegin()
11803 
      if ftype == TType.STOP:
11804 
        break
11805 
      if fid == 1:
11806 
        if ftype == TType.I64:
690 chandransh 11807 
          self.cartId = iprot.readI64();
559 chandransh 11808 
        else:
11809 
          iprot.skip(ftype)
11810 
      elif fid == 2:
690 chandransh 11811 
        if ftype == TType.MAP:
11812 
          self.items = {}
7746 amit.gupta 11813 
          (_ktype168, _vtype169, _size167 ) = iprot.readMapBegin()
11814 
          for _i171 in xrange(_size167):
11815 
            _key172 = iprot.readI64();
11816 
            _val173 = iprot.readDouble();
11817 
            self.items[_key172] = _val173
690 chandransh 11818 
          iprot.readMapEnd()
559 chandransh 11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      else:
11822 
        iprot.skip(ftype)
11823 
      iprot.readFieldEnd()
11824 
    iprot.readStructEnd()
11825 
 
11826 
  def write(self, oprot):
11827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11829 
      return
690 chandransh 11830 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 11831 
    if self.cartId is not None:
690 chandransh 11832 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11833 
      oprot.writeI64(self.cartId)
94 ashish 11834 
      oprot.writeFieldEnd()
3431 rajveer 11835 
    if self.items is not None:
690 chandransh 11836 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11837 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
7746 amit.gupta 11838 
      for kiter174,viter175 in self.items.items():
11839 
        oprot.writeI64(kiter174)
11840 
        oprot.writeDouble(viter175)
690 chandransh 11841 
      oprot.writeMapEnd()
559 chandransh 11842 
      oprot.writeFieldEnd()
94 ashish 11843 
    oprot.writeFieldStop()
11844 
    oprot.writeStructEnd()
11845 
 
3431 rajveer 11846 
  def validate(self):
11847 
    return
11848 
 
11849 
 
94 ashish 11850 
  def __repr__(self):
11851 
    L = ['%s=%r' % (key, value)
11852 
      for key, value in self.__dict__.iteritems()]
11853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11854 
 
11855 
  def __eq__(self, other):
11856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11857 
 
11858 
  def __ne__(self, other):
11859 
    return not (self == other)
11860 
 
690 chandransh 11861 
class resetCart_result:
11862 
  """
11863 
  Attributes:
11864 
   - success
11865 
   - scex
11866 
  """
559 chandransh 11867 
 
11868 
  thrift_spec = (
690 chandransh 11869 
    (0, TType.BOOL, 'success', None, None, ), # 0
11870 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11871 
  )
11872 
 
690 chandransh 11873 
  def __init__(self, success=None, scex=None,):
11874 
    self.success = success
11875 
    self.scex = scex
11876 
 
559 chandransh 11877 
  def read(self, iprot):
11878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11880 
      return
11881 
    iprot.readStructBegin()
11882 
    while True:
11883 
      (fname, ftype, fid) = iprot.readFieldBegin()
11884 
      if ftype == TType.STOP:
11885 
        break
690 chandransh 11886 
      if fid == 0:
11887 
        if ftype == TType.BOOL:
11888 
          self.success = iprot.readBool();
11889 
        else:
11890 
          iprot.skip(ftype)
11891 
      elif fid == 1:
11892 
        if ftype == TType.STRUCT:
11893 
          self.scex = ShoppingCartException()
11894 
          self.scex.read(iprot)
11895 
        else:
11896 
          iprot.skip(ftype)
559 chandransh 11897 
      else:
11898 
        iprot.skip(ftype)
11899 
      iprot.readFieldEnd()
11900 
    iprot.readStructEnd()
11901 
 
11902 
  def write(self, oprot):
11903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11905 
      return
690 chandransh 11906 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 11907 
    if self.success is not None:
690 chandransh 11908 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11909 
      oprot.writeBool(self.success)
11910 
      oprot.writeFieldEnd()
3431 rajveer 11911 
    if self.scex is not None:
690 chandransh 11912 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11913 
      self.scex.write(oprot)
11914 
      oprot.writeFieldEnd()
559 chandransh 11915 
    oprot.writeFieldStop()
11916 
    oprot.writeStructEnd()
11917 
 
3431 rajveer 11918 
  def validate(self):
11919 
    return
11920 
 
11921 
 
559 chandransh 11922 
  def __repr__(self):
11923 
    L = ['%s=%r' % (key, value)
11924 
      for key, value in self.__dict__.iteritems()]
11925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11926 
 
11927 
  def __eq__(self, other):
11928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11929 
 
11930 
  def __ne__(self, other):
11931 
    return not (self == other)
11932 
 
2981 rajveer 11933 
class getUserCount_args:
94 ashish 11934 
  """
11935 
  Attributes:
2981 rajveer 11936 
   - userType
559 chandransh 11937 
  """
11938 
 
11939 
  thrift_spec = (
11940 
    None, # 0
2981 rajveer 11941 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 11942 
  )
11943 
 
2981 rajveer 11944 
  def __init__(self, userType=None,):
11945 
    self.userType = userType
559 chandransh 11946 
 
11947 
  def read(self, iprot):
11948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11950 
      return
11951 
    iprot.readStructBegin()
11952 
    while True:
11953 
      (fname, ftype, fid) = iprot.readFieldBegin()
11954 
      if ftype == TType.STOP:
11955 
        break
11956 
      if fid == 1:
2981 rajveer 11957 
        if ftype == TType.I32:
11958 
          self.userType = iprot.readI32();
559 chandransh 11959 
        else:
11960 
          iprot.skip(ftype)
11961 
      else:
11962 
        iprot.skip(ftype)
11963 
      iprot.readFieldEnd()
11964 
    iprot.readStructEnd()
11965 
 
11966 
  def write(self, oprot):
11967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11969 
      return
2981 rajveer 11970 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 11971 
    if self.userType is not None:
2981 rajveer 11972 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11973 
      oprot.writeI32(self.userType)
559 chandransh 11974 
      oprot.writeFieldEnd()
11975 
    oprot.writeFieldStop()
11976 
    oprot.writeStructEnd()
11977 
 
3431 rajveer 11978 
  def validate(self):
11979 
    return
11980 
 
11981 
 
559 chandransh 11982 
  def __repr__(self):
11983 
    L = ['%s=%r' % (key, value)
11984 
      for key, value in self.__dict__.iteritems()]
11985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11986 
 
11987 
  def __eq__(self, other):
11988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11989 
 
11990 
  def __ne__(self, other):
11991 
    return not (self == other)
11992 
 
2981 rajveer 11993 
class getUserCount_result:
94 ashish 11994 
  """
11995 
  Attributes:
11996 
   - success
11997 
  """
11998 
 
11999 
  thrift_spec = (
2981 rajveer 12000 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12001 
  )
12002 
 
2981 rajveer 12003 
  def __init__(self, success=None,):
94 ashish 12004 
    self.success = success
12005 
 
12006 
  def read(self, iprot):
12007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12009 
      return
12010 
    iprot.readStructBegin()
12011 
    while True:
12012 
      (fname, ftype, fid) = iprot.readFieldBegin()
12013 
      if ftype == TType.STOP:
12014 
        break
12015 
      if fid == 0:
2981 rajveer 12016 
        if ftype == TType.I64:
12017 
          self.success = iprot.readI64();
94 ashish 12018 
        else:
12019 
          iprot.skip(ftype)
12020 
      else:
12021 
        iprot.skip(ftype)
12022 
      iprot.readFieldEnd()
12023 
    iprot.readStructEnd()
12024 
 
12025 
  def write(self, oprot):
12026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12028 
      return
2981 rajveer 12029 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12030 
    if self.success is not None:
2981 rajveer 12031 
      oprot.writeFieldBegin('success', TType.I64, 0)
12032 
      oprot.writeI64(self.success)
94 ashish 12033 
      oprot.writeFieldEnd()
12034 
    oprot.writeFieldStop()
12035 
    oprot.writeStructEnd()
12036 
 
3431 rajveer 12037 
  def validate(self):
12038 
    return
12039 
 
12040 
 
94 ashish 12041 
  def __repr__(self):
12042 
    L = ['%s=%r' % (key, value)
12043 
      for key, value in self.__dict__.iteritems()]
12044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12045 
 
12046 
  def __eq__(self, other):
12047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12048 
 
12049 
  def __ne__(self, other):
12050 
    return not (self == other)
12051 
 
2981 rajveer 12052 
class getAllUsers_args:
94 ashish 12053 
  """
12054 
  Attributes:
2981 rajveer 12055 
   - userType
12056 
   - startDate
12057 
   - endDate
94 ashish 12058 
  """
12059 
 
12060 
  thrift_spec = (
12061 
    None, # 0
2981 rajveer 12062 
    (1, TType.I32, 'userType', None, None, ), # 1
12063 
    (2, TType.I64, 'startDate', None, None, ), # 2
12064 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12065 
  )
12066 
 
2981 rajveer 12067 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12068 
    self.userType = userType
12069 
    self.startDate = startDate
12070 
    self.endDate = endDate
94 ashish 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();
94 ashish 12084 
        else:
12085 
          iprot.skip(ftype)
12086 
      elif fid == 2:
559 chandransh 12087 
        if ftype == TType.I64:
2981 rajveer 12088 
          self.startDate = iprot.readI64();
94 ashish 12089 
        else:
12090 
          iprot.skip(ftype)
2981 rajveer 12091 
      elif fid == 3:
12092 
        if ftype == TType.I64:
12093 
          self.endDate = iprot.readI64();
12094 
        else:
12095 
          iprot.skip(ftype)
94 ashish 12096 
      else:
12097 
        iprot.skip(ftype)
12098 
      iprot.readFieldEnd()
12099 
    iprot.readStructEnd()
12100 
 
12101 
  def write(self, oprot):
12102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12104 
      return
2981 rajveer 12105 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12106 
    if self.userType is not None:
2981 rajveer 12107 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12108 
      oprot.writeI32(self.userType)
94 ashish 12109 
      oprot.writeFieldEnd()
3431 rajveer 12110 
    if self.startDate is not None:
2981 rajveer 12111 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12112 
      oprot.writeI64(self.startDate)
94 ashish 12113 
      oprot.writeFieldEnd()
3431 rajveer 12114 
    if self.endDate is not None:
2981 rajveer 12115 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12116 
      oprot.writeI64(self.endDate)
12117 
      oprot.writeFieldEnd()
94 ashish 12118 
    oprot.writeFieldStop()
12119 
    oprot.writeStructEnd()
12120 
 
3431 rajveer 12121 
  def validate(self):
12122 
    return
12123 
 
12124 
 
94 ashish 12125 
  def __repr__(self):
12126 
    L = ['%s=%r' % (key, value)
12127 
      for key, value in self.__dict__.iteritems()]
12128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12129 
 
12130 
  def __eq__(self, other):
12131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12132 
 
12133 
  def __ne__(self, other):
12134 
    return not (self == other)
12135 
 
2981 rajveer 12136 
class getAllUsers_result:
94 ashish 12137 
  """
12138 
  Attributes:
12139 
   - success
12140 
  """
12141 
 
12142 
  thrift_spec = (
2981 rajveer 12143 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12144 
  )
12145 
 
2981 rajveer 12146 
  def __init__(self, success=None,):
94 ashish 12147 
    self.success = success
12148 
 
12149 
  def read(self, iprot):
12150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12152 
      return
12153 
    iprot.readStructBegin()
12154 
    while True:
12155 
      (fname, ftype, fid) = iprot.readFieldBegin()
12156 
      if ftype == TType.STOP:
12157 
        break
12158 
      if fid == 0:
2981 rajveer 12159 
        if ftype == TType.LIST:
12160 
          self.success = []
7746 amit.gupta 12161 
          (_etype179, _size176) = iprot.readListBegin()
12162 
          for _i180 in xrange(_size176):
12163 
            _elem181 = User()
12164 
            _elem181.read(iprot)
12165 
            self.success.append(_elem181)
2981 rajveer 12166 
          iprot.readListEnd()
94 ashish 12167 
        else:
12168 
          iprot.skip(ftype)
12169 
      else:
12170 
        iprot.skip(ftype)
12171 
      iprot.readFieldEnd()
12172 
    iprot.readStructEnd()
12173 
 
12174 
  def write(self, oprot):
12175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12177 
      return
2981 rajveer 12178 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12179 
    if self.success is not None:
2981 rajveer 12180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7746 amit.gupta 12182 
      for iter182 in self.success:
12183 
        iter182.write(oprot)
2981 rajveer 12184 
      oprot.writeListEnd()
94 ashish 12185 
      oprot.writeFieldEnd()
12186 
    oprot.writeFieldStop()
12187 
    oprot.writeStructEnd()
12188 
 
3431 rajveer 12189 
  def validate(self):
12190 
    return
12191 
 
12192 
 
94 ashish 12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
12203 
 
2981 rajveer 12204 
class getMyResearchItems_args:
559 chandransh 12205 
  """
12206 
  Attributes:
772 rajveer 12207 
   - userId
559 chandransh 12208 
  """
12209 
 
12210 
  thrift_spec = (
12211 
    None, # 0
772 rajveer 12212 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12213 
  )
12214 
 
772 rajveer 12215 
  def __init__(self, userId=None,):
12216 
    self.userId = userId
559 chandransh 12217 
 
12218 
  def read(self, iprot):
12219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12221 
      return
12222 
    iprot.readStructBegin()
12223 
    while True:
12224 
      (fname, ftype, fid) = iprot.readFieldBegin()
12225 
      if ftype == TType.STOP:
12226 
        break
12227 
      if fid == 1:
12228 
        if ftype == TType.I64:
772 rajveer 12229 
          self.userId = iprot.readI64();
559 chandransh 12230 
        else:
12231 
          iprot.skip(ftype)
12232 
      else:
12233 
        iprot.skip(ftype)
12234 
      iprot.readFieldEnd()
12235 
    iprot.readStructEnd()
12236 
 
12237 
  def write(self, oprot):
12238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12240 
      return
2981 rajveer 12241 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 12242 
    if self.userId is not None:
772 rajveer 12243 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12244 
      oprot.writeI64(self.userId)
559 chandransh 12245 
      oprot.writeFieldEnd()
12246 
    oprot.writeFieldStop()
12247 
    oprot.writeStructEnd()
12248 
 
3431 rajveer 12249 
  def validate(self):
12250 
    return
12251 
 
12252 
 
559 chandransh 12253 
  def __repr__(self):
12254 
    L = ['%s=%r' % (key, value)
12255 
      for key, value in self.__dict__.iteritems()]
12256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12257 
 
12258 
  def __eq__(self, other):
12259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12260 
 
12261 
  def __ne__(self, other):
12262 
    return not (self == other)
12263 
 
2981 rajveer 12264 
class getMyResearchItems_result:
559 chandransh 12265 
  """
12266 
  Attributes:
130 ashish 12267 
   - success
559 chandransh 12268 
   - scx
130 ashish 12269 
  """
12270 
 
12271 
  thrift_spec = (
2981 rajveer 12272 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12273 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12274 
  )
12275 
 
559 chandransh 12276 
  def __init__(self, success=None, scx=None,):
130 ashish 12277 
    self.success = success
559 chandransh 12278 
    self.scx = scx
130 ashish 12279 
 
12280 
  def read(self, iprot):
12281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12283 
      return
12284 
    iprot.readStructBegin()
12285 
    while True:
12286 
      (fname, ftype, fid) = iprot.readFieldBegin()
12287 
      if ftype == TType.STOP:
12288 
        break
12289 
      if fid == 0:
2981 rajveer 12290 
        if ftype == TType.LIST:
12291 
          self.success = []
7746 amit.gupta 12292 
          (_etype186, _size183) = iprot.readListBegin()
12293 
          for _i187 in xrange(_size183):
12294 
            _elem188 = iprot.readI64();
12295 
            self.success.append(_elem188)
2981 rajveer 12296 
          iprot.readListEnd()
130 ashish 12297 
        else:
12298 
          iprot.skip(ftype)
12299 
      elif fid == 1:
12300 
        if ftype == TType.STRUCT:
559 chandransh 12301 
          self.scx = WidgetException()
12302 
          self.scx.read(iprot)
130 ashish 12303 
        else:
12304 
          iprot.skip(ftype)
12305 
      else:
12306 
        iprot.skip(ftype)
12307 
      iprot.readFieldEnd()
12308 
    iprot.readStructEnd()
12309 
 
12310 
  def write(self, oprot):
12311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12313 
      return
2981 rajveer 12314 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 12315 
    if self.success is not None:
2981 rajveer 12316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12317 
      oprot.writeListBegin(TType.I64, len(self.success))
7746 amit.gupta 12318 
      for iter189 in self.success:
12319 
        oprot.writeI64(iter189)
2981 rajveer 12320 
      oprot.writeListEnd()
130 ashish 12321 
      oprot.writeFieldEnd()
3431 rajveer 12322 
    if self.scx is not None:
559 chandransh 12323 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12324 
      self.scx.write(oprot)
130 ashish 12325 
      oprot.writeFieldEnd()
12326 
    oprot.writeFieldStop()
12327 
    oprot.writeStructEnd()
12328 
 
3431 rajveer 12329 
  def validate(self):
12330 
    return
12331 
 
12332 
 
130 ashish 12333 
  def __repr__(self):
12334 
    L = ['%s=%r' % (key, value)
12335 
      for key, value in self.__dict__.iteritems()]
12336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12337 
 
12338 
  def __eq__(self, other):
12339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12340 
 
12341 
  def __ne__(self, other):
12342 
    return not (self == other)
12343 
 
2981 rajveer 12344 
class updateMyResearch_args:
130 ashish 12345 
  """
12346 
  Attributes:
2981 rajveer 12347 
   - userId
12348 
   - itemId
130 ashish 12349 
  """
12350 
 
12351 
  thrift_spec = (
12352 
    None, # 0
2981 rajveer 12353 
    (1, TType.I64, 'userId', None, None, ), # 1
12354 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12355 
  )
12356 
 
2981 rajveer 12357 
  def __init__(self, userId=None, itemId=None,):
12358 
    self.userId = userId
12359 
    self.itemId = itemId
130 ashish 12360 
 
12361 
  def read(self, iprot):
12362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12364 
      return
12365 
    iprot.readStructBegin()
12366 
    while True:
12367 
      (fname, ftype, fid) = iprot.readFieldBegin()
12368 
      if ftype == TType.STOP:
12369 
        break
12370 
      if fid == 1:
559 chandransh 12371 
        if ftype == TType.I64:
2981 rajveer 12372 
          self.userId = iprot.readI64();
130 ashish 12373 
        else:
12374 
          iprot.skip(ftype)
12375 
      elif fid == 2:
559 chandransh 12376 
        if ftype == TType.I64:
2981 rajveer 12377 
          self.itemId = iprot.readI64();
559 chandransh 12378 
        else:
12379 
          iprot.skip(ftype)
130 ashish 12380 
      else:
12381 
        iprot.skip(ftype)
12382 
      iprot.readFieldEnd()
12383 
    iprot.readStructEnd()
12384 
 
12385 
  def write(self, oprot):
12386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12388 
      return
2981 rajveer 12389 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 12390 
    if self.userId is not None:
2981 rajveer 12391 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12392 
      oprot.writeI64(self.userId)
130 ashish 12393 
      oprot.writeFieldEnd()
3431 rajveer 12394 
    if self.itemId is not None:
2981 rajveer 12395 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12396 
      oprot.writeI64(self.itemId)
130 ashish 12397 
      oprot.writeFieldEnd()
12398 
    oprot.writeFieldStop()
12399 
    oprot.writeStructEnd()
12400 
 
3431 rajveer 12401 
  def validate(self):
12402 
    return
12403 
 
12404 
 
130 ashish 12405 
  def __repr__(self):
12406 
    L = ['%s=%r' % (key, value)
12407 
      for key, value in self.__dict__.iteritems()]
12408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12409 
 
12410 
  def __eq__(self, other):
12411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12412 
 
12413 
  def __ne__(self, other):
12414 
    return not (self == other)
12415 
 
2981 rajveer 12416 
class updateMyResearch_result:
12417 
  """
12418 
  Attributes:
12419 
   - success
12420 
   - scx
12421 
  """
559 chandransh 12422 
 
12423 
  thrift_spec = (
2981 rajveer 12424 
    (0, TType.BOOL, 'success', None, None, ), # 0
12425 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12426 
  )
12427 
 
2981 rajveer 12428 
  def __init__(self, success=None, scx=None,):
12429 
    self.success = success
12430 
    self.scx = scx
12431 
 
559 chandransh 12432 
  def read(self, iprot):
12433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12435 
      return
12436 
    iprot.readStructBegin()
12437 
    while True:
12438 
      (fname, ftype, fid) = iprot.readFieldBegin()
12439 
      if ftype == TType.STOP:
12440 
        break
2981 rajveer 12441 
      if fid == 0:
12442 
        if ftype == TType.BOOL:
12443 
          self.success = iprot.readBool();
12444 
        else:
12445 
          iprot.skip(ftype)
12446 
      elif fid == 1:
12447 
        if ftype == TType.STRUCT:
12448 
          self.scx = WidgetException()
12449 
          self.scx.read(iprot)
12450 
        else:
12451 
          iprot.skip(ftype)
559 chandransh 12452 
      else:
12453 
        iprot.skip(ftype)
12454 
      iprot.readFieldEnd()
12455 
    iprot.readStructEnd()
12456 
 
12457 
  def write(self, oprot):
12458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12460 
      return
2981 rajveer 12461 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 12462 
    if self.success is not None:
2981 rajveer 12463 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12464 
      oprot.writeBool(self.success)
12465 
      oprot.writeFieldEnd()
3431 rajveer 12466 
    if self.scx is not None:
2981 rajveer 12467 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12468 
      self.scx.write(oprot)
12469 
      oprot.writeFieldEnd()
559 chandransh 12470 
    oprot.writeFieldStop()
12471 
    oprot.writeStructEnd()
12472 
 
3431 rajveer 12473 
  def validate(self):
12474 
    return
12475 
 
12476 
 
559 chandransh 12477 
  def __repr__(self):
12478 
    L = ['%s=%r' % (key, value)
12479 
      for key, value in self.__dict__.iteritems()]
12480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12481 
 
12482 
  def __eq__(self, other):
12483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12484 
 
12485 
  def __ne__(self, other):
12486 
    return not (self == other)
12487 
 
2981 rajveer 12488 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12489 
  """
12490 
  Attributes:
2981 rajveer 12491 
   - userId
12492 
   - itemId
1596 ankur.sing 12493 
  """
559 chandransh 12494 
 
1596 ankur.sing 12495 
  thrift_spec = (
12496 
    None, # 0
2981 rajveer 12497 
    (1, TType.I64, 'userId', None, None, ), # 1
12498 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12499 
  )
12500 
 
2981 rajveer 12501 
  def __init__(self, userId=None, itemId=None,):
12502 
    self.userId = userId
12503 
    self.itemId = itemId
1596 ankur.sing 12504 
 
12505 
  def read(self, iprot):
12506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12508 
      return
12509 
    iprot.readStructBegin()
12510 
    while True:
12511 
      (fname, ftype, fid) = iprot.readFieldBegin()
12512 
      if ftype == TType.STOP:
12513 
        break
12514 
      if fid == 1:
2981 rajveer 12515 
        if ftype == TType.I64:
12516 
          self.userId = iprot.readI64();
1596 ankur.sing 12517 
        else:
12518 
          iprot.skip(ftype)
2981 rajveer 12519 
      elif fid == 2:
12520 
        if ftype == TType.I64:
12521 
          self.itemId = iprot.readI64();
12522 
        else:
12523 
          iprot.skip(ftype)
1596 ankur.sing 12524 
      else:
12525 
        iprot.skip(ftype)
12526 
      iprot.readFieldEnd()
12527 
    iprot.readStructEnd()
12528 
 
12529 
  def write(self, oprot):
12530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12532 
      return
2981 rajveer 12533 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 12534 
    if self.userId is not None:
2981 rajveer 12535 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12536 
      oprot.writeI64(self.userId)
1596 ankur.sing 12537 
      oprot.writeFieldEnd()
3431 rajveer 12538 
    if self.itemId is not None:
2981 rajveer 12539 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12540 
      oprot.writeI64(self.itemId)
12541 
      oprot.writeFieldEnd()
1596 ankur.sing 12542 
    oprot.writeFieldStop()
12543 
    oprot.writeStructEnd()
12544 
 
3431 rajveer 12545 
  def validate(self):
12546 
    return
12547 
 
12548 
 
1596 ankur.sing 12549 
  def __repr__(self):
12550 
    L = ['%s=%r' % (key, value)
12551 
      for key, value in self.__dict__.iteritems()]
12552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12553 
 
12554 
  def __eq__(self, other):
12555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12556 
 
12557 
  def __ne__(self, other):
12558 
    return not (self == other)
12559 
 
2981 rajveer 12560 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12561 
  """
12562 
  Attributes:
2981 rajveer 12563 
   - scx
1596 ankur.sing 12564 
  """
12565 
 
12566 
  thrift_spec = (
2981 rajveer 12567 
    None, # 0
12568 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12569 
  )
12570 
 
2981 rajveer 12571 
  def __init__(self, scx=None,):
12572 
    self.scx = scx
1596 ankur.sing 12573 
 
12574 
  def read(self, iprot):
12575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12577 
      return
12578 
    iprot.readStructBegin()
12579 
    while True:
12580 
      (fname, ftype, fid) = iprot.readFieldBegin()
12581 
      if ftype == TType.STOP:
12582 
        break
2981 rajveer 12583 
      if fid == 1:
12584 
        if ftype == TType.STRUCT:
12585 
          self.scx = WidgetException()
12586 
          self.scx.read(iprot)
1596 ankur.sing 12587 
        else:
12588 
          iprot.skip(ftype)
12589 
      else:
12590 
        iprot.skip(ftype)
12591 
      iprot.readFieldEnd()
12592 
    iprot.readStructEnd()
12593 
 
12594 
  def write(self, oprot):
12595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12597 
      return
2981 rajveer 12598 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 12599 
    if self.scx is not None:
2981 rajveer 12600 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12601 
      self.scx.write(oprot)
1596 ankur.sing 12602 
      oprot.writeFieldEnd()
12603 
    oprot.writeFieldStop()
12604 
    oprot.writeStructEnd()
12605 
 
3431 rajveer 12606 
  def validate(self):
12607 
    return
12608 
 
12609 
 
1596 ankur.sing 12610 
  def __repr__(self):
12611 
    L = ['%s=%r' % (key, value)
12612 
      for key, value in self.__dict__.iteritems()]
12613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12614 
 
12615 
  def __eq__(self, other):
12616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12617 
 
12618 
  def __ne__(self, other):
12619 
    return not (self == other)
12620 
 
2981 rajveer 12621 
class getBrowseHistoryItems_args:
1673 ankur.sing 12622 
  """
12623 
  Attributes:
2981 rajveer 12624 
   - userId
1673 ankur.sing 12625 
  """
1596 ankur.sing 12626 
 
1673 ankur.sing 12627 
  thrift_spec = (
12628 
    None, # 0
2981 rajveer 12629 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12630 
  )
12631 
 
2981 rajveer 12632 
  def __init__(self, userId=None,):
12633 
    self.userId = userId
1673 ankur.sing 12634 
 
12635 
  def read(self, iprot):
12636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12638 
      return
12639 
    iprot.readStructBegin()
12640 
    while True:
12641 
      (fname, ftype, fid) = iprot.readFieldBegin()
12642 
      if ftype == TType.STOP:
12643 
        break
12644 
      if fid == 1:
1891 ankur.sing 12645 
        if ftype == TType.I64:
2981 rajveer 12646 
          self.userId = iprot.readI64();
1891 ankur.sing 12647 
        else:
12648 
          iprot.skip(ftype)
1673 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('getBrowseHistoryItems_args')
3431 rajveer 12659 
    if self.userId is not None:
2981 rajveer 12660 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12661 
      oprot.writeI64(self.userId)
1673 ankur.sing 12662 
      oprot.writeFieldEnd()
12663 
    oprot.writeFieldStop()
12664 
    oprot.writeStructEnd()
12665 
 
3431 rajveer 12666 
  def validate(self):
12667 
    return
12668 
 
12669 
 
1673 ankur.sing 12670 
  def __repr__(self):
12671 
    L = ['%s=%r' % (key, value)
12672 
      for key, value in self.__dict__.iteritems()]
12673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12674 
 
12675 
  def __eq__(self, other):
12676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12677 
 
12678 
  def __ne__(self, other):
12679 
    return not (self == other)
12680 
 
2981 rajveer 12681 
class getBrowseHistoryItems_result:
1673 ankur.sing 12682 
  """
12683 
  Attributes:
12684 
   - success
2981 rajveer 12685 
   - scx
1673 ankur.sing 12686 
  """
12687 
 
12688 
  thrift_spec = (
2981 rajveer 12689 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12690 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12691 
  )
12692 
 
2981 rajveer 12693 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12694 
    self.success = success
2981 rajveer 12695 
    self.scx = scx
1673 ankur.sing 12696 
 
12697 
  def read(self, iprot):
12698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12700 
      return
12701 
    iprot.readStructBegin()
12702 
    while True:
12703 
      (fname, ftype, fid) = iprot.readFieldBegin()
12704 
      if ftype == TType.STOP:
12705 
        break
12706 
      if fid == 0:
12707 
        if ftype == TType.LIST:
12708 
          self.success = []
7746 amit.gupta 12709 
          (_etype193, _size190) = iprot.readListBegin()
12710 
          for _i194 in xrange(_size190):
12711 
            _elem195 = iprot.readI64();
12712 
            self.success.append(_elem195)
1673 ankur.sing 12713 
          iprot.readListEnd()
12714 
        else:
12715 
          iprot.skip(ftype)
2981 rajveer 12716 
      elif fid == 1:
12717 
        if ftype == TType.STRUCT:
12718 
          self.scx = WidgetException()
12719 
          self.scx.read(iprot)
12720 
        else:
12721 
          iprot.skip(ftype)
1673 ankur.sing 12722 
      else:
12723 
        iprot.skip(ftype)
12724 
      iprot.readFieldEnd()
12725 
    iprot.readStructEnd()
12726 
 
12727 
  def write(self, oprot):
12728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12730 
      return
2981 rajveer 12731 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 12732 
    if self.success is not None:
1673 ankur.sing 12733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12734 
      oprot.writeListBegin(TType.I64, len(self.success))
7746 amit.gupta 12735 
      for iter196 in self.success:
12736 
        oprot.writeI64(iter196)
1673 ankur.sing 12737 
      oprot.writeListEnd()
12738 
      oprot.writeFieldEnd()
3431 rajveer 12739 
    if self.scx is not None:
2981 rajveer 12740 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12741 
      self.scx.write(oprot)
2642 varun.gupt 12742 
      oprot.writeFieldEnd()
12743 
    oprot.writeFieldStop()
12744 
    oprot.writeStructEnd()
12745 
 
3431 rajveer 12746 
  def validate(self):
12747 
    return
12748 
 
12749 
 
2642 varun.gupt 12750 
  def __repr__(self):
12751 
    L = ['%s=%r' % (key, value)
12752 
      for key, value in self.__dict__.iteritems()]
12753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12754 
 
12755 
  def __eq__(self, other):
12756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12757 
 
12758 
  def __ne__(self, other):
12759 
    return not (self == other)
12760 
 
2981 rajveer 12761 
class updateBrowseHistory_args:
2642 varun.gupt 12762 
  """
12763 
  Attributes:
2981 rajveer 12764 
   - userId
12765 
   - itemId
2642 varun.gupt 12766 
  """
12767 
 
12768 
  thrift_spec = (
12769 
    None, # 0
2981 rajveer 12770 
    (1, TType.I64, 'userId', None, None, ), # 1
12771 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12772 
  )
12773 
 
2981 rajveer 12774 
  def __init__(self, userId=None, itemId=None,):
12775 
    self.userId = userId
12776 
    self.itemId = itemId
2642 varun.gupt 12777 
 
12778 
  def read(self, iprot):
12779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12781 
      return
12782 
    iprot.readStructBegin()
12783 
    while True:
12784 
      (fname, ftype, fid) = iprot.readFieldBegin()
12785 
      if ftype == TType.STOP:
12786 
        break
12787 
      if fid == 1:
12788 
        if ftype == TType.I64:
2981 rajveer 12789 
          self.userId = iprot.readI64();
2642 varun.gupt 12790 
        else:
12791 
          iprot.skip(ftype)
12792 
      elif fid == 2:
12793 
        if ftype == TType.I64:
2981 rajveer 12794 
          self.itemId = iprot.readI64();
2642 varun.gupt 12795 
        else:
12796 
          iprot.skip(ftype)
12797 
      else:
12798 
        iprot.skip(ftype)
12799 
      iprot.readFieldEnd()
12800 
    iprot.readStructEnd()
12801 
 
12802 
  def write(self, oprot):
12803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12805 
      return
2981 rajveer 12806 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 12807 
    if self.userId is not None:
2981 rajveer 12808 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12809 
      oprot.writeI64(self.userId)
2642 varun.gupt 12810 
      oprot.writeFieldEnd()
3431 rajveer 12811 
    if self.itemId is not None:
2981 rajveer 12812 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12813 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12814 
      oprot.writeFieldEnd()
12815 
    oprot.writeFieldStop()
12816 
    oprot.writeStructEnd()
12817 
 
3431 rajveer 12818 
  def validate(self):
12819 
    return
12820 
 
12821 
 
2642 varun.gupt 12822 
  def __repr__(self):
12823 
    L = ['%s=%r' % (key, value)
12824 
      for key, value in self.__dict__.iteritems()]
12825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12826 
 
12827 
  def __eq__(self, other):
12828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12829 
 
12830 
  def __ne__(self, other):
12831 
    return not (self == other)
12832 
 
2981 rajveer 12833 
class updateBrowseHistory_result:
2642 varun.gupt 12834 
 
12835 
  thrift_spec = (
12836 
  )
12837 
 
12838 
  def read(self, iprot):
12839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12841 
      return
12842 
    iprot.readStructBegin()
12843 
    while True:
12844 
      (fname, ftype, fid) = iprot.readFieldBegin()
12845 
      if ftype == TType.STOP:
12846 
        break
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('updateBrowseHistory_result')
2642 varun.gupt 12857 
    oprot.writeFieldStop()
12858 
    oprot.writeStructEnd()
12859 
 
3431 rajveer 12860 
  def validate(self):
12861 
    return
12862 
 
12863 
 
2642 varun.gupt 12864 
  def __repr__(self):
12865 
    L = ['%s=%r' % (key, value)
12866 
      for key, value in self.__dict__.iteritems()]
12867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12868 
 
12869 
  def __eq__(self, other):
12870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12871 
 
12872 
  def __ne__(self, other):
12873 
    return not (self == other)
12874 
 
3385 varun.gupt 12875 
class getCartsWithCouponCount_args:
12876 
  """
12877 
  Attributes:
12878 
   - couponCode
12879 
  """
2642 varun.gupt 12880 
 
3385 varun.gupt 12881 
  thrift_spec = (
12882 
    None, # 0
12883 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
12884 
  )
12885 
 
12886 
  def __init__(self, couponCode=None,):
12887 
    self.couponCode = couponCode
12888 
 
12889 
  def read(self, iprot):
12890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12892 
      return
12893 
    iprot.readStructBegin()
12894 
    while True:
12895 
      (fname, ftype, fid) = iprot.readFieldBegin()
12896 
      if ftype == TType.STOP:
12897 
        break
12898 
      if fid == 1:
12899 
        if ftype == TType.STRING:
12900 
          self.couponCode = iprot.readString();
12901 
        else:
12902 
          iprot.skip(ftype)
12903 
      else:
12904 
        iprot.skip(ftype)
12905 
      iprot.readFieldEnd()
12906 
    iprot.readStructEnd()
12907 
 
12908 
  def write(self, oprot):
12909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12911 
      return
12912 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 12913 
    if self.couponCode is not None:
3385 varun.gupt 12914 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
12915 
      oprot.writeString(self.couponCode)
12916 
      oprot.writeFieldEnd()
12917 
    oprot.writeFieldStop()
12918 
    oprot.writeStructEnd()
12919 
 
3431 rajveer 12920 
  def validate(self):
12921 
    return
12922 
 
12923 
 
3385 varun.gupt 12924 
  def __repr__(self):
12925 
    L = ['%s=%r' % (key, value)
12926 
      for key, value in self.__dict__.iteritems()]
12927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12928 
 
12929 
  def __eq__(self, other):
12930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12931 
 
12932 
  def __ne__(self, other):
12933 
    return not (self == other)
12934 
 
12935 
class getCartsWithCouponCount_result:
12936 
  """
12937 
  Attributes:
12938 
   - success
12939 
  """
12940 
 
12941 
  thrift_spec = (
12942 
    (0, TType.I64, 'success', None, None, ), # 0
12943 
  )
12944 
 
12945 
  def __init__(self, success=None,):
12946 
    self.success = success
12947 
 
12948 
  def read(self, iprot):
12949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12951 
      return
12952 
    iprot.readStructBegin()
12953 
    while True:
12954 
      (fname, ftype, fid) = iprot.readFieldBegin()
12955 
      if ftype == TType.STOP:
12956 
        break
12957 
      if fid == 0:
12958 
        if ftype == TType.I64:
12959 
          self.success = iprot.readI64();
12960 
        else:
12961 
          iprot.skip(ftype)
12962 
      else:
12963 
        iprot.skip(ftype)
12964 
      iprot.readFieldEnd()
12965 
    iprot.readStructEnd()
12966 
 
12967 
  def write(self, oprot):
12968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12970 
      return
12971 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 12972 
    if self.success is not None:
3385 varun.gupt 12973 
      oprot.writeFieldBegin('success', TType.I64, 0)
12974 
      oprot.writeI64(self.success)
12975 
      oprot.writeFieldEnd()
12976 
    oprot.writeFieldStop()
12977 
    oprot.writeStructEnd()
12978 
 
3431 rajveer 12979 
  def validate(self):
12980 
    return
12981 
 
12982 
 
3385 varun.gupt 12983 
  def __repr__(self):
12984 
    L = ['%s=%r' % (key, value)
12985 
      for key, value in self.__dict__.iteritems()]
12986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12987 
 
12988 
  def __eq__(self, other):
12989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12990 
 
12991 
  def __ne__(self, other):
12992 
    return not (self == other)
3499 mandeep.dh 12993 
 
12994 
class increaseTrustLevel_args:
12995 
  """
12996 
  Attributes:
12997 
   - userId
12998 
   - trustLevelDelta
12999 
  """
13000 
 
13001 
  thrift_spec = (
13002 
    None, # 0
13003 
    (1, TType.I64, 'userId', None, None, ), # 1
13004 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13005 
  )
13006 
 
13007 
  def __init__(self, userId=None, trustLevelDelta=None,):
13008 
    self.userId = userId
13009 
    self.trustLevelDelta = trustLevelDelta
13010 
 
13011 
  def read(self, iprot):
13012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13014 
      return
13015 
    iprot.readStructBegin()
13016 
    while True:
13017 
      (fname, ftype, fid) = iprot.readFieldBegin()
13018 
      if ftype == TType.STOP:
13019 
        break
13020 
      if fid == 1:
13021 
        if ftype == TType.I64:
13022 
          self.userId = iprot.readI64();
13023 
        else:
13024 
          iprot.skip(ftype)
13025 
      elif fid == 2:
13026 
        if ftype == TType.DOUBLE:
13027 
          self.trustLevelDelta = iprot.readDouble();
13028 
        else:
13029 
          iprot.skip(ftype)
13030 
      else:
13031 
        iprot.skip(ftype)
13032 
      iprot.readFieldEnd()
13033 
    iprot.readStructEnd()
13034 
 
13035 
  def write(self, oprot):
13036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13038 
      return
13039 
    oprot.writeStructBegin('increaseTrustLevel_args')
13040 
    if self.userId is not None:
13041 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13042 
      oprot.writeI64(self.userId)
13043 
      oprot.writeFieldEnd()
13044 
    if self.trustLevelDelta is not None:
13045 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13046 
      oprot.writeDouble(self.trustLevelDelta)
13047 
      oprot.writeFieldEnd()
13048 
    oprot.writeFieldStop()
13049 
    oprot.writeStructEnd()
13050 
 
13051 
  def validate(self):
13052 
    return
13053 
 
13054 
 
13055 
  def __repr__(self):
13056 
    L = ['%s=%r' % (key, value)
13057 
      for key, value in self.__dict__.iteritems()]
13058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13059 
 
13060 
  def __eq__(self, other):
13061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13062 
 
13063 
  def __ne__(self, other):
13064 
    return not (self == other)
4668 varun.gupt 13065 
 
5407 amar.kumar 13066 
class getTrustLevel_args:
13067 
  """
13068 
  Attributes:
13069 
   - userId
13070 
  """
13071 
 
13072 
  thrift_spec = (
13073 
    None, # 0
13074 
    (1, TType.I64, 'userId', None, None, ), # 1
13075 
  )
13076 
 
13077 
  def __init__(self, userId=None,):
13078 
    self.userId = userId
13079 
 
13080 
  def read(self, iprot):
13081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13083 
      return
13084 
    iprot.readStructBegin()
13085 
    while True:
13086 
      (fname, ftype, fid) = iprot.readFieldBegin()
13087 
      if ftype == TType.STOP:
13088 
        break
13089 
      if fid == 1:
13090 
        if ftype == TType.I64:
13091 
          self.userId = iprot.readI64();
13092 
        else:
13093 
          iprot.skip(ftype)
13094 
      else:
13095 
        iprot.skip(ftype)
13096 
      iprot.readFieldEnd()
13097 
    iprot.readStructEnd()
13098 
 
13099 
  def write(self, oprot):
13100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13102 
      return
13103 
    oprot.writeStructBegin('getTrustLevel_args')
13104 
    if self.userId is not None:
13105 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13106 
      oprot.writeI64(self.userId)
13107 
      oprot.writeFieldEnd()
13108 
    oprot.writeFieldStop()
13109 
    oprot.writeStructEnd()
13110 
 
13111 
  def validate(self):
13112 
    return
13113 
 
13114 
 
13115 
  def __repr__(self):
13116 
    L = ['%s=%r' % (key, value)
13117 
      for key, value in self.__dict__.iteritems()]
13118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13119 
 
13120 
  def __eq__(self, other):
13121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13122 
 
13123 
  def __ne__(self, other):
13124 
    return not (self == other)
13125 
 
13126 
class getTrustLevel_result:
13127 
  """
13128 
  Attributes:
13129 
   - success
13130 
  """
13131 
 
13132 
  thrift_spec = (
13133 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13134 
  )
13135 
 
13136 
  def __init__(self, success=None,):
13137 
    self.success = success
13138 
 
13139 
  def read(self, iprot):
13140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13142 
      return
13143 
    iprot.readStructBegin()
13144 
    while True:
13145 
      (fname, ftype, fid) = iprot.readFieldBegin()
13146 
      if ftype == TType.STOP:
13147 
        break
13148 
      if fid == 0:
13149 
        if ftype == TType.DOUBLE:
13150 
          self.success = iprot.readDouble();
13151 
        else:
13152 
          iprot.skip(ftype)
13153 
      else:
13154 
        iprot.skip(ftype)
13155 
      iprot.readFieldEnd()
13156 
    iprot.readStructEnd()
13157 
 
13158 
  def write(self, oprot):
13159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13161 
      return
13162 
    oprot.writeStructBegin('getTrustLevel_result')
13163 
    if self.success is not None:
13164 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13165 
      oprot.writeDouble(self.success)
13166 
      oprot.writeFieldEnd()
13167 
    oprot.writeFieldStop()
13168 
    oprot.writeStructEnd()
13169 
 
13170 
  def validate(self):
13171 
    return
13172 
 
13173 
 
13174 
  def __repr__(self):
13175 
    L = ['%s=%r' % (key, value)
13176 
      for key, value in self.__dict__.iteritems()]
13177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13178 
 
13179 
  def __eq__(self, other):
13180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13181 
 
13182 
  def __ne__(self, other):
13183 
    return not (self == other)
13184 
 
4668 varun.gupt 13185 
class showCODOption_args:
13186 
  """
13187 
  Attributes:
13188 
   - cartId
13189 
   - sourceId
13190 
   - pincode
13191 
  """
13192 
 
13193 
  thrift_spec = (
13194 
    None, # 0
13195 
    (1, TType.I64, 'cartId', None, None, ), # 1
13196 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13197 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13198 
  )
13199 
 
13200 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13201 
    self.cartId = cartId
13202 
    self.sourceId = sourceId
13203 
    self.pincode = pincode
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.cartId = iprot.readI64();
13217 
        else:
13218 
          iprot.skip(ftype)
13219 
      elif fid == 2:
13220 
        if ftype == TType.I64:
13221 
          self.sourceId = iprot.readI64();
13222 
        else:
13223 
          iprot.skip(ftype)
13224 
      elif fid == 3:
13225 
        if ftype == TType.STRING:
13226 
          self.pincode = iprot.readString();
13227 
        else:
13228 
          iprot.skip(ftype)
13229 
      else:
13230 
        iprot.skip(ftype)
13231 
      iprot.readFieldEnd()
13232 
    iprot.readStructEnd()
13233 
 
13234 
  def write(self, oprot):
13235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13237 
      return
13238 
    oprot.writeStructBegin('showCODOption_args')
13239 
    if self.cartId is not None:
13240 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13241 
      oprot.writeI64(self.cartId)
13242 
      oprot.writeFieldEnd()
13243 
    if self.sourceId is not None:
13244 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13245 
      oprot.writeI64(self.sourceId)
13246 
      oprot.writeFieldEnd()
13247 
    if self.pincode is not None:
13248 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
13249 
      oprot.writeString(self.pincode)
13250 
      oprot.writeFieldEnd()
13251 
    oprot.writeFieldStop()
13252 
    oprot.writeStructEnd()
13253 
 
13254 
  def validate(self):
13255 
    return
13256 
 
13257 
 
13258 
  def __repr__(self):
13259 
    L = ['%s=%r' % (key, value)
13260 
      for key, value in self.__dict__.iteritems()]
13261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13262 
 
13263 
  def __eq__(self, other):
13264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13265 
 
13266 
  def __ne__(self, other):
13267 
    return not (self == other)
13268 
 
13269 
class showCODOption_result:
13270 
  """
13271 
  Attributes:
13272 
   - success
13273 
  """
13274 
 
13275 
  thrift_spec = (
13276 
    (0, TType.BOOL, 'success', None, None, ), # 0
13277 
  )
13278 
 
13279 
  def __init__(self, success=None,):
13280 
    self.success = success
13281 
 
13282 
  def read(self, iprot):
13283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13285 
      return
13286 
    iprot.readStructBegin()
13287 
    while True:
13288 
      (fname, ftype, fid) = iprot.readFieldBegin()
13289 
      if ftype == TType.STOP:
13290 
        break
13291 
      if fid == 0:
13292 
        if ftype == TType.BOOL:
13293 
          self.success = iprot.readBool();
13294 
        else:
13295 
          iprot.skip(ftype)
13296 
      else:
13297 
        iprot.skip(ftype)
13298 
      iprot.readFieldEnd()
13299 
    iprot.readStructEnd()
13300 
 
13301 
  def write(self, oprot):
13302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13304 
      return
13305 
    oprot.writeStructBegin('showCODOption_result')
13306 
    if self.success is not None:
13307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13308 
      oprot.writeBool(self.success)
13309 
      oprot.writeFieldEnd()
13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
5623 anupam.sin 13327 
 
13328 
class getUserEmails_args:
13329 
  """
13330 
  Attributes:
13331 
   - startDate
13332 
   - endDate
13333 
  """
13334 
 
13335 
  thrift_spec = (
13336 
    None, # 0
13337 
    (1, TType.I64, 'startDate', None, None, ), # 1
13338 
    (2, TType.I64, 'endDate', None, None, ), # 2
13339 
  )
13340 
 
13341 
  def __init__(self, startDate=None, endDate=None,):
13342 
    self.startDate = startDate
13343 
    self.endDate = endDate
13344 
 
13345 
  def read(self, iprot):
13346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13348 
      return
13349 
    iprot.readStructBegin()
13350 
    while True:
13351 
      (fname, ftype, fid) = iprot.readFieldBegin()
13352 
      if ftype == TType.STOP:
13353 
        break
13354 
      if fid == 1:
13355 
        if ftype == TType.I64:
13356 
          self.startDate = iprot.readI64();
13357 
        else:
13358 
          iprot.skip(ftype)
13359 
      elif fid == 2:
13360 
        if ftype == TType.I64:
13361 
          self.endDate = iprot.readI64();
13362 
        else:
13363 
          iprot.skip(ftype)
13364 
      else:
13365 
        iprot.skip(ftype)
13366 
      iprot.readFieldEnd()
13367 
    iprot.readStructEnd()
13368 
 
13369 
  def write(self, oprot):
13370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13372 
      return
13373 
    oprot.writeStructBegin('getUserEmails_args')
13374 
    if self.startDate is not None:
13375 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
13376 
      oprot.writeI64(self.startDate)
13377 
      oprot.writeFieldEnd()
13378 
    if self.endDate is not None:
13379 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
13380 
      oprot.writeI64(self.endDate)
13381 
      oprot.writeFieldEnd()
13382 
    oprot.writeFieldStop()
13383 
    oprot.writeStructEnd()
13384 
 
13385 
  def validate(self):
13386 
    return
13387 
 
13388 
 
13389 
  def __repr__(self):
13390 
    L = ['%s=%r' % (key, value)
13391 
      for key, value in self.__dict__.iteritems()]
13392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13393 
 
13394 
  def __eq__(self, other):
13395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13396 
 
13397 
  def __ne__(self, other):
13398 
    return not (self == other)
13399 
 
13400 
class getUserEmails_result:
13401 
  """
13402 
  Attributes:
13403 
   - success
13404 
  """
13405 
 
13406 
  thrift_spec = (
13407 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13408 
  )
13409 
 
13410 
  def __init__(self, success=None,):
13411 
    self.success = success
13412 
 
13413 
  def read(self, iprot):
13414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13416 
      return
13417 
    iprot.readStructBegin()
13418 
    while True:
13419 
      (fname, ftype, fid) = iprot.readFieldBegin()
13420 
      if ftype == TType.STOP:
13421 
        break
13422 
      if fid == 0:
13423 
        if ftype == TType.LIST:
13424 
          self.success = []
7746 amit.gupta 13425 
          (_etype200, _size197) = iprot.readListBegin()
13426 
          for _i201 in xrange(_size197):
13427 
            _elem202 = iprot.readString();
13428 
            self.success.append(_elem202)
5623 anupam.sin 13429 
          iprot.readListEnd()
13430 
        else:
13431 
          iprot.skip(ftype)
13432 
      else:
13433 
        iprot.skip(ftype)
13434 
      iprot.readFieldEnd()
13435 
    iprot.readStructEnd()
13436 
 
13437 
  def write(self, oprot):
13438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13440 
      return
13441 
    oprot.writeStructBegin('getUserEmails_result')
13442 
    if self.success is not None:
13443 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13444 
      oprot.writeListBegin(TType.STRING, len(self.success))
7746 amit.gupta 13445 
      for iter203 in self.success:
13446 
        oprot.writeString(iter203)
5623 anupam.sin 13447 
      oprot.writeListEnd()
13448 
      oprot.writeFieldEnd()
13449 
    oprot.writeFieldStop()
13450 
    oprot.writeStructEnd()
13451 
 
13452 
  def validate(self):
13453 
    return
13454 
 
13455 
 
13456 
  def __repr__(self):
13457 
    L = ['%s=%r' % (key, value)
13458 
      for key, value in self.__dict__.iteritems()]
13459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13460 
 
13461 
  def __eq__(self, other):
13462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13463 
 
13464 
  def __ne__(self, other):
13465 
    return not (self == other)
6821 amar.kumar 13466 
 
6903 anupam.sin 13467 
class insureItem_args:
13468 
  """
13469 
  Attributes:
13470 
   - itemId
13471 
   - cartId
13472 
   - toInsure
13473 
  """
13474 
 
13475 
  thrift_spec = (
13476 
    None, # 0
13477 
    (1, TType.I64, 'itemId', None, None, ), # 1
13478 
    (2, TType.I64, 'cartId', None, None, ), # 2
13479 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
13480 
  )
13481 
 
13482 
  def __init__(self, itemId=None, cartId=None, toInsure=None,):
13483 
    self.itemId = itemId
13484 
    self.cartId = cartId
13485 
    self.toInsure = toInsure
13486 
 
13487 
  def read(self, iprot):
13488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13490 
      return
13491 
    iprot.readStructBegin()
13492 
    while True:
13493 
      (fname, ftype, fid) = iprot.readFieldBegin()
13494 
      if ftype == TType.STOP:
13495 
        break
13496 
      if fid == 1:
13497 
        if ftype == TType.I64:
13498 
          self.itemId = iprot.readI64();
13499 
        else:
13500 
          iprot.skip(ftype)
13501 
      elif fid == 2:
13502 
        if ftype == TType.I64:
13503 
          self.cartId = iprot.readI64();
13504 
        else:
13505 
          iprot.skip(ftype)
13506 
      elif fid == 3:
13507 
        if ftype == TType.BOOL:
13508 
          self.toInsure = iprot.readBool();
13509 
        else:
13510 
          iprot.skip(ftype)
13511 
      else:
13512 
        iprot.skip(ftype)
13513 
      iprot.readFieldEnd()
13514 
    iprot.readStructEnd()
13515 
 
13516 
  def write(self, oprot):
13517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13519 
      return
13520 
    oprot.writeStructBegin('insureItem_args')
13521 
    if self.itemId is not None:
13522 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13523 
      oprot.writeI64(self.itemId)
13524 
      oprot.writeFieldEnd()
13525 
    if self.cartId is not None:
13526 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
13527 
      oprot.writeI64(self.cartId)
13528 
      oprot.writeFieldEnd()
13529 
    if self.toInsure is not None:
13530 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
13531 
      oprot.writeBool(self.toInsure)
13532 
      oprot.writeFieldEnd()
13533 
    oprot.writeFieldStop()
13534 
    oprot.writeStructEnd()
13535 
 
13536 
  def validate(self):
13537 
    return
13538 
 
13539 
 
13540 
  def __repr__(self):
13541 
    L = ['%s=%r' % (key, value)
13542 
      for key, value in self.__dict__.iteritems()]
13543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13544 
 
13545 
  def __eq__(self, other):
13546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13547 
 
13548 
  def __ne__(self, other):
13549 
    return not (self == other)
13550 
 
13551 
class insureItem_result:
13552 
  """
13553 
  Attributes:
13554 
   - success
13555 
  """
13556 
 
13557 
  thrift_spec = (
13558 
    (0, TType.BOOL, 'success', None, None, ), # 0
13559 
  )
13560 
 
13561 
  def __init__(self, success=None,):
13562 
    self.success = success
13563 
 
13564 
  def read(self, iprot):
13565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13567 
      return
13568 
    iprot.readStructBegin()
13569 
    while True:
13570 
      (fname, ftype, fid) = iprot.readFieldBegin()
13571 
      if ftype == TType.STOP:
13572 
        break
13573 
      if fid == 0:
13574 
        if ftype == TType.BOOL:
13575 
          self.success = iprot.readBool();
13576 
        else:
13577 
          iprot.skip(ftype)
13578 
      else:
13579 
        iprot.skip(ftype)
13580 
      iprot.readFieldEnd()
13581 
    iprot.readStructEnd()
13582 
 
13583 
  def write(self, oprot):
13584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13586 
      return
13587 
    oprot.writeStructBegin('insureItem_result')
13588 
    if self.success is not None:
13589 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13590 
      oprot.writeBool(self.success)
13591 
      oprot.writeFieldEnd()
13592 
    oprot.writeFieldStop()
13593 
    oprot.writeStructEnd()
13594 
 
13595 
  def validate(self):
13596 
    return
13597 
 
13598 
 
13599 
  def __repr__(self):
13600 
    L = ['%s=%r' % (key, value)
13601 
      for key, value in self.__dict__.iteritems()]
13602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13603 
 
13604 
  def __eq__(self, other):
13605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13606 
 
13607 
  def __ne__(self, other):
13608 
    return not (self == other)
13609 
 
13610 
class cancelInsurance_args:
13611 
  """
13612 
  Attributes:
13613 
   - cartId
13614 
  """
13615 
 
13616 
  thrift_spec = (
13617 
    None, # 0
13618 
    (1, TType.I64, 'cartId', None, None, ), # 1
13619 
  )
13620 
 
13621 
  def __init__(self, cartId=None,):
13622 
    self.cartId = cartId
13623 
 
13624 
  def read(self, iprot):
13625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13627 
      return
13628 
    iprot.readStructBegin()
13629 
    while True:
13630 
      (fname, ftype, fid) = iprot.readFieldBegin()
13631 
      if ftype == TType.STOP:
13632 
        break
13633 
      if fid == 1:
13634 
        if ftype == TType.I64:
13635 
          self.cartId = iprot.readI64();
13636 
        else:
13637 
          iprot.skip(ftype)
13638 
      else:
13639 
        iprot.skip(ftype)
13640 
      iprot.readFieldEnd()
13641 
    iprot.readStructEnd()
13642 
 
13643 
  def write(self, oprot):
13644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13646 
      return
13647 
    oprot.writeStructBegin('cancelInsurance_args')
13648 
    if self.cartId is not None:
13649 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13650 
      oprot.writeI64(self.cartId)
13651 
      oprot.writeFieldEnd()
13652 
    oprot.writeFieldStop()
13653 
    oprot.writeStructEnd()
13654 
 
13655 
  def validate(self):
13656 
    return
13657 
 
13658 
 
13659 
  def __repr__(self):
13660 
    L = ['%s=%r' % (key, value)
13661 
      for key, value in self.__dict__.iteritems()]
13662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13663 
 
13664 
  def __eq__(self, other):
13665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13666 
 
13667 
  def __ne__(self, other):
13668 
    return not (self == other)
13669 
 
13670 
class cancelInsurance_result:
13671 
  """
13672 
  Attributes:
13673 
   - success
13674 
  """
13675 
 
13676 
  thrift_spec = (
13677 
    (0, TType.BOOL, 'success', None, None, ), # 0
13678 
  )
13679 
 
13680 
  def __init__(self, success=None,):
13681 
    self.success = success
13682 
 
13683 
  def read(self, iprot):
13684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13686 
      return
13687 
    iprot.readStructBegin()
13688 
    while True:
13689 
      (fname, ftype, fid) = iprot.readFieldBegin()
13690 
      if ftype == TType.STOP:
13691 
        break
13692 
      if fid == 0:
13693 
        if ftype == TType.BOOL:
13694 
          self.success = iprot.readBool();
13695 
        else:
13696 
          iprot.skip(ftype)
13697 
      else:
13698 
        iprot.skip(ftype)
13699 
      iprot.readFieldEnd()
13700 
    iprot.readStructEnd()
13701 
 
13702 
  def write(self, oprot):
13703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13705 
      return
13706 
    oprot.writeStructBegin('cancelInsurance_result')
13707 
    if self.success is not None:
13708 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13709 
      oprot.writeBool(self.success)
13710 
      oprot.writeFieldEnd()
13711 
    oprot.writeFieldStop()
13712 
    oprot.writeStructEnd()
13713 
 
13714 
  def validate(self):
13715 
    return
13716 
 
13717 
 
13718 
  def __repr__(self):
13719 
    L = ['%s=%r' % (key, value)
13720 
      for key, value in self.__dict__.iteritems()]
13721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13722 
 
13723 
  def __eq__(self, other):
13724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13725 
 
13726 
  def __ne__(self, other):
13727 
    return not (self == other)
13728 
 
13729 
class storeInsuranceSpecificDetails_args:
13730 
  """
13731 
  Attributes:
13732 
   - addressId
13733 
   - dob
13734 
   - guardianName
13735 
  """
13736 
 
13737 
  thrift_spec = (
13738 
    None, # 0
13739 
    (1, TType.I64, 'addressId', None, None, ), # 1
13740 
    (2, TType.STRING, 'dob', None, None, ), # 2
13741 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
13742 
  )
13743 
 
13744 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
13745 
    self.addressId = addressId
13746 
    self.dob = dob
13747 
    self.guardianName = guardianName
13748 
 
13749 
  def read(self, iprot):
13750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13752 
      return
13753 
    iprot.readStructBegin()
13754 
    while True:
13755 
      (fname, ftype, fid) = iprot.readFieldBegin()
13756 
      if ftype == TType.STOP:
13757 
        break
13758 
      if fid == 1:
13759 
        if ftype == TType.I64:
13760 
          self.addressId = iprot.readI64();
13761 
        else:
13762 
          iprot.skip(ftype)
13763 
      elif fid == 2:
13764 
        if ftype == TType.STRING:
13765 
          self.dob = iprot.readString();
13766 
        else:
13767 
          iprot.skip(ftype)
13768 
      elif fid == 3:
13769 
        if ftype == TType.STRING:
13770 
          self.guardianName = iprot.readString();
13771 
        else:
13772 
          iprot.skip(ftype)
13773 
      else:
13774 
        iprot.skip(ftype)
13775 
      iprot.readFieldEnd()
13776 
    iprot.readStructEnd()
13777 
 
13778 
  def write(self, oprot):
13779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13781 
      return
13782 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
13783 
    if self.addressId is not None:
13784 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
13785 
      oprot.writeI64(self.addressId)
13786 
      oprot.writeFieldEnd()
13787 
    if self.dob is not None:
13788 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
13789 
      oprot.writeString(self.dob)
13790 
      oprot.writeFieldEnd()
13791 
    if self.guardianName is not None:
13792 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
13793 
      oprot.writeString(self.guardianName)
13794 
      oprot.writeFieldEnd()
13795 
    oprot.writeFieldStop()
13796 
    oprot.writeStructEnd()
13797 
 
13798 
  def validate(self):
13799 
    return
13800 
 
13801 
 
13802 
  def __repr__(self):
13803 
    L = ['%s=%r' % (key, value)
13804 
      for key, value in self.__dict__.iteritems()]
13805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13806 
 
13807 
  def __eq__(self, other):
13808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13809 
 
13810 
  def __ne__(self, other):
13811 
    return not (self == other)
13812 
 
13813 
class storeInsuranceSpecificDetails_result:
13814 
  """
13815 
  Attributes:
13816 
   - success
13817 
  """
13818 
 
13819 
  thrift_spec = (
13820 
    (0, TType.BOOL, 'success', None, None, ), # 0
13821 
  )
13822 
 
13823 
  def __init__(self, success=None,):
13824 
    self.success = success
13825 
 
13826 
  def read(self, iprot):
13827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13829 
      return
13830 
    iprot.readStructBegin()
13831 
    while True:
13832 
      (fname, ftype, fid) = iprot.readFieldBegin()
13833 
      if ftype == TType.STOP:
13834 
        break
13835 
      if fid == 0:
13836 
        if ftype == TType.BOOL:
13837 
          self.success = iprot.readBool();
13838 
        else:
13839 
          iprot.skip(ftype)
13840 
      else:
13841 
        iprot.skip(ftype)
13842 
      iprot.readFieldEnd()
13843 
    iprot.readStructEnd()
13844 
 
13845 
  def write(self, oprot):
13846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13848 
      return
13849 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
13850 
    if self.success is not None:
13851 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13852 
      oprot.writeBool(self.success)
13853 
      oprot.writeFieldEnd()
13854 
    oprot.writeFieldStop()
13855 
    oprot.writeStructEnd()
13856 
 
13857 
  def validate(self):
13858 
    return
13859 
 
13860 
 
13861 
  def __repr__(self):
13862 
    L = ['%s=%r' % (key, value)
13863 
      for key, value in self.__dict__.iteritems()]
13864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13865 
 
13866 
  def __eq__(self, other):
13867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13868 
 
13869 
  def __ne__(self, other):
13870 
    return not (self == other)
13871 
 
13872 
class isInsuranceDetailPresent_args:
13873 
  """
13874 
  Attributes:
13875 
   - addressId
13876 
  """
13877 
 
13878 
  thrift_spec = (
13879 
    None, # 0
13880 
    (1, TType.I64, 'addressId', None, None, ), # 1
13881 
  )
13882 
 
13883 
  def __init__(self, addressId=None,):
13884 
    self.addressId = addressId
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 
      else:
13901 
        iprot.skip(ftype)
13902 
      iprot.readFieldEnd()
13903 
    iprot.readStructEnd()
13904 
 
13905 
  def write(self, oprot):
13906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13908 
      return
13909 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
13910 
    if self.addressId is not None:
13911 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
13912 
      oprot.writeI64(self.addressId)
13913 
      oprot.writeFieldEnd()
13914 
    oprot.writeFieldStop()
13915 
    oprot.writeStructEnd()
13916 
 
13917 
  def validate(self):
13918 
    return
13919 
 
13920 
 
13921 
  def __repr__(self):
13922 
    L = ['%s=%r' % (key, value)
13923 
      for key, value in self.__dict__.iteritems()]
13924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13925 
 
13926 
  def __eq__(self, other):
13927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13928 
 
13929 
  def __ne__(self, other):
13930 
    return not (self == other)
13931 
 
13932 
class isInsuranceDetailPresent_result:
13933 
  """
13934 
  Attributes:
13935 
   - success
13936 
  """
13937 
 
13938 
  thrift_spec = (
13939 
    (0, TType.BOOL, 'success', None, None, ), # 0
13940 
  )
13941 
 
13942 
  def __init__(self, success=None,):
13943 
    self.success = success
13944 
 
13945 
  def read(self, iprot):
13946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13948 
      return
13949 
    iprot.readStructBegin()
13950 
    while True:
13951 
      (fname, ftype, fid) = iprot.readFieldBegin()
13952 
      if ftype == TType.STOP:
13953 
        break
13954 
      if fid == 0:
13955 
        if ftype == TType.BOOL:
13956 
          self.success = iprot.readBool();
13957 
        else:
13958 
          iprot.skip(ftype)
13959 
      else:
13960 
        iprot.skip(ftype)
13961 
      iprot.readFieldEnd()
13962 
    iprot.readStructEnd()
13963 
 
13964 
  def write(self, oprot):
13965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13967 
      return
13968 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
13969 
    if self.success is not None:
13970 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13971 
      oprot.writeBool(self.success)
13972 
      oprot.writeFieldEnd()
13973 
    oprot.writeFieldStop()
13974 
    oprot.writeStructEnd()
13975 
 
13976 
  def validate(self):
13977 
    return
13978 
 
13979 
 
13980 
  def __repr__(self):
13981 
    L = ['%s=%r' % (key, value)
13982 
      for key, value in self.__dict__.iteritems()]
13983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13984 
 
13985 
  def __eq__(self, other):
13986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13987 
 
13988 
  def __ne__(self, other):
13989 
    return not (self == other)
13990 
 
6821 amar.kumar 13991 
class isProductAddedToCart_args:
13992 
  """
13993 
  Attributes:
13994 
   - itemId
13995 
   - startDate
13996 
   - endDate
13997 
  """
13998 
 
13999 
  thrift_spec = (
14000 
    None, # 0
14001 
    (1, TType.I64, 'itemId', None, None, ), # 1
14002 
    (2, TType.I64, 'startDate', None, None, ), # 2
14003 
    (3, TType.I64, 'endDate', None, None, ), # 3
14004 
  )
14005 
 
14006 
  def __init__(self, itemId=None, startDate=None, endDate=None,):
14007 
    self.itemId = itemId
14008 
    self.startDate = startDate
14009 
    self.endDate = endDate
14010 
 
14011 
  def read(self, iprot):
14012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14014 
      return
14015 
    iprot.readStructBegin()
14016 
    while True:
14017 
      (fname, ftype, fid) = iprot.readFieldBegin()
14018 
      if ftype == TType.STOP:
14019 
        break
14020 
      if fid == 1:
14021 
        if ftype == TType.I64:
14022 
          self.itemId = iprot.readI64();
14023 
        else:
14024 
          iprot.skip(ftype)
14025 
      elif fid == 2:
14026 
        if ftype == TType.I64:
14027 
          self.startDate = iprot.readI64();
14028 
        else:
14029 
          iprot.skip(ftype)
14030 
      elif fid == 3:
14031 
        if ftype == TType.I64:
14032 
          self.endDate = iprot.readI64();
14033 
        else:
14034 
          iprot.skip(ftype)
14035 
      else:
14036 
        iprot.skip(ftype)
14037 
      iprot.readFieldEnd()
14038 
    iprot.readStructEnd()
14039 
 
14040 
  def write(self, oprot):
14041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14043 
      return
14044 
    oprot.writeStructBegin('isProductAddedToCart_args')
14045 
    if self.itemId is not None:
14046 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14047 
      oprot.writeI64(self.itemId)
14048 
      oprot.writeFieldEnd()
14049 
    if self.startDate is not None:
14050 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
14051 
      oprot.writeI64(self.startDate)
14052 
      oprot.writeFieldEnd()
14053 
    if self.endDate is not None:
14054 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
14055 
      oprot.writeI64(self.endDate)
14056 
      oprot.writeFieldEnd()
14057 
    oprot.writeFieldStop()
14058 
    oprot.writeStructEnd()
14059 
 
14060 
  def validate(self):
14061 
    return
14062 
 
14063 
 
14064 
  def __repr__(self):
14065 
    L = ['%s=%r' % (key, value)
14066 
      for key, value in self.__dict__.iteritems()]
14067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14068 
 
14069 
  def __eq__(self, other):
14070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14071 
 
14072 
  def __ne__(self, other):
14073 
    return not (self == other)
14074 
 
14075 
class isProductAddedToCart_result:
14076 
  """
14077 
  Attributes:
14078 
   - success
14079 
  """
14080 
 
14081 
  thrift_spec = (
14082 
    (0, TType.BOOL, 'success', None, None, ), # 0
14083 
  )
14084 
 
14085 
  def __init__(self, success=None,):
14086 
    self.success = success
14087 
 
14088 
  def read(self, iprot):
14089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14091 
      return
14092 
    iprot.readStructBegin()
14093 
    while True:
14094 
      (fname, ftype, fid) = iprot.readFieldBegin()
14095 
      if ftype == TType.STOP:
14096 
        break
14097 
      if fid == 0:
14098 
        if ftype == TType.BOOL:
14099 
          self.success = iprot.readBool();
14100 
        else:
14101 
          iprot.skip(ftype)
14102 
      else:
14103 
        iprot.skip(ftype)
14104 
      iprot.readFieldEnd()
14105 
    iprot.readStructEnd()
14106 
 
14107 
  def write(self, oprot):
14108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14110 
      return
14111 
    oprot.writeStructBegin('isProductAddedToCart_result')
14112 
    if self.success is not None:
14113 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14114 
      oprot.writeBool(self.success)
14115 
      oprot.writeFieldEnd()
14116 
    oprot.writeFieldStop()
14117 
    oprot.writeStructEnd()
14118 
 
14119 
  def validate(self):
14120 
    return
14121 
 
14122 
 
14123 
  def __repr__(self):
14124 
    L = ['%s=%r' % (key, value)
14125 
      for key, value in self.__dict__.iteritems()]
14126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14127 
 
14128 
  def __eq__(self, other):
14129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14130 
 
14131 
  def __ne__(self, other):
14132 
    return not (self == other)