Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
690 chandransh 438 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 439 
    """
690 chandransh 440 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 441 
 
575 chandransh 442 
    Parameters:
690 chandransh 443 
     - fromCartId
444 
     - toCartId
445 
    """
446 
    pass
447 
 
448 
  def checkOut(self, cartId):
449 
    """
450 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 451 
 
690 chandransh 452 
    Parameters:
575 chandransh 453 
     - cartId
454 
    """
455 
    pass
456 
 
690 chandransh 457 
  def resetCart(self, cartId, items):
559 chandransh 458 
    """
690 chandransh 459 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
460 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 461 
 
559 chandransh 462 
    Parameters:
690 chandransh 463 
     - cartId
464 
     - items
559 chandransh 465 
    """
466 
    pass
467 
 
2981 rajveer 468 
  def getUserCount(self, userType):
559 chandransh 469 
    """
2981 rajveer 470 
    Returns number of registered users.
471 
    If userType = null, then it returns count of all users, including anonymous
472 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
473 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 474 
 
559 chandransh 475 
    Parameters:
2981 rajveer 476 
     - userType
559 chandransh 477 
    """
478 
    pass
479 
 
2981 rajveer 480 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 481 
    """
2981 rajveer 482 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
483 
    If any of startDate or endDate is -1, then that filter is ignored.
484 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 485 
 
486 
 
559 chandransh 487 
    Parameters:
2981 rajveer 488 
     - userType
489 
     - startDate
490 
     - endDate
559 chandransh 491 
    """
492 
    pass
493 
 
2981 rajveer 494 
  def getMyResearchItems(self, userId):
559 chandransh 495 
    """
2981 rajveer 496 
    Returns list of item ids in myresearch for the user
3431 rajveer 497 
 
559 chandransh 498 
    Parameters:
499 
     - userId
500 
    """
501 
    pass
502 
 
2981 rajveer 503 
  def updateMyResearch(self, userId, itemId):
559 chandransh 504 
    """
2981 rajveer 505 
    add item to my research for a user
3431 rajveer 506 
 
559 chandransh 507 
    Parameters:
2981 rajveer 508 
     - userId
509 
     - itemId
559 chandransh 510 
    """
511 
    pass
512 
 
2981 rajveer 513 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 514 
    """
2981 rajveer 515 
    delete item from my research for a user
3431 rajveer 516 
 
1596 ankur.sing 517 
    Parameters:
2981 rajveer 518 
     - userId
519 
     - itemId
1596 ankur.sing 520 
    """
521 
    pass
559 chandransh 522 
 
2981 rajveer 523 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 524 
    """
2981 rajveer 525 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 526 
 
1673 ankur.sing 527 
    Parameters:
2981 rajveer 528 
     - userId
1673 ankur.sing 529 
    """
530 
    pass
1596 ankur.sing 531 
 
2981 rajveer 532 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 533 
    """
2981 rajveer 534 
    add item to browse history for a user
3431 rajveer 535 
 
2642 varun.gupt 536 
    Parameters:
2981 rajveer 537 
     - userId
538 
     - itemId
2642 varun.gupt 539 
    """
540 
    pass
1673 ankur.sing 541 
 
3385 varun.gupt 542 
  def getCartsWithCouponCount(self, couponCode):
543 
    """
544 
    Returns count of Carts with given coupon applied
3431 rajveer 545 
 
3385 varun.gupt 546 
    Parameters:
547 
     - couponCode
548 
    """
549 
    pass
2642 varun.gupt 550 
 
3499 mandeep.dh 551 
  def increaseTrustLevel(self, userId, trustLevelDelta):
552 
    """
553 
    Updates COD trust level of a user
3385 varun.gupt 554 
 
3499 mandeep.dh 555 
    Parameters:
556 
     - userId
557 
     - trustLevelDelta
558 
    """
559 
    pass
560 
 
5407 amar.kumar 561 
  def getTrustLevel(self, userId):
562 
    """
563 
    Get trust level of a user
564 
 
565 
    Parameters:
566 
     - userId
567 
    """
568 
    pass
569 
 
4668 varun.gupt 570 
  def showCODOption(self, cartId, sourceId, pincode):
571 
    """
572 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 573 
 
4668 varun.gupt 574 
    Parameters:
575 
     - cartId
576 
     - sourceId
577 
     - pincode
578 
    """
579 
    pass
580 
 
5623 anupam.sin 581 
  def getUserEmails(self, startDate, endDate):
582 
    """
583 
    Get email addresses for users activated within a given date range
4668 varun.gupt 584 
 
5623 anupam.sin 585 
    Parameters:
586 
     - startDate
587 
     - endDate
588 
    """
589 
    pass
590 
 
9299 kshitij.so 591 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 592 
    """
593 
    Mark a cart lineitem as insured. Returns true/false.
594 
 
595 
    Parameters:
596 
     - itemId
597 
     - cartId
598 
     - toInsure
9299 kshitij.so 599 
     - insurerType
6903 anupam.sin 600 
    """
601 
    pass
602 
 
603 
  def cancelInsurance(self, cartId):
604 
    """
605 
    Cancel insurance for all items in the cart
606 
 
607 
    Parameters:
608 
     - cartId
609 
    """
610 
    pass
611 
 
612 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
613 
    """
614 
    Stores insurance specific details like date of birth and guardianName
615 
 
616 
    Parameters:
617 
     - addressId
618 
     - dob
619 
     - guardianName
620 
    """
621 
    pass
622 
 
623 
  def isInsuranceDetailPresent(self, addressId):
624 
    """
625 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
626 
 
627 
    Parameters:
628 
     - addressId
629 
    """
630 
    pass
631 
 
9791 rajveer 632 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 633 
    """
9791 rajveer 634 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 635 
 
6821 amar.kumar 636 
    Parameters:
637 
     - startDate
638 
     - endDate
639 
    """
640 
    pass
641 
 
11592 amit.gupta 642 
  def validateCartPlus(self, cartId, sourceId):
643 
    """
644 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 645 
 
11592 amit.gupta 646 
    Parameters:
647 
     - cartId
648 
     - sourceId
649 
    """
650 
    pass
651 
 
11679 vikram.rag 652 
  def isPrivateDealUser(self, userId):
653 
    """
654 
    Parameters:
655 
     - userId
656 
    """
657 
    pass
11592 amit.gupta 658 
 
11890 kshitij.so 659 
  def addPrivateDealUser(self, userId):
660 
    """
661 
    Parameters:
662 
     - userId
663 
    """
664 
    pass
11679 vikram.rag 665 
 
11890 kshitij.so 666 
  def changePrivateDealUserStatus(self, userId, isActive):
667 
    """
668 
    Parameters:
669 
     - userId
670 
     - isActive
671 
    """
672 
    pass
673 
 
674 
  def getPrivateDealUser(self, userId):
675 
    """
676 
    Parameters:
677 
     - userId
678 
    """
679 
    pass
680 
 
681 
 
3376 rajveer 682 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 683 
  """
684 
  service
685 
  """
686 
  def __init__(self, iprot, oprot=None):
3376 rajveer 687 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 688 
 
559 chandransh 689 
  def createAnonymousUser(self, jsessionId):
94 ashish 690 
    """
691 
    Parameters:
559 chandransh 692 
     - jsessionId
94 ashish 693 
    """
559 chandransh 694 
    self.send_createAnonymousUser(jsessionId)
695 
    return self.recv_createAnonymousUser()
94 ashish 696 
 
559 chandransh 697 
  def send_createAnonymousUser(self, jsessionId):
698 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
699 
    args = createAnonymousUser_args()
700 
    args.jsessionId = jsessionId
94 ashish 701 
    args.write(self._oprot)
702 
    self._oprot.writeMessageEnd()
703 
    self._oprot.trans.flush()
704 
 
559 chandransh 705 
  def recv_createAnonymousUser(self, ):
94 ashish 706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
707 
    if mtype == TMessageType.EXCEPTION:
708 
      x = TApplicationException()
709 
      x.read(self._iprot)
710 
      self._iprot.readMessageEnd()
711 
      raise x
559 chandransh 712 
    result = createAnonymousUser_result()
94 ashish 713 
    result.read(self._iprot)
714 
    self._iprot.readMessageEnd()
3431 rajveer 715 
    if result.success is not None:
94 ashish 716 
      return result.success
3431 rajveer 717 
    if result.ucex is not None:
559 chandransh 718 
      raise result.ucex
719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 720 
 
559 chandransh 721 
  def getUserById(self, userId):
94 ashish 722 
    """
723 
    Parameters:
724 
     - userId
725 
    """
559 chandransh 726 
    self.send_getUserById(userId)
727 
    return self.recv_getUserById()
94 ashish 728 
 
559 chandransh 729 
  def send_getUserById(self, userId):
730 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
731 
    args = getUserById_args()
94 ashish 732 
    args.userId = userId
733 
    args.write(self._oprot)
734 
    self._oprot.writeMessageEnd()
735 
    self._oprot.trans.flush()
736 
 
559 chandransh 737 
  def recv_getUserById(self, ):
94 ashish 738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
739 
    if mtype == TMessageType.EXCEPTION:
740 
      x = TApplicationException()
741 
      x.read(self._iprot)
742 
      self._iprot.readMessageEnd()
743 
      raise x
559 chandransh 744 
    result = getUserById_result()
94 ashish 745 
    result.read(self._iprot)
746 
    self._iprot.readMessageEnd()
3431 rajveer 747 
    if result.success is not None:
94 ashish 748 
      return result.success
3431 rajveer 749 
    if result.ucex is not None:
559 chandransh 750 
      raise result.ucex
751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 752 
 
5326 rajveer 753 
  def getUserByCartId(self, cartId):
754 
    """
755 
    Parameters:
756 
     - cartId
757 
    """
758 
    self.send_getUserByCartId(cartId)
759 
    return self.recv_getUserByCartId()
760 
 
761 
  def send_getUserByCartId(self, cartId):
762 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
763 
    args = getUserByCartId_args()
764 
    args.cartId = cartId
765 
    args.write(self._oprot)
766 
    self._oprot.writeMessageEnd()
767 
    self._oprot.trans.flush()
768 
 
769 
  def recv_getUserByCartId(self, ):
770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
771 
    if mtype == TMessageType.EXCEPTION:
772 
      x = TApplicationException()
773 
      x.read(self._iprot)
774 
      self._iprot.readMessageEnd()
775 
      raise x
776 
    result = getUserByCartId_result()
777 
    result.read(self._iprot)
778 
    self._iprot.readMessageEnd()
779 
    if result.success is not None:
780 
      return result.success
781 
    if result.ucex is not None:
782 
      raise result.ucex
783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
784 
 
1491 vikas 785 
  def getUserByEmail(self, email):
786 
    """
787 
    Parameters:
788 
     - email
789 
    """
790 
    self.send_getUserByEmail(email)
791 
    return self.recv_getUserByEmail()
792 
 
793 
  def send_getUserByEmail(self, email):
794 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
795 
    args = getUserByEmail_args()
796 
    args.email = email
797 
    args.write(self._oprot)
798 
    self._oprot.writeMessageEnd()
799 
    self._oprot.trans.flush()
800 
 
801 
  def recv_getUserByEmail(self, ):
802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
803 
    if mtype == TMessageType.EXCEPTION:
804 
      x = TApplicationException()
805 
      x.read(self._iprot)
806 
      self._iprot.readMessageEnd()
807 
      raise x
808 
    result = getUserByEmail_result()
809 
    result.read(self._iprot)
810 
    self._iprot.readMessageEnd()
3431 rajveer 811 
    if result.success is not None:
1491 vikas 812 
      return result.success
3431 rajveer 813 
    if result.ucex is not None:
1491 vikas 814 
      raise result.ucex
815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
816 
 
3032 mandeep.dh 817 
  def getUserByMobileNumber(self, mobileNumber):
818 
    """
819 
    Parameters:
820 
     - mobileNumber
821 
    """
822 
    self.send_getUserByMobileNumber(mobileNumber)
823 
    return self.recv_getUserByMobileNumber()
824 
 
825 
  def send_getUserByMobileNumber(self, mobileNumber):
826 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
827 
    args = getUserByMobileNumber_args()
828 
    args.mobileNumber = mobileNumber
829 
    args.write(self._oprot)
830 
    self._oprot.writeMessageEnd()
831 
    self._oprot.trans.flush()
832 
 
833 
  def recv_getUserByMobileNumber(self, ):
834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
835 
    if mtype == TMessageType.EXCEPTION:
836 
      x = TApplicationException()
837 
      x.read(self._iprot)
838 
      self._iprot.readMessageEnd()
839 
      raise x
840 
    result = getUserByMobileNumber_result()
841 
    result.read(self._iprot)
842 
    self._iprot.readMessageEnd()
3431 rajveer 843 
    if result.success is not None:
3032 mandeep.dh 844 
      return result.success
3431 rajveer 845 
    if result.ucex is not None:
3032 mandeep.dh 846 
      raise result.ucex
847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
848 
 
559 chandransh 849 
  def createUser(self, user):
94 ashish 850 
    """
851 
    Parameters:
559 chandransh 852 
     - user
94 ashish 853 
    """
559 chandransh 854 
    self.send_createUser(user)
855 
    return self.recv_createUser()
94 ashish 856 
 
559 chandransh 857 
  def send_createUser(self, user):
858 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
859 
    args = createUser_args()
860 
    args.user = user
94 ashish 861 
    args.write(self._oprot)
862 
    self._oprot.writeMessageEnd()
863 
    self._oprot.trans.flush()
864 
 
559 chandransh 865 
  def recv_createUser(self, ):
94 ashish 866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
867 
    if mtype == TMessageType.EXCEPTION:
868 
      x = TApplicationException()
869 
      x.read(self._iprot)
870 
      self._iprot.readMessageEnd()
871 
      raise x
559 chandransh 872 
    result = createUser_result()
94 ashish 873 
    result.read(self._iprot)
874 
    self._iprot.readMessageEnd()
3431 rajveer 875 
    if result.success is not None:
94 ashish 876 
      return result.success
3431 rajveer 877 
    if result.ucex is not None:
559 chandransh 878 
      raise result.ucex
879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 880 
 
559 chandransh 881 
  def updateUser(self, user):
94 ashish 882 
    """
883 
    Parameters:
559 chandransh 884 
     - user
94 ashish 885 
    """
559 chandransh 886 
    self.send_updateUser(user)
887 
    return self.recv_updateUser()
94 ashish 888 
 
559 chandransh 889 
  def send_updateUser(self, user):
890 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
891 
    args = updateUser_args()
892 
    args.user = user
94 ashish 893 
    args.write(self._oprot)
894 
    self._oprot.writeMessageEnd()
895 
    self._oprot.trans.flush()
896 
 
559 chandransh 897 
  def recv_updateUser(self, ):
94 ashish 898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
899 
    if mtype == TMessageType.EXCEPTION:
900 
      x = TApplicationException()
901 
      x.read(self._iprot)
902 
      self._iprot.readMessageEnd()
903 
      raise x
559 chandransh 904 
    result = updateUser_result()
94 ashish 905 
    result.read(self._iprot)
906 
    self._iprot.readMessageEnd()
3431 rajveer 907 
    if result.success is not None:
94 ashish 908 
      return result.success
3431 rajveer 909 
    if result.ucex is not None:
559 chandransh 910 
      raise result.ucex
911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 912 
 
559 chandransh 913 
  def authenticateUser(self, email, password):
94 ashish 914 
    """
915 
    Parameters:
916 
     - email
917 
     - password
918 
    """
559 chandransh 919 
    self.send_authenticateUser(email, password)
122 ashish 920 
    return self.recv_authenticateUser()
921 
 
559 chandransh 922 
  def send_authenticateUser(self, email, password):
122 ashish 923 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
924 
    args = authenticateUser_args()
559 chandransh 925 
    args.email = email
122 ashish 926 
    args.password = password
927 
    args.write(self._oprot)
928 
    self._oprot.writeMessageEnd()
929 
    self._oprot.trans.flush()
930 
 
931 
  def recv_authenticateUser(self, ):
932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
933 
    if mtype == TMessageType.EXCEPTION:
934 
      x = TApplicationException()
935 
      x.read(self._iprot)
936 
      self._iprot.readMessageEnd()
937 
      raise x
938 
    result = authenticateUser_result()
939 
    result.read(self._iprot)
940 
    self._iprot.readMessageEnd()
3431 rajveer 941 
    if result.success is not None:
122 ashish 942 
      return result.success
3431 rajveer 943 
    if result.auex is not None:
559 chandransh 944 
      raise result.auex
122 ashish 945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
946 
 
94 ashish 947 
  def userExists(self, email):
948 
    """
949 
    Parameters:
950 
     - email
951 
    """
952 
    self.send_userExists(email)
953 
    return self.recv_userExists()
954 
 
955 
  def send_userExists(self, email):
956 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
957 
    args = userExists_args()
958 
    args.email = email
959 
    args.write(self._oprot)
960 
    self._oprot.writeMessageEnd()
961 
    self._oprot.trans.flush()
962 
 
963 
  def recv_userExists(self, ):
964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
965 
    if mtype == TMessageType.EXCEPTION:
966 
      x = TApplicationException()
967 
      x.read(self._iprot)
968 
      self._iprot.readMessageEnd()
969 
      raise x
970 
    result = userExists_result()
971 
    result.read(self._iprot)
972 
    self._iprot.readMessageEnd()
3431 rajveer 973 
    if result.success is not None:
94 ashish 974 
      return result.success
3431 rajveer 975 
    if result.ucx is not None:
94 ashish 976 
      raise result.ucx
977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
978 
 
567 rajveer 979 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 980 
    """
981 
    Parameters:
982 
     - userId
983 
     - address
513 rajveer 984 
     - setDefault
94 ashish 985 
    """
567 rajveer 986 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 987 
    return self.recv_addAddressForUser()
988 
 
567 rajveer 989 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 990 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
991 
    args = addAddressForUser_args()
559 chandransh 992 
    args.userId = userId
94 ashish 993 
    args.address = address
513 rajveer 994 
    args.setDefault = setDefault
94 ashish 995 
    args.write(self._oprot)
996 
    self._oprot.writeMessageEnd()
997 
    self._oprot.trans.flush()
998 
 
999 
  def recv_addAddressForUser(self, ):
1000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1001 
    if mtype == TMessageType.EXCEPTION:
1002 
      x = TApplicationException()
1003 
      x.read(self._iprot)
1004 
      self._iprot.readMessageEnd()
1005 
      raise x
1006 
    result = addAddressForUser_result()
1007 
    result.read(self._iprot)
1008 
    self._iprot.readMessageEnd()
3431 rajveer 1009 
    if result.success is not None:
94 ashish 1010 
      return result.success
3431 rajveer 1011 
    if result.ucx is not None:
94 ashish 1012 
      raise result.ucx
1013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1014 
 
1015 
  def removeAddressForUser(self, userid, addressId):
1016 
    """
1017 
    Parameters:
1018 
     - userid
1019 
     - addressId
1020 
    """
1021 
    self.send_removeAddressForUser(userid, addressId)
1022 
    return self.recv_removeAddressForUser()
1023 
 
1024 
  def send_removeAddressForUser(self, userid, addressId):
1025 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1026 
    args = removeAddressForUser_args()
1027 
    args.userid = userid
1028 
    args.addressId = addressId
1029 
    args.write(self._oprot)
1030 
    self._oprot.writeMessageEnd()
1031 
    self._oprot.trans.flush()
1032 
 
1033 
  def recv_removeAddressForUser(self, ):
1034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1035 
    if mtype == TMessageType.EXCEPTION:
1036 
      x = TApplicationException()
1037 
      x.read(self._iprot)
1038 
      self._iprot.readMessageEnd()
1039 
      raise x
1040 
    result = removeAddressForUser_result()
1041 
    result.read(self._iprot)
1042 
    self._iprot.readMessageEnd()
3431 rajveer 1043 
    if result.success is not None:
94 ashish 1044 
      return result.success
3431 rajveer 1045 
    if result.ucx is not None:
94 ashish 1046 
      raise result.ucx
1047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1048 
 
1049 
  def setUserAsLoggedIn(self, userId, timestamp):
1050 
    """
1051 
    Parameters:
1052 
     - userId
1053 
     - timestamp
1054 
    """
1055 
    self.send_setUserAsLoggedIn(userId, timestamp)
1056 
    return self.recv_setUserAsLoggedIn()
1057 
 
1058 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1059 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1060 
    args = setUserAsLoggedIn_args()
1061 
    args.userId = userId
1062 
    args.timestamp = timestamp
1063 
    args.write(self._oprot)
1064 
    self._oprot.writeMessageEnd()
1065 
    self._oprot.trans.flush()
1066 
 
1067 
  def recv_setUserAsLoggedIn(self, ):
1068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1069 
    if mtype == TMessageType.EXCEPTION:
1070 
      x = TApplicationException()
1071 
      x.read(self._iprot)
1072 
      self._iprot.readMessageEnd()
1073 
      raise x
1074 
    result = setUserAsLoggedIn_result()
1075 
    result.read(self._iprot)
1076 
    self._iprot.readMessageEnd()
3431 rajveer 1077 
    if result.success is not None:
94 ashish 1078 
      return result.success
3431 rajveer 1079 
    if result.ucx is not None:
94 ashish 1080 
      raise result.ucx
1081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1082 
 
1083 
  def setUserAsLoggedOut(self, userid, timestamp):
1084 
    """
1085 
    Parameters:
1086 
     - userid
1087 
     - timestamp
1088 
    """
1089 
    self.send_setUserAsLoggedOut(userid, timestamp)
1090 
    return self.recv_setUserAsLoggedOut()
1091 
 
1092 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1093 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1094 
    args = setUserAsLoggedOut_args()
1095 
    args.userid = userid
1096 
    args.timestamp = timestamp
1097 
    args.write(self._oprot)
1098 
    self._oprot.writeMessageEnd()
1099 
    self._oprot.trans.flush()
1100 
 
1101 
  def recv_setUserAsLoggedOut(self, ):
1102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1103 
    if mtype == TMessageType.EXCEPTION:
1104 
      x = TApplicationException()
1105 
      x.read(self._iprot)
1106 
      self._iprot.readMessageEnd()
1107 
      raise x
1108 
    result = setUserAsLoggedOut_result()
1109 
    result.read(self._iprot)
1110 
    self._iprot.readMessageEnd()
3431 rajveer 1111 
    if result.success is not None:
94 ashish 1112 
      return result.success
3431 rajveer 1113 
    if result.ucx is not None:
94 ashish 1114 
      raise result.ucx
1115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1116 
 
504 rajveer 1117 
  def setDefaultAddress(self, userid, addressId):
1118 
    """
1119 
    Parameters:
1120 
     - userid
1121 
     - addressId
1122 
    """
1123 
    self.send_setDefaultAddress(userid, addressId)
1124 
    return self.recv_setDefaultAddress()
1125 
 
1126 
  def send_setDefaultAddress(self, userid, addressId):
1127 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1128 
    args = setDefaultAddress_args()
1129 
    args.userid = userid
1130 
    args.addressId = addressId
1131 
    args.write(self._oprot)
1132 
    self._oprot.writeMessageEnd()
1133 
    self._oprot.trans.flush()
1134 
 
1135 
  def recv_setDefaultAddress(self, ):
1136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1137 
    if mtype == TMessageType.EXCEPTION:
1138 
      x = TApplicationException()
1139 
      x.read(self._iprot)
1140 
      self._iprot.readMessageEnd()
1141 
      raise x
1142 
    result = setDefaultAddress_result()
1143 
    result.read(self._iprot)
1144 
    self._iprot.readMessageEnd()
3431 rajveer 1145 
    if result.success is not None:
504 rajveer 1146 
      return result.success
3431 rajveer 1147 
    if result.ucx is not None:
504 rajveer 1148 
      raise result.ucx
1149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1150 
 
594 rajveer 1151 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1152 
    """
1153 
    Parameters:
1154 
     - userid
594 rajveer 1155 
     - oldPassword
1156 
     - newPassword
94 ashish 1157 
    """
594 rajveer 1158 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1159 
    return self.recv_updatePassword()
1160 
 
594 rajveer 1161 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1162 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1163 
    args = updatePassword_args()
1164 
    args.userid = userid
594 rajveer 1165 
    args.oldPassword = oldPassword
1166 
    args.newPassword = newPassword
94 ashish 1167 
    args.write(self._oprot)
1168 
    self._oprot.writeMessageEnd()
1169 
    self._oprot.trans.flush()
1170 
 
1171 
  def recv_updatePassword(self, ):
1172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1173 
    if mtype == TMessageType.EXCEPTION:
1174 
      x = TApplicationException()
1175 
      x.read(self._iprot)
1176 
      self._iprot.readMessageEnd()
1177 
      raise x
1178 
    result = updatePassword_result()
1179 
    result.read(self._iprot)
1180 
    self._iprot.readMessageEnd()
3431 rajveer 1181 
    if result.success is not None:
94 ashish 1182 
      return result.success
3431 rajveer 1183 
    if result.ucx is not None:
94 ashish 1184 
      raise result.ucx
1185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1186 
 
884 rajveer 1187 
  def forgotPassword(self, email, newPassword):
581 rajveer 1188 
    """
1189 
    Parameters:
1190 
     - email
884 rajveer 1191 
     - newPassword
581 rajveer 1192 
    """
884 rajveer 1193 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1194 
    return self.recv_forgotPassword()
1195 
 
884 rajveer 1196 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1197 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1198 
    args = forgotPassword_args()
1199 
    args.email = email
884 rajveer 1200 
    args.newPassword = newPassword
581 rajveer 1201 
    args.write(self._oprot)
1202 
    self._oprot.writeMessageEnd()
1203 
    self._oprot.trans.flush()
1204 
 
1205 
  def recv_forgotPassword(self, ):
1206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1207 
    if mtype == TMessageType.EXCEPTION:
1208 
      x = TApplicationException()
1209 
      x.read(self._iprot)
1210 
      self._iprot.readMessageEnd()
1211 
      raise x
1212 
    result = forgotPassword_result()
1213 
    result.read(self._iprot)
1214 
    self._iprot.readMessageEnd()
3431 rajveer 1215 
    if result.success is not None:
581 rajveer 1216 
      return result.success
3431 rajveer 1217 
    if result.ucx is not None:
581 rajveer 1218 
      raise result.ucx
1219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1220 
 
594 rajveer 1221 
  def getAllAddressesForUser(self, userId):
1222 
    """
1223 
    Parameters:
1224 
     - userId
1225 
    """
1226 
    self.send_getAllAddressesForUser(userId)
1227 
    return self.recv_getAllAddressesForUser()
1228 
 
1229 
  def send_getAllAddressesForUser(self, userId):
1230 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1231 
    args = getAllAddressesForUser_args()
1232 
    args.userId = userId
1233 
    args.write(self._oprot)
1234 
    self._oprot.writeMessageEnd()
1235 
    self._oprot.trans.flush()
1236 
 
1237 
  def recv_getAllAddressesForUser(self, ):
1238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1239 
    if mtype == TMessageType.EXCEPTION:
1240 
      x = TApplicationException()
1241 
      x.read(self._iprot)
1242 
      self._iprot.readMessageEnd()
1243 
      raise x
1244 
    result = getAllAddressesForUser_result()
1245 
    result.read(self._iprot)
1246 
    self._iprot.readMessageEnd()
3431 rajveer 1247 
    if result.success is not None:
594 rajveer 1248 
      return result.success
3431 rajveer 1249 
    if result.ucx is not None:
594 rajveer 1250 
      raise result.ucx
1251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1252 
 
1894 vikas 1253 
  def getAddressById(self, addressId):
1254 
    """
1255 
    Parameters:
1256 
     - addressId
1257 
    """
1258 
    self.send_getAddressById(addressId)
1259 
    return self.recv_getAddressById()
1260 
 
1261 
  def send_getAddressById(self, addressId):
1262 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1263 
    args = getAddressById_args()
1264 
    args.addressId = addressId
1265 
    args.write(self._oprot)
1266 
    self._oprot.writeMessageEnd()
1267 
    self._oprot.trans.flush()
1268 
 
1269 
  def recv_getAddressById(self, ):
1270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1271 
    if mtype == TMessageType.EXCEPTION:
1272 
      x = TApplicationException()
1273 
      x.read(self._iprot)
1274 
      self._iprot.readMessageEnd()
1275 
      raise x
1276 
    result = getAddressById_result()
1277 
    result.read(self._iprot)
1278 
    self._iprot.readMessageEnd()
3431 rajveer 1279 
    if result.success is not None:
1894 vikas 1280 
      return result.success
3431 rajveer 1281 
    if result.ucx is not None:
1894 vikas 1282 
      raise result.ucx
1283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1284 
 
594 rajveer 1285 
  def getDefaultAddressId(self, userId):
1286 
    """
1287 
    Parameters:
1288 
     - userId
1289 
    """
1290 
    self.send_getDefaultAddressId(userId)
1291 
    return self.recv_getDefaultAddressId()
1292 
 
1293 
  def send_getDefaultAddressId(self, userId):
1294 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1295 
    args = getDefaultAddressId_args()
1296 
    args.userId = userId
1297 
    args.write(self._oprot)
1298 
    self._oprot.writeMessageEnd()
1299 
    self._oprot.trans.flush()
1300 
 
1301 
  def recv_getDefaultAddressId(self, ):
1302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1303 
    if mtype == TMessageType.EXCEPTION:
1304 
      x = TApplicationException()
1305 
      x.read(self._iprot)
1306 
      self._iprot.readMessageEnd()
1307 
      raise x
1308 
    result = getDefaultAddressId_result()
1309 
    result.read(self._iprot)
1310 
    self._iprot.readMessageEnd()
3431 rajveer 1311 
    if result.success is not None:
594 rajveer 1312 
      return result.success
3431 rajveer 1313 
    if result.ucx is not None:
594 rajveer 1314 
      raise result.ucx
1315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1316 
 
785 rajveer 1317 
  def getDefaultPincode(self, userId):
1318 
    """
1319 
    Parameters:
1320 
     - userId
1321 
    """
1322 
    self.send_getDefaultPincode(userId)
1323 
    return self.recv_getDefaultPincode()
1324 
 
1325 
  def send_getDefaultPincode(self, userId):
1326 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1327 
    args = getDefaultPincode_args()
1328 
    args.userId = userId
1329 
    args.write(self._oprot)
1330 
    self._oprot.writeMessageEnd()
1331 
    self._oprot.trans.flush()
1332 
 
1333 
  def recv_getDefaultPincode(self, ):
1334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1335 
    if mtype == TMessageType.EXCEPTION:
1336 
      x = TApplicationException()
1337 
      x.read(self._iprot)
1338 
      self._iprot.readMessageEnd()
1339 
      raise x
1340 
    result = getDefaultPincode_result()
1341 
    result.read(self._iprot)
1342 
    self._iprot.readMessageEnd()
3431 rajveer 1343 
    if result.success is not None:
785 rajveer 1344 
      return result.success
3431 rajveer 1345 
    if result.ucx is not None:
785 rajveer 1346 
      raise result.ucx
1347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1348 
 
1274 varun.gupt 1349 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1350 
    """
1351 
    Parameters:
1352 
     - userId
1353 
     - replyTo
1354 
     - communicationType
1355 
     - orderId
1356 
     - airwaybillNo
1357 
     - productName
1358 
     - subject
1359 
     - message
1360 
    """
1361 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1362 
    return self.recv_saveUserCommunication()
1363 
 
1364 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1365 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1366 
    args = saveUserCommunication_args()
1367 
    args.userId = userId
1368 
    args.replyTo = replyTo
1369 
    args.communicationType = communicationType
1370 
    args.orderId = orderId
1371 
    args.airwaybillNo = airwaybillNo
1372 
    args.productName = productName
1373 
    args.subject = subject
1374 
    args.message = message
1375 
    args.write(self._oprot)
1376 
    self._oprot.writeMessageEnd()
1377 
    self._oprot.trans.flush()
1378 
 
1379 
  def recv_saveUserCommunication(self, ):
1380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1381 
    if mtype == TMessageType.EXCEPTION:
1382 
      x = TApplicationException()
1383 
      x.read(self._iprot)
1384 
      self._iprot.readMessageEnd()
1385 
      raise x
1386 
    result = saveUserCommunication_result()
1387 
    result.read(self._iprot)
1388 
    self._iprot.readMessageEnd()
3431 rajveer 1389 
    if result.success is not None:
1274 varun.gupt 1390 
      return result.success
3431 rajveer 1391 
    if result.ucx is not None:
1274 varun.gupt 1392 
      raise result.ucx
1393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1394 
 
1590 varun.gupt 1395 
  def getUserCommunicationById(self, id):
1396 
    """
1397 
    Parameters:
1398 
     - id
1399 
    """
1400 
    self.send_getUserCommunicationById(id)
1401 
    return self.recv_getUserCommunicationById()
1402 
 
1403 
  def send_getUserCommunicationById(self, id):
1404 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1405 
    args = getUserCommunicationById_args()
1406 
    args.id = id
1407 
    args.write(self._oprot)
1408 
    self._oprot.writeMessageEnd()
1409 
    self._oprot.trans.flush()
1410 
 
1411 
  def recv_getUserCommunicationById(self, ):
1412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1413 
    if mtype == TMessageType.EXCEPTION:
1414 
      x = TApplicationException()
1415 
      x.read(self._iprot)
1416 
      self._iprot.readMessageEnd()
1417 
      raise x
1418 
    result = getUserCommunicationById_result()
1419 
    result.read(self._iprot)
1420 
    self._iprot.readMessageEnd()
3431 rajveer 1421 
    if result.success is not None:
1590 varun.gupt 1422 
      return result.success
3431 rajveer 1423 
    if result.ucx is not None:
1590 varun.gupt 1424 
      raise result.ucx
1425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1426 
 
1427 
  def getUserCommunicationByUser(self, userId):
1428 
    """
1429 
    Parameters:
1430 
     - userId
1431 
    """
1432 
    self.send_getUserCommunicationByUser(userId)
1433 
    return self.recv_getUserCommunicationByUser()
1434 
 
1435 
  def send_getUserCommunicationByUser(self, userId):
1436 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1437 
    args = getUserCommunicationByUser_args()
1438 
    args.userId = userId
1439 
    args.write(self._oprot)
1440 
    self._oprot.writeMessageEnd()
1441 
    self._oprot.trans.flush()
1442 
 
1443 
  def recv_getUserCommunicationByUser(self, ):
1444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1445 
    if mtype == TMessageType.EXCEPTION:
1446 
      x = TApplicationException()
1447 
      x.read(self._iprot)
1448 
      self._iprot.readMessageEnd()
1449 
      raise x
1450 
    result = getUserCommunicationByUser_result()
1451 
    result.read(self._iprot)
1452 
    self._iprot.readMessageEnd()
3431 rajveer 1453 
    if result.success is not None:
1590 varun.gupt 1454 
      return result.success
3431 rajveer 1455 
    if result.ucx is not None:
1590 varun.gupt 1456 
      raise result.ucx
1457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1458 
 
1459 
  def getAllUserCommunications(self, ):
1460 
    self.send_getAllUserCommunications()
1461 
    return self.recv_getAllUserCommunications()
1462 
 
1463 
  def send_getAllUserCommunications(self, ):
1464 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1465 
    args = getAllUserCommunications_args()
1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_getAllUserCommunications(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = getAllUserCommunications_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
3431 rajveer 1480 
    if result.success is not None:
1590 varun.gupt 1481 
      return result.success
3431 rajveer 1482 
    if result.ucx is not None:
1590 varun.gupt 1483 
      raise result.ucx
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1485 
 
5407 amar.kumar 1486 
  def removeUserCommunication(self, id):
1487 
    """
1488 
    Parameters:
1489 
     - id
1490 
    """
1491 
    self.send_removeUserCommunication(id)
1492 
    self.recv_removeUserCommunication()
1493 
 
1494 
  def send_removeUserCommunication(self, id):
1495 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1496 
    args = removeUserCommunication_args()
1497 
    args.id = id
1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
1502 
  def recv_removeUserCommunication(self, ):
1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
1509 
    result = removeUserCommunication_result()
1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
1512 
    if result.ucx is not None:
1513 
      raise result.ucx
1514 
    return
1515 
 
1859 vikas 1516 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1517 
    """
1518 
    Parameters:
1519 
     - name
1859 vikas 1520 
     - addedOn
1845 vikas 1521 
    """
1859 vikas 1522 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1523 
    return self.recv_createMasterAffiliate()
1524 
 
1859 vikas 1525 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1526 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1527 
    args = createMasterAffiliate_args()
1528 
    args.name = name
1859 vikas 1529 
    args.addedOn = addedOn
1845 vikas 1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_createMasterAffiliate(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = createMasterAffiliate_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
3431 rajveer 1544 
    if result.success is not None:
1845 vikas 1545 
      return result.success
3431 rajveer 1546 
    if result.utx is not None:
1845 vikas 1547 
      raise result.utx
1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1549 
 
1899 vikas 1550 
  def getAllMasterAffiliates(self, ):
1551 
    self.send_getAllMasterAffiliates()
1552 
    return self.recv_getAllMasterAffiliates()
1553 
 
1554 
  def send_getAllMasterAffiliates(self, ):
1555 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1556 
    args = getAllMasterAffiliates_args()
1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_getAllMasterAffiliates(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = getAllMasterAffiliates_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
3431 rajveer 1571 
    if result.success is not None:
1899 vikas 1572 
      return result.success
3431 rajveer 1573 
    if result.utx is not None:
1899 vikas 1574 
      raise result.utx
1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1576 
 
1845 vikas 1577 
  def getMasterAffiliateById(self, id):
1578 
    """
1579 
    Parameters:
1580 
     - id
1581 
    """
1582 
    self.send_getMasterAffiliateById(id)
1583 
    return self.recv_getMasterAffiliateById()
1584 
 
1585 
  def send_getMasterAffiliateById(self, id):
1586 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1587 
    args = getMasterAffiliateById_args()
1588 
    args.id = id
1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
1593 
  def recv_getMasterAffiliateById(self, ):
1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
1600 
    result = getMasterAffiliateById_result()
1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
3431 rajveer 1603 
    if result.success is not None:
1845 vikas 1604 
      return result.success
3431 rajveer 1605 
    if result.utx is not None:
1845 vikas 1606 
      raise result.utx
1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1608 
 
1609 
  def getMasterAffiliateByName(self, name):
1610 
    """
1611 
    Parameters:
1612 
     - name
1613 
    """
1614 
    self.send_getMasterAffiliateByName(name)
1615 
    return self.recv_getMasterAffiliateByName()
1616 
 
1617 
  def send_getMasterAffiliateByName(self, name):
1618 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1619 
    args = getMasterAffiliateByName_args()
1620 
    args.name = name
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getMasterAffiliateByName(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getMasterAffiliateByName_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
3431 rajveer 1635 
    if result.success is not None:
1845 vikas 1636 
      return result.success
3431 rajveer 1637 
    if result.utx is not None:
1845 vikas 1638 
      raise result.utx
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1640 
 
1859 vikas 1641 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1642 
    """
1643 
    Parameters:
1644 
     - name
1645 
     - url
1646 
     - masterAffiliateId
1859 vikas 1647 
     - addedOn
1845 vikas 1648 
    """
1859 vikas 1649 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1650 
    return self.recv_createAffiliate()
1651 
 
1859 vikas 1652 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1653 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1654 
    args = createAffiliate_args()
1655 
    args.name = name
1656 
    args.url = url
1657 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1658 
    args.addedOn = addedOn
1845 vikas 1659 
    args.write(self._oprot)
1660 
    self._oprot.writeMessageEnd()
1661 
    self._oprot.trans.flush()
1662 
 
1663 
  def recv_createAffiliate(self, ):
1664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1665 
    if mtype == TMessageType.EXCEPTION:
1666 
      x = TApplicationException()
1667 
      x.read(self._iprot)
1668 
      self._iprot.readMessageEnd()
1669 
      raise x
1670 
    result = createAffiliate_result()
1671 
    result.read(self._iprot)
1672 
    self._iprot.readMessageEnd()
3431 rajveer 1673 
    if result.success is not None:
1845 vikas 1674 
      return result.success
3431 rajveer 1675 
    if result.utx is not None:
1845 vikas 1676 
      raise result.utx
1677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1678 
 
1679 
  def getAffiliateById(self, id):
1680 
    """
1681 
    Parameters:
1682 
     - id
1683 
    """
1684 
    self.send_getAffiliateById(id)
1685 
    return self.recv_getAffiliateById()
1686 
 
1687 
  def send_getAffiliateById(self, id):
1688 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1689 
    args = getAffiliateById_args()
1690 
    args.id = id
1691 
    args.write(self._oprot)
1692 
    self._oprot.writeMessageEnd()
1693 
    self._oprot.trans.flush()
1694 
 
1695 
  def recv_getAffiliateById(self, ):
1696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1697 
    if mtype == TMessageType.EXCEPTION:
1698 
      x = TApplicationException()
1699 
      x.read(self._iprot)
1700 
      self._iprot.readMessageEnd()
1701 
      raise x
1702 
    result = getAffiliateById_result()
1703 
    result.read(self._iprot)
1704 
    self._iprot.readMessageEnd()
3431 rajveer 1705 
    if result.success is not None:
1845 vikas 1706 
      return result.success
3431 rajveer 1707 
    if result.utx is not None:
1845 vikas 1708 
      raise result.utx
1709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1710 
 
1711 
  def getAffiliateByName(self, name):
1712 
    """
1713 
    Parameters:
1714 
     - name
1715 
    """
1716 
    self.send_getAffiliateByName(name)
1717 
    return self.recv_getAffiliateByName()
1718 
 
1719 
  def send_getAffiliateByName(self, name):
1720 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1721 
    args = getAffiliateByName_args()
1722 
    args.name = name
1723 
    args.write(self._oprot)
1724 
    self._oprot.writeMessageEnd()
1725 
    self._oprot.trans.flush()
1726 
 
1727 
  def recv_getAffiliateByName(self, ):
1728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1729 
    if mtype == TMessageType.EXCEPTION:
1730 
      x = TApplicationException()
1731 
      x.read(self._iprot)
1732 
      self._iprot.readMessageEnd()
1733 
      raise x
1734 
    result = getAffiliateByName_result()
1735 
    result.read(self._iprot)
1736 
    self._iprot.readMessageEnd()
3431 rajveer 1737 
    if result.success is not None:
1845 vikas 1738 
      return result.success
3431 rajveer 1739 
    if result.utx is not None:
1845 vikas 1740 
      raise result.utx
1741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1742 
 
1996 vikas 1743 
  def getTrackerById(self, id):
1845 vikas 1744 
    """
1745 
    Parameters:
1746 
     - id
1747 
    """
1996 vikas 1748 
    self.send_getTrackerById(id)
1845 vikas 1749 
    return self.recv_getTrackerById()
1750 
 
1996 vikas 1751 
  def send_getTrackerById(self, id):
1845 vikas 1752 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1753 
    args = getTrackerById_args()
1996 vikas 1754 
    args.id = id
1845 vikas 1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_getTrackerById(self, ):
1760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1761 
    if mtype == TMessageType.EXCEPTION:
1762 
      x = TApplicationException()
1763 
      x.read(self._iprot)
1764 
      self._iprot.readMessageEnd()
1765 
      raise x
1766 
    result = getTrackerById_result()
1767 
    result.read(self._iprot)
1768 
    self._iprot.readMessageEnd()
3431 rajveer 1769 
    if result.success is not None:
1845 vikas 1770 
      return result.success
3431 rajveer 1771 
    if result.utx is not None:
1845 vikas 1772 
      raise result.utx
1773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1774 
 
1996 vikas 1775 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1776 
    """
1777 
    Parameters:
1996 vikas 1778 
     - id
1845 vikas 1779 
    """
1996 vikas 1780 
    self.send_getAffiliatesByMasterAffiliate(id)
1781 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1782 
 
1996 vikas 1783 
  def send_getAffiliatesByMasterAffiliate(self, id):
1784 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1785 
    args = getAffiliatesByMasterAffiliate_args()
1786 
    args.id = id
1845 vikas 1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1996 vikas 1791 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1793 
    if mtype == TMessageType.EXCEPTION:
1794 
      x = TApplicationException()
1795 
      x.read(self._iprot)
1796 
      self._iprot.readMessageEnd()
1797 
      raise x
1996 vikas 1798 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1799 
    result.read(self._iprot)
1800 
    self._iprot.readMessageEnd()
3431 rajveer 1801 
    if result.success is not None:
1845 vikas 1802 
      return result.success
3431 rajveer 1803 
    if result.utx is not None:
1845 vikas 1804 
      raise result.utx
1996 vikas 1805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1806 
 
1996 vikas 1807 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1808 
    """
1809 
    Parameters:
1996 vikas 1810 
     - affiliateId
1845 vikas 1811 
     - userId
1812 
     - event
1813 
     - url
1814 
     - data
1859 vikas 1815 
     - addedOn
1845 vikas 1816 
    """
1996 vikas 1817 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1818 
    return self.recv_addTrackLog()
1819 
 
1996 vikas 1820 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1821 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1822 
    args = addTrackLog_args()
1996 vikas 1823 
    args.affiliateId = affiliateId
1845 vikas 1824 
    args.userId = userId
1825 
    args.event = event
1826 
    args.url = url
1827 
    args.data = data
1859 vikas 1828 
    args.addedOn = addedOn
1845 vikas 1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
1833 
  def recv_addTrackLog(self, ):
1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
1840 
    result = addTrackLog_result()
1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
3431 rajveer 1843 
    if result.success is not None:
1845 vikas 1844 
      return result.success
3431 rajveer 1845 
    if result.utx is not None:
1845 vikas 1846 
      raise result.utx
1847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1848 
 
1849 
  def getTrackLogById(self, id):
1850 
    """
1851 
    Parameters:
1852 
     - id
1853 
    """
1854 
    self.send_getTrackLogById(id)
1855 
    return self.recv_getTrackLogById()
1856 
 
1857 
  def send_getTrackLogById(self, id):
1858 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1859 
    args = getTrackLogById_args()
1860 
    args.id = id
1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_getTrackLogById(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = getTrackLogById_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
3431 rajveer 1875 
    if result.success is not None:
1845 vikas 1876 
      return result.success
3431 rajveer 1877 
    if result.utx is not None:
1845 vikas 1878 
      raise result.utx
1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1880 
 
3293 vikas 1881 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1882 
    """
1883 
    Parameters:
1996 vikas 1884 
     - affiliateId
3293 vikas 1885 
     - startDate
1886 
     - endDate
1845 vikas 1887 
    """
3293 vikas 1888 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1889 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1890 
 
3293 vikas 1891 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1892 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1893 
    args = getTrackLogsByAffiliate_args()
1894 
    args.affiliateId = affiliateId
3293 vikas 1895 
    args.startDate = startDate
1896 
    args.endDate = endDate
1845 vikas 1897 
    args.write(self._oprot)
1898 
    self._oprot.writeMessageEnd()
1899 
    self._oprot.trans.flush()
1900 
 
1996 vikas 1901 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1903 
    if mtype == TMessageType.EXCEPTION:
1904 
      x = TApplicationException()
1905 
      x.read(self._iprot)
1906 
      self._iprot.readMessageEnd()
1907 
      raise x
1996 vikas 1908 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1909 
    result.read(self._iprot)
1910 
    self._iprot.readMessageEnd()
3431 rajveer 1911 
    if result.success is not None:
1845 vikas 1912 
      return result.success
3431 rajveer 1913 
    if result.utx is not None:
1845 vikas 1914 
      raise result.utx
1996 vikas 1915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1916 
 
1917 
  def getTrackLogsByUser(self, userId):
1918 
    """
1919 
    Parameters:
1920 
     - userId
1921 
    """
1922 
    self.send_getTrackLogsByUser(userId)
1923 
    return self.recv_getTrackLogsByUser()
1924 
 
1925 
  def send_getTrackLogsByUser(self, userId):
1926 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1927 
    args = getTrackLogsByUser_args()
1928 
    args.userId = userId
1929 
    args.write(self._oprot)
1930 
    self._oprot.writeMessageEnd()
1931 
    self._oprot.trans.flush()
1932 
 
1933 
  def recv_getTrackLogsByUser(self, ):
1934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1935 
    if mtype == TMessageType.EXCEPTION:
1936 
      x = TApplicationException()
1937 
      x.read(self._iprot)
1938 
      self._iprot.readMessageEnd()
1939 
      raise x
1940 
    result = getTrackLogsByUser_result()
1941 
    result.read(self._iprot)
1942 
    self._iprot.readMessageEnd()
3431 rajveer 1943 
    if result.success is not None:
1845 vikas 1944 
      return result.success
3431 rajveer 1945 
    if result.utx is not None:
1845 vikas 1946 
      raise result.utx
1947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1948 
 
1996 vikas 1949 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1950 
    """
1951 
    Parameters:
1952 
     - userId
1953 
     - event
1954 
     - url
1955 
    """
1996 vikas 1956 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1957 
    return self.recv_getTrackLogs()
1958 
 
1996 vikas 1959 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1960 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1961 
    args = getTrackLogs_args()
1962 
    args.userId = userId
1963 
    args.event = event
1964 
    args.url = url
1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
1969 
  def recv_getTrackLogs(self, ):
1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
1976 
    result = getTrackLogs_result()
1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
3431 rajveer 1979 
    if result.success is not None:
1845 vikas 1980 
      return result.success
3431 rajveer 1981 
    if result.utx is not None:
1845 vikas 1982 
      raise result.utx
1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1984 
 
559 chandransh 1985 
  def getCurrentCart(self, userId):
94 ashish 1986 
    """
1987 
    Parameters:
559 chandransh 1988 
     - userId
94 ashish 1989 
    """
559 chandransh 1990 
    self.send_getCurrentCart(userId)
1991 
    return self.recv_getCurrentCart()
94 ashish 1992 
 
559 chandransh 1993 
  def send_getCurrentCart(self, userId):
1994 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1995 
    args = getCurrentCart_args()
1996 
    args.userId = userId
94 ashish 1997 
    args.write(self._oprot)
1998 
    self._oprot.writeMessageEnd()
1999 
    self._oprot.trans.flush()
2000 
 
559 chandransh 2001 
  def recv_getCurrentCart(self, ):
94 ashish 2002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2003 
    if mtype == TMessageType.EXCEPTION:
2004 
      x = TApplicationException()
2005 
      x.read(self._iprot)
2006 
      self._iprot.readMessageEnd()
2007 
      raise x
559 chandransh 2008 
    result = getCurrentCart_result()
94 ashish 2009 
    result.read(self._iprot)
2010 
    self._iprot.readMessageEnd()
3431 rajveer 2011 
    if result.success is not None:
94 ashish 2012 
      return result.success
3431 rajveer 2013 
    if result.scx is not None:
559 chandransh 2014 
      raise result.scx
2015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2016 
 
559 chandransh 2017 
  def getCart(self, cartId):
94 ashish 2018 
    """
2019 
    Parameters:
559 chandransh 2020 
     - cartId
94 ashish 2021 
    """
559 chandransh 2022 
    self.send_getCart(cartId)
2023 
    return self.recv_getCart()
94 ashish 2024 
 
559 chandransh 2025 
  def send_getCart(self, cartId):
2026 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2027 
    args = getCart_args()
2028 
    args.cartId = cartId
94 ashish 2029 
    args.write(self._oprot)
2030 
    self._oprot.writeMessageEnd()
2031 
    self._oprot.trans.flush()
2032 
 
559 chandransh 2033 
  def recv_getCart(self, ):
94 ashish 2034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2035 
    if mtype == TMessageType.EXCEPTION:
2036 
      x = TApplicationException()
2037 
      x.read(self._iprot)
2038 
      self._iprot.readMessageEnd()
2039 
      raise x
559 chandransh 2040 
    result = getCart_result()
94 ashish 2041 
    result.read(self._iprot)
2042 
    self._iprot.readMessageEnd()
3431 rajveer 2043 
    if result.success is not None:
94 ashish 2044 
      return result.success
3431 rajveer 2045 
    if result.scx is not None:
559 chandransh 2046 
      raise result.scx
2047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2048 
 
559 chandransh 2049 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2050 
    """
2051 
    Parameters:
559 chandransh 2052 
     - from_time
2053 
     - to_time
2054 
     - status
94 ashish 2055 
    """
559 chandransh 2056 
    self.send_getCartsByTime(from_time, to_time, status)
2057 
    return self.recv_getCartsByTime()
94 ashish 2058 
 
559 chandransh 2059 
  def send_getCartsByTime(self, from_time, to_time, status):
2060 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2061 
    args = getCartsByTime_args()
2062 
    args.from_time = from_time
2063 
    args.to_time = to_time
2064 
    args.status = status
94 ashish 2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
559 chandransh 2069 
  def recv_getCartsByTime(self, ):
94 ashish 2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
559 chandransh 2076 
    result = getCartsByTime_result()
94 ashish 2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
3431 rajveer 2079 
    if result.success is not None:
94 ashish 2080 
      return result.success
3431 rajveer 2081 
    if result.scx is not None:
559 chandransh 2082 
      raise result.scx
2083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2084 
 
3557 rajveer 2085 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2086 
    """
2087 
    Parameters:
2088 
     - cartId
2089 
     - itemId
2090 
     - quantity
3557 rajveer 2091 
     - sourceId
559 chandransh 2092 
    """
3557 rajveer 2093 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2094 
    return self.recv_addItemToCart()
559 chandransh 2095 
 
3557 rajveer 2096 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2097 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2098 
    args = addItemToCart_args()
2099 
    args.cartId = cartId
2100 
    args.itemId = itemId
2101 
    args.quantity = quantity
3557 rajveer 2102 
    args.sourceId = sourceId
559 chandransh 2103 
    args.write(self._oprot)
2104 
    self._oprot.writeMessageEnd()
2105 
    self._oprot.trans.flush()
2106 
 
2107 
  def recv_addItemToCart(self, ):
2108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2109 
    if mtype == TMessageType.EXCEPTION:
2110 
      x = TApplicationException()
2111 
      x.read(self._iprot)
2112 
      self._iprot.readMessageEnd()
2113 
      raise x
2114 
    result = addItemToCart_result()
2115 
    result.read(self._iprot)
2116 
    self._iprot.readMessageEnd()
3431 rajveer 2117 
    if result.success is not None:
2035 rajveer 2118 
      return result.success
3431 rajveer 2119 
    if result.scx is not None:
559 chandransh 2120 
      raise result.scx
2035 rajveer 2121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2122 
 
2123 
  def deleteItemFromCart(self, cartId, itemId):
2124 
    """
2125 
    Parameters:
2126 
     - cartId
2127 
     - itemId
2128 
    """
2129 
    self.send_deleteItemFromCart(cartId, itemId)
2130 
    self.recv_deleteItemFromCart()
2131 
 
2132 
  def send_deleteItemFromCart(self, cartId, itemId):
2133 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2134 
    args = deleteItemFromCart_args()
2135 
    args.cartId = cartId
2136 
    args.itemId = itemId
2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
2141 
  def recv_deleteItemFromCart(self, ):
2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
2148 
    result = deleteItemFromCart_result()
2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
3431 rajveer 2151 
    if result.scx is not None:
559 chandransh 2152 
      raise result.scx
2153 
    return
2154 
 
2155 
  def addAddressToCart(self, cartId, addressId):
2156 
    """
2157 
    Parameters:
2158 
     - cartId
2159 
     - addressId
2160 
    """
2161 
    self.send_addAddressToCart(cartId, addressId)
2162 
    self.recv_addAddressToCart()
2163 
 
2164 
  def send_addAddressToCart(self, cartId, addressId):
2165 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2166 
    args = addAddressToCart_args()
2167 
    args.cartId = cartId
2168 
    args.addressId = addressId
2169 
    args.write(self._oprot)
2170 
    self._oprot.writeMessageEnd()
2171 
    self._oprot.trans.flush()
2172 
 
2173 
  def recv_addAddressToCart(self, ):
2174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2175 
    if mtype == TMessageType.EXCEPTION:
2176 
      x = TApplicationException()
2177 
      x.read(self._iprot)
2178 
      self._iprot.readMessageEnd()
2179 
      raise x
2180 
    result = addAddressToCart_result()
2181 
    result.read(self._iprot)
2182 
    self._iprot.readMessageEnd()
3431 rajveer 2183 
    if result.scx is not None:
575 chandransh 2184 
      raise result.scx
559 chandransh 2185 
    return
2186 
 
5553 rajveer 2187 
  def addStoreToCart(self, cartId, storeId):
2188 
    """
2189 
    Parameters:
2190 
     - cartId
2191 
     - storeId
2192 
    """
2193 
    self.send_addStoreToCart(cartId, storeId)
2194 
    self.recv_addStoreToCart()
2195 
 
2196 
  def send_addStoreToCart(self, cartId, storeId):
2197 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2198 
    args = addStoreToCart_args()
2199 
    args.cartId = cartId
2200 
    args.storeId = storeId
2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
2205 
  def recv_addStoreToCart(self, ):
2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
2212 
    result = addStoreToCart_result()
2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
2215 
    if result.scx is not None:
2216 
      raise result.scx
2217 
    return
2218 
 
6922 anupam.sin 2219 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2220 
    """
2221 
    Parameters:
6922 anupam.sin 2222 
     - cart
1976 varun.gupt 2223 
     - couponCode
2224 
    """
6922 anupam.sin 2225 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2226 
    self.recv_applyCouponToCart()
2227 
 
6922 anupam.sin 2228 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2229 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2230 
    args = applyCouponToCart_args()
6922 anupam.sin 2231 
    args.cart = cart
1976 varun.gupt 2232 
    args.couponCode = couponCode
2233 
    args.write(self._oprot)
2234 
    self._oprot.writeMessageEnd()
2235 
    self._oprot.trans.flush()
2236 
 
2237 
  def recv_applyCouponToCart(self, ):
2238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2239 
    if mtype == TMessageType.EXCEPTION:
2240 
      x = TApplicationException()
2241 
      x.read(self._iprot)
2242 
      self._iprot.readMessageEnd()
2243 
      raise x
2244 
    result = applyCouponToCart_result()
2245 
    result.read(self._iprot)
2246 
    self._iprot.readMessageEnd()
3431 rajveer 2247 
    if result.scx is not None:
1976 varun.gupt 2248 
      raise result.scx
2249 
    return
2250 
 
2251 
  def removeCoupon(self, cartId):
2252 
    """
2253 
    Parameters:
2254 
     - cartId
2255 
    """
2256 
    self.send_removeCoupon(cartId)
2257 
    self.recv_removeCoupon()
2258 
 
2259 
  def send_removeCoupon(self, cartId):
2260 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2261 
    args = removeCoupon_args()
2262 
    args.cartId = cartId
2263 
    args.write(self._oprot)
2264 
    self._oprot.writeMessageEnd()
2265 
    self._oprot.trans.flush()
2266 
 
2267 
  def recv_removeCoupon(self, ):
2268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2269 
    if mtype == TMessageType.EXCEPTION:
2270 
      x = TApplicationException()
2271 
      x.read(self._iprot)
2272 
      self._iprot.readMessageEnd()
2273 
      raise x
2274 
    result = removeCoupon_result()
2275 
    result.read(self._iprot)
2276 
    self._iprot.readMessageEnd()
3431 rajveer 2277 
    if result.scx is not None:
1976 varun.gupt 2278 
      raise result.scx
2279 
    return
2280 
 
3554 varun.gupt 2281 
  def deleteDiscountsFromCart(self, cartId):
2282 
    """
2283 
    Deletes all the discounts associated with the cart
2284 
 
2285 
    Parameters:
2286 
     - cartId
2287 
    """
2288 
    self.send_deleteDiscountsFromCart(cartId)
2289 
    self.recv_deleteDiscountsFromCart()
2290 
 
2291 
  def send_deleteDiscountsFromCart(self, cartId):
2292 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2293 
    args = deleteDiscountsFromCart_args()
2294 
    args.cartId = cartId
2295 
    args.write(self._oprot)
2296 
    self._oprot.writeMessageEnd()
2297 
    self._oprot.trans.flush()
2298 
 
2299 
  def recv_deleteDiscountsFromCart(self, ):
2300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2301 
    if mtype == TMessageType.EXCEPTION:
2302 
      x = TApplicationException()
2303 
      x.read(self._iprot)
2304 
      self._iprot.readMessageEnd()
2305 
      raise x
2306 
    result = deleteDiscountsFromCart_result()
2307 
    result.read(self._iprot)
2308 
    self._iprot.readMessageEnd()
2309 
    if result.scx is not None:
2310 
      raise result.scx
2311 
    return
2312 
 
2313 
  def saveDiscounts(self, discounts):
2314 
    """
2315 
    Accepts a list of thrift objects of Discount type and saves them
2316 
 
2317 
    Parameters:
2318 
     - discounts
2319 
    """
2320 
    self.send_saveDiscounts(discounts)
2321 
    self.recv_saveDiscounts()
2322 
 
2323 
  def send_saveDiscounts(self, discounts):
2324 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2325 
    args = saveDiscounts_args()
2326 
    args.discounts = discounts
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_saveDiscounts(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = saveDiscounts_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
2341 
    if result.scx is not None:
2342 
      raise result.scx
2343 
    return
2344 
 
11526 amit.gupta 2345 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2346 
    """
690 chandransh 2347 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2348 
 
559 chandransh 2349 
    Parameters:
2350 
     - cartId
2815 vikas 2351 
     - sessionSource
2352 
     - sessionStartTime
3858 vikas 2353 
     - firstSource
2354 
     - firstSourceTime
5326 rajveer 2355 
     - userId
6389 rajveer 2356 
     - schemeId
11526 amit.gupta 2357 
     - orderSource
559 chandransh 2358 
    """
11526 amit.gupta 2359 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2360 
    return self.recv_createOrders()
559 chandransh 2361 
 
11526 amit.gupta 2362 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2363 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2364 
    args = createOrders_args()
559 chandransh 2365 
    args.cartId = cartId
2815 vikas 2366 
    args.sessionSource = sessionSource
2367 
    args.sessionStartTime = sessionStartTime
3858 vikas 2368 
    args.firstSource = firstSource
2369 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2370 
    args.userId = userId
6389 rajveer 2371 
    args.schemeId = schemeId
11526 amit.gupta 2372 
    args.orderSource = orderSource
559 chandransh 2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
690 chandransh 2377 
  def recv_createOrders(self, ):
559 chandransh 2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
690 chandransh 2384 
    result = createOrders_result()
559 chandransh 2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
3431 rajveer 2387 
    if result.success is not None:
130 ashish 2388 
      return result.success
3431 rajveer 2389 
    if result.scx is not None:
559 chandransh 2390 
      raise result.scx
690 chandransh 2391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2392 
 
3557 rajveer 2393 
  def validateCart(self, cartId, sourceId):
130 ashish 2394 
    """
690 chandransh 2395 
    Validates that:
2396 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2397 
    2. All of the lines in the cart are active items.
690 chandransh 2398 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2399 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2400 
 
130 ashish 2401 
    Parameters:
559 chandransh 2402 
     - cartId
3557 rajveer 2403 
     - sourceId
130 ashish 2404 
    """
3557 rajveer 2405 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2406 
    return self.recv_validateCart()
130 ashish 2407 
 
3557 rajveer 2408 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2409 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2410 
    args = validateCart_args()
2411 
    args.cartId = cartId
3557 rajveer 2412 
    args.sourceId = sourceId
130 ashish 2413 
    args.write(self._oprot)
2414 
    self._oprot.writeMessageEnd()
2415 
    self._oprot.trans.flush()
2416 
 
559 chandransh 2417 
  def recv_validateCart(self, ):
130 ashish 2418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2419 
    if mtype == TMessageType.EXCEPTION:
2420 
      x = TApplicationException()
2421 
      x.read(self._iprot)
2422 
      self._iprot.readMessageEnd()
2423 
      raise x
559 chandransh 2424 
    result = validateCart_result()
130 ashish 2425 
    result.read(self._iprot)
2426 
    self._iprot.readMessageEnd()
3431 rajveer 2427 
    if result.success is not None:
130 ashish 2428 
      return result.success
3431 rajveer 2429 
    if result.scex is not None:
575 chandransh 2430 
      raise result.scex
559 chandransh 2431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2432 
 
690 chandransh 2433 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2434 
    """
690 chandransh 2435 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2436 
 
575 chandransh 2437 
    Parameters:
690 chandransh 2438 
     - fromCartId
2439 
     - toCartId
2440 
    """
2441 
    self.send_mergeCart(fromCartId, toCartId)
2442 
    self.recv_mergeCart()
2443 
 
2444 
  def send_mergeCart(self, fromCartId, toCartId):
2445 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2446 
    args = mergeCart_args()
2447 
    args.fromCartId = fromCartId
2448 
    args.toCartId = toCartId
2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
2453 
  def recv_mergeCart(self, ):
2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
2460 
    result = mergeCart_result()
2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
2463 
    return
2464 
 
2465 
  def checkOut(self, cartId):
2466 
    """
2467 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2468 
 
690 chandransh 2469 
    Parameters:
575 chandransh 2470 
     - cartId
2471 
    """
690 chandransh 2472 
    self.send_checkOut(cartId)
2473 
    return self.recv_checkOut()
575 chandransh 2474 
 
690 chandransh 2475 
  def send_checkOut(self, cartId):
2476 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2477 
    args = checkOut_args()
575 chandransh 2478 
    args.cartId = cartId
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
690 chandransh 2483 
  def recv_checkOut(self, ):
575 chandransh 2484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2485 
    if mtype == TMessageType.EXCEPTION:
2486 
      x = TApplicationException()
2487 
      x.read(self._iprot)
2488 
      self._iprot.readMessageEnd()
2489 
      raise x
690 chandransh 2490 
    result = checkOut_result()
575 chandransh 2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
3431 rajveer 2493 
    if result.success is not None:
575 chandransh 2494 
      return result.success
3431 rajveer 2495 
    if result.scex is not None:
575 chandransh 2496 
      raise result.scex
690 chandransh 2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2498 
 
690 chandransh 2499 
  def resetCart(self, cartId, items):
559 chandransh 2500 
    """
690 chandransh 2501 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2502 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2503 
 
559 chandransh 2504 
    Parameters:
690 chandransh 2505 
     - cartId
2506 
     - items
559 chandransh 2507 
    """
690 chandransh 2508 
    self.send_resetCart(cartId, items)
2509 
    return self.recv_resetCart()
130 ashish 2510 
 
690 chandransh 2511 
  def send_resetCart(self, cartId, items):
2512 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2513 
    args = resetCart_args()
2514 
    args.cartId = cartId
2515 
    args.items = items
559 chandransh 2516 
    args.write(self._oprot)
2517 
    self._oprot.writeMessageEnd()
2518 
    self._oprot.trans.flush()
2519 
 
690 chandransh 2520 
  def recv_resetCart(self, ):
559 chandransh 2521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2522 
    if mtype == TMessageType.EXCEPTION:
2523 
      x = TApplicationException()
2524 
      x.read(self._iprot)
2525 
      self._iprot.readMessageEnd()
2526 
      raise x
690 chandransh 2527 
    result = resetCart_result()
559 chandransh 2528 
    result.read(self._iprot)
2529 
    self._iprot.readMessageEnd()
3431 rajveer 2530 
    if result.success is not None:
690 chandransh 2531 
      return result.success
3431 rajveer 2532 
    if result.scex is not None:
690 chandransh 2533 
      raise result.scex
2534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2535 
 
2981 rajveer 2536 
  def getUserCount(self, userType):
559 chandransh 2537 
    """
2981 rajveer 2538 
    Returns number of registered users.
2539 
    If userType = null, then it returns count of all users, including anonymous
2540 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2541 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2542 
 
559 chandransh 2543 
    Parameters:
2981 rajveer 2544 
     - userType
559 chandransh 2545 
    """
2981 rajveer 2546 
    self.send_getUserCount(userType)
2547 
    return self.recv_getUserCount()
559 chandransh 2548 
 
2981 rajveer 2549 
  def send_getUserCount(self, userType):
2550 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2551 
    args = getUserCount_args()
2552 
    args.userType = userType
559 chandransh 2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
2981 rajveer 2557 
  def recv_getUserCount(self, ):
559 chandransh 2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
2981 rajveer 2564 
    result = getUserCount_result()
559 chandransh 2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
3431 rajveer 2567 
    if result.success is not None:
559 chandransh 2568 
      return result.success
2981 rajveer 2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2570 
 
2981 rajveer 2571 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2572 
    """
2981 rajveer 2573 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2574 
    If any of startDate or endDate is -1, then that filter is ignored.
2575 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2576 
 
2577 
 
559 chandransh 2578 
    Parameters:
2981 rajveer 2579 
     - userType
2580 
     - startDate
2581 
     - endDate
559 chandransh 2582 
    """
2981 rajveer 2583 
    self.send_getAllUsers(userType, startDate, endDate)
2584 
    return self.recv_getAllUsers()
559 chandransh 2585 
 
2981 rajveer 2586 
  def send_getAllUsers(self, userType, startDate, endDate):
2587 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2588 
    args = getAllUsers_args()
2589 
    args.userType = userType
2590 
    args.startDate = startDate
2591 
    args.endDate = endDate
559 chandransh 2592 
    args.write(self._oprot)
2593 
    self._oprot.writeMessageEnd()
2594 
    self._oprot.trans.flush()
2595 
 
2981 rajveer 2596 
  def recv_getAllUsers(self, ):
559 chandransh 2597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2598 
    if mtype == TMessageType.EXCEPTION:
2599 
      x = TApplicationException()
2600 
      x.read(self._iprot)
2601 
      self._iprot.readMessageEnd()
2602 
      raise x
2981 rajveer 2603 
    result = getAllUsers_result()
559 chandransh 2604 
    result.read(self._iprot)
2605 
    self._iprot.readMessageEnd()
3431 rajveer 2606 
    if result.success is not None:
559 chandransh 2607 
      return result.success
2981 rajveer 2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2609 
 
2981 rajveer 2610 
  def getMyResearchItems(self, userId):
559 chandransh 2611 
    """
2981 rajveer 2612 
    Returns list of item ids in myresearch for the user
3431 rajveer 2613 
 
559 chandransh 2614 
    Parameters:
772 rajveer 2615 
     - userId
559 chandransh 2616 
    """
2981 rajveer 2617 
    self.send_getMyResearchItems(userId)
2618 
    return self.recv_getMyResearchItems()
559 chandransh 2619 
 
2981 rajveer 2620 
  def send_getMyResearchItems(self, userId):
2621 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2622 
    args = getMyResearchItems_args()
772 rajveer 2623 
    args.userId = userId
559 chandransh 2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2981 rajveer 2628 
  def recv_getMyResearchItems(self, ):
559 chandransh 2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
2981 rajveer 2635 
    result = getMyResearchItems_result()
559 chandransh 2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
3431 rajveer 2638 
    if result.success is not None:
559 chandransh 2639 
      return result.success
3431 rajveer 2640 
    if result.scx is not None:
559 chandransh 2641 
      raise result.scx
2981 rajveer 2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2643 
 
2981 rajveer 2644 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2645 
    """
2981 rajveer 2646 
    add item to my research for a user
3431 rajveer 2647 
 
559 chandransh 2648 
    Parameters:
2981 rajveer 2649 
     - userId
2650 
     - itemId
559 chandransh 2651 
    """
2981 rajveer 2652 
    self.send_updateMyResearch(userId, itemId)
2653 
    return self.recv_updateMyResearch()
559 chandransh 2654 
 
2981 rajveer 2655 
  def send_updateMyResearch(self, userId, itemId):
2656 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2657 
    args = updateMyResearch_args()
2658 
    args.userId = userId
2659 
    args.itemId = itemId
559 chandransh 2660 
    args.write(self._oprot)
2661 
    self._oprot.writeMessageEnd()
2662 
    self._oprot.trans.flush()
2663 
 
2981 rajveer 2664 
  def recv_updateMyResearch(self, ):
559 chandransh 2665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2666 
    if mtype == TMessageType.EXCEPTION:
2667 
      x = TApplicationException()
2668 
      x.read(self._iprot)
2669 
      self._iprot.readMessageEnd()
2670 
      raise x
2981 rajveer 2671 
    result = updateMyResearch_result()
559 chandransh 2672 
    result.read(self._iprot)
2673 
    self._iprot.readMessageEnd()
3431 rajveer 2674 
    if result.success is not None:
2981 rajveer 2675 
      return result.success
3431 rajveer 2676 
    if result.scx is not None:
2981 rajveer 2677 
      raise result.scx
2678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2679 
 
2981 rajveer 2680 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2681 
    """
2981 rajveer 2682 
    delete item from my research for a user
3431 rajveer 2683 
 
1596 ankur.sing 2684 
    Parameters:
2981 rajveer 2685 
     - userId
2686 
     - itemId
1596 ankur.sing 2687 
    """
2981 rajveer 2688 
    self.send_deleteItemFromMyResearch(userId, itemId)
2689 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2690 
 
2981 rajveer 2691 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2692 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2693 
    args = deleteItemFromMyResearch_args()
2694 
    args.userId = userId
2695 
    args.itemId = itemId
1596 ankur.sing 2696 
    args.write(self._oprot)
2697 
    self._oprot.writeMessageEnd()
2698 
    self._oprot.trans.flush()
2699 
 
2981 rajveer 2700 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2702 
    if mtype == TMessageType.EXCEPTION:
2703 
      x = TApplicationException()
2704 
      x.read(self._iprot)
2705 
      self._iprot.readMessageEnd()
2706 
      raise x
2981 rajveer 2707 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2708 
    result.read(self._iprot)
2709 
    self._iprot.readMessageEnd()
3431 rajveer 2710 
    if result.scx is not None:
2981 rajveer 2711 
      raise result.scx
2712 
    return
1596 ankur.sing 2713 
 
2981 rajveer 2714 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2715 
    """
2981 rajveer 2716 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2717 
 
1673 ankur.sing 2718 
    Parameters:
2981 rajveer 2719 
     - userId
1673 ankur.sing 2720 
    """
2981 rajveer 2721 
    self.send_getBrowseHistoryItems(userId)
2722 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2723 
 
2981 rajveer 2724 
  def send_getBrowseHistoryItems(self, userId):
2725 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2726 
    args = getBrowseHistoryItems_args()
2727 
    args.userId = userId
1673 ankur.sing 2728 
    args.write(self._oprot)
2729 
    self._oprot.writeMessageEnd()
2730 
    self._oprot.trans.flush()
2731 
 
2981 rajveer 2732 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2734 
    if mtype == TMessageType.EXCEPTION:
2735 
      x = TApplicationException()
2736 
      x.read(self._iprot)
2737 
      self._iprot.readMessageEnd()
2738 
      raise x
2981 rajveer 2739 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2740 
    result.read(self._iprot)
2741 
    self._iprot.readMessageEnd()
3431 rajveer 2742 
    if result.success is not None:
1673 ankur.sing 2743 
      return result.success
3431 rajveer 2744 
    if result.scx is not None:
2981 rajveer 2745 
      raise result.scx
2746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2747 
 
2981 rajveer 2748 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2749 
    """
2981 rajveer 2750 
    add item to browse history for a user
3431 rajveer 2751 
 
2642 varun.gupt 2752 
    Parameters:
2981 rajveer 2753 
     - userId
2754 
     - itemId
2642 varun.gupt 2755 
    """
2981 rajveer 2756 
    self.send_updateBrowseHistory(userId, itemId)
2757 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2758 
 
2981 rajveer 2759 
  def send_updateBrowseHistory(self, userId, itemId):
2760 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2761 
    args = updateBrowseHistory_args()
2762 
    args.userId = userId
2763 
    args.itemId = itemId
2642 varun.gupt 2764 
    args.write(self._oprot)
2765 
    self._oprot.writeMessageEnd()
2766 
    self._oprot.trans.flush()
2767 
 
2981 rajveer 2768 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2770 
    if mtype == TMessageType.EXCEPTION:
2771 
      x = TApplicationException()
2772 
      x.read(self._iprot)
2773 
      self._iprot.readMessageEnd()
2774 
      raise x
2981 rajveer 2775 
    result = updateBrowseHistory_result()
2642 varun.gupt 2776 
    result.read(self._iprot)
2777 
    self._iprot.readMessageEnd()
2778 
    return
2779 
 
3385 varun.gupt 2780 
  def getCartsWithCouponCount(self, couponCode):
2781 
    """
2782 
    Returns count of Carts with given coupon applied
3431 rajveer 2783 
 
3385 varun.gupt 2784 
    Parameters:
2785 
     - couponCode
2786 
    """
2787 
    self.send_getCartsWithCouponCount(couponCode)
2788 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2789 
 
3385 varun.gupt 2790 
  def send_getCartsWithCouponCount(self, couponCode):
2791 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2792 
    args = getCartsWithCouponCount_args()
2793 
    args.couponCode = couponCode
2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
2798 
  def recv_getCartsWithCouponCount(self, ):
2799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2800 
    if mtype == TMessageType.EXCEPTION:
2801 
      x = TApplicationException()
2802 
      x.read(self._iprot)
2803 
      self._iprot.readMessageEnd()
2804 
      raise x
2805 
    result = getCartsWithCouponCount_result()
2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
3431 rajveer 2808 
    if result.success is not None:
3385 varun.gupt 2809 
      return result.success
2810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2811 
 
3499 mandeep.dh 2812 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2813 
    """
2814 
    Updates COD trust level of a user
3385 varun.gupt 2815 
 
3499 mandeep.dh 2816 
    Parameters:
2817 
     - userId
2818 
     - trustLevelDelta
2819 
    """
2820 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2821 
 
2822 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2823 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2824 
    args = increaseTrustLevel_args()
2825 
    args.userId = userId
2826 
    args.trustLevelDelta = trustLevelDelta
2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
5407 amar.kumar 2830 
  def getTrustLevel(self, userId):
2831 
    """
2832 
    Get trust level of a user
2833 
 
2834 
    Parameters:
2835 
     - userId
2836 
    """
2837 
    self.send_getTrustLevel(userId)
2838 
    return self.recv_getTrustLevel()
2839 
 
2840 
  def send_getTrustLevel(self, userId):
2841 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2842 
    args = getTrustLevel_args()
2843 
    args.userId = userId
2844 
    args.write(self._oprot)
2845 
    self._oprot.writeMessageEnd()
2846 
    self._oprot.trans.flush()
2847 
 
2848 
  def recv_getTrustLevel(self, ):
2849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2850 
    if mtype == TMessageType.EXCEPTION:
2851 
      x = TApplicationException()
2852 
      x.read(self._iprot)
2853 
      self._iprot.readMessageEnd()
2854 
      raise x
2855 
    result = getTrustLevel_result()
2856 
    result.read(self._iprot)
2857 
    self._iprot.readMessageEnd()
2858 
    if result.success is not None:
2859 
      return result.success
2860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2861 
 
4668 varun.gupt 2862 
  def showCODOption(self, cartId, sourceId, pincode):
2863 
    """
2864 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2865 
 
4668 varun.gupt 2866 
    Parameters:
2867 
     - cartId
2868 
     - sourceId
2869 
     - pincode
2870 
    """
2871 
    self.send_showCODOption(cartId, sourceId, pincode)
2872 
    return self.recv_showCODOption()
2873 
 
2874 
  def send_showCODOption(self, cartId, sourceId, pincode):
2875 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2876 
    args = showCODOption_args()
2877 
    args.cartId = cartId
2878 
    args.sourceId = sourceId
2879 
    args.pincode = pincode
2880 
    args.write(self._oprot)
2881 
    self._oprot.writeMessageEnd()
2882 
    self._oprot.trans.flush()
2883 
 
2884 
  def recv_showCODOption(self, ):
2885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2886 
    if mtype == TMessageType.EXCEPTION:
2887 
      x = TApplicationException()
2888 
      x.read(self._iprot)
2889 
      self._iprot.readMessageEnd()
2890 
      raise x
2891 
    result = showCODOption_result()
2892 
    result.read(self._iprot)
2893 
    self._iprot.readMessageEnd()
2894 
    if result.success is not None:
2895 
      return result.success
2896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2897 
 
5623 anupam.sin 2898 
  def getUserEmails(self, startDate, endDate):
2899 
    """
2900 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2901 
 
5623 anupam.sin 2902 
    Parameters:
2903 
     - startDate
2904 
     - endDate
2905 
    """
2906 
    self.send_getUserEmails(startDate, endDate)
2907 
    return self.recv_getUserEmails()
2908 
 
2909 
  def send_getUserEmails(self, startDate, endDate):
2910 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
2911 
    args = getUserEmails_args()
2912 
    args.startDate = startDate
2913 
    args.endDate = endDate
2914 
    args.write(self._oprot)
2915 
    self._oprot.writeMessageEnd()
2916 
    self._oprot.trans.flush()
2917 
 
2918 
  def recv_getUserEmails(self, ):
2919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2920 
    if mtype == TMessageType.EXCEPTION:
2921 
      x = TApplicationException()
2922 
      x.read(self._iprot)
2923 
      self._iprot.readMessageEnd()
2924 
      raise x
2925 
    result = getUserEmails_result()
2926 
    result.read(self._iprot)
2927 
    self._iprot.readMessageEnd()
2928 
    if result.success is not None:
2929 
      return result.success
2930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
2931 
 
9299 kshitij.so 2932 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 2933 
    """
2934 
    Mark a cart lineitem as insured. Returns true/false.
2935 
 
2936 
    Parameters:
2937 
     - itemId
2938 
     - cartId
2939 
     - toInsure
9299 kshitij.so 2940 
     - insurerType
6903 anupam.sin 2941 
    """
9299 kshitij.so 2942 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 2943 
    return self.recv_insureItem()
2944 
 
9299 kshitij.so 2945 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 2946 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
2947 
    args = insureItem_args()
2948 
    args.itemId = itemId
2949 
    args.cartId = cartId
2950 
    args.toInsure = toInsure
9299 kshitij.so 2951 
    args.insurerType = insurerType
6903 anupam.sin 2952 
    args.write(self._oprot)
2953 
    self._oprot.writeMessageEnd()
2954 
    self._oprot.trans.flush()
2955 
 
2956 
  def recv_insureItem(self, ):
2957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2958 
    if mtype == TMessageType.EXCEPTION:
2959 
      x = TApplicationException()
2960 
      x.read(self._iprot)
2961 
      self._iprot.readMessageEnd()
2962 
      raise x
2963 
    result = insureItem_result()
2964 
    result.read(self._iprot)
2965 
    self._iprot.readMessageEnd()
2966 
    if result.success is not None:
2967 
      return result.success
2968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
2969 
 
2970 
  def cancelInsurance(self, cartId):
2971 
    """
2972 
    Cancel insurance for all items in the cart
2973 
 
2974 
    Parameters:
2975 
     - cartId
2976 
    """
2977 
    self.send_cancelInsurance(cartId)
2978 
    return self.recv_cancelInsurance()
2979 
 
2980 
  def send_cancelInsurance(self, cartId):
2981 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
2982 
    args = cancelInsurance_args()
2983 
    args.cartId = cartId
2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
2988 
  def recv_cancelInsurance(self, ):
2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
2995 
    result = cancelInsurance_result()
2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
2998 
    if result.success is not None:
2999 
      return result.success
3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3001 
 
3002 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3003 
    """
3004 
    Stores insurance specific details like date of birth and guardianName
3005 
 
3006 
    Parameters:
3007 
     - addressId
3008 
     - dob
3009 
     - guardianName
3010 
    """
3011 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3012 
    return self.recv_storeInsuranceSpecificDetails()
3013 
 
3014 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3015 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3016 
    args = storeInsuranceSpecificDetails_args()
3017 
    args.addressId = addressId
3018 
    args.dob = dob
3019 
    args.guardianName = guardianName
3020 
    args.write(self._oprot)
3021 
    self._oprot.writeMessageEnd()
3022 
    self._oprot.trans.flush()
3023 
 
3024 
  def recv_storeInsuranceSpecificDetails(self, ):
3025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3026 
    if mtype == TMessageType.EXCEPTION:
3027 
      x = TApplicationException()
3028 
      x.read(self._iprot)
3029 
      self._iprot.readMessageEnd()
3030 
      raise x
3031 
    result = storeInsuranceSpecificDetails_result()
3032 
    result.read(self._iprot)
3033 
    self._iprot.readMessageEnd()
3034 
    if result.success is not None:
3035 
      return result.success
3036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3037 
 
3038 
  def isInsuranceDetailPresent(self, addressId):
3039 
    """
3040 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3041 
 
3042 
    Parameters:
3043 
     - addressId
3044 
    """
3045 
    self.send_isInsuranceDetailPresent(addressId)
3046 
    return self.recv_isInsuranceDetailPresent()
3047 
 
3048 
  def send_isInsuranceDetailPresent(self, addressId):
3049 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3050 
    args = isInsuranceDetailPresent_args()
3051 
    args.addressId = addressId
3052 
    args.write(self._oprot)
3053 
    self._oprot.writeMessageEnd()
3054 
    self._oprot.trans.flush()
3055 
 
3056 
  def recv_isInsuranceDetailPresent(self, ):
3057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3058 
    if mtype == TMessageType.EXCEPTION:
3059 
      x = TApplicationException()
3060 
      x.read(self._iprot)
3061 
      self._iprot.readMessageEnd()
3062 
      raise x
3063 
    result = isInsuranceDetailPresent_result()
3064 
    result.read(self._iprot)
3065 
    self._iprot.readMessageEnd()
3066 
    if result.success is not None:
3067 
      return result.success
3068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3069 
 
9791 rajveer 3070 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3071 
    """
9791 rajveer 3072 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3073 
 
6821 amar.kumar 3074 
    Parameters:
3075 
     - startDate
3076 
     - endDate
3077 
    """
9791 rajveer 3078 
    self.send_getProductsAddedToCart(startDate, endDate)
3079 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3080 
 
9791 rajveer 3081 
  def send_getProductsAddedToCart(self, startDate, endDate):
3082 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3083 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3084 
    args.startDate = startDate
3085 
    args.endDate = endDate
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
3089 
 
9791 rajveer 3090 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3092 
    if mtype == TMessageType.EXCEPTION:
3093 
      x = TApplicationException()
3094 
      x.read(self._iprot)
3095 
      self._iprot.readMessageEnd()
3096 
      raise x
9791 rajveer 3097 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3098 
    result.read(self._iprot)
3099 
    self._iprot.readMessageEnd()
3100 
    if result.success is not None:
3101 
      return result.success
9791 rajveer 3102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3103 
 
11592 amit.gupta 3104 
  def validateCartPlus(self, cartId, sourceId):
3105 
    """
3106 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3107 
 
11592 amit.gupta 3108 
    Parameters:
3109 
     - cartId
3110 
     - sourceId
3111 
    """
3112 
    self.send_validateCartPlus(cartId, sourceId)
3113 
    return self.recv_validateCartPlus()
3114 
 
3115 
  def send_validateCartPlus(self, cartId, sourceId):
3116 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3117 
    args = validateCartPlus_args()
3118 
    args.cartId = cartId
3119 
    args.sourceId = sourceId
3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3124 
  def recv_validateCartPlus(self, ):
3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3131 
    result = validateCartPlus_result()
3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3134 
    if result.success is not None:
3135 
      return result.success
3136 
    if result.scex is not None:
3137 
      raise result.scex
3138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3139 
 
11679 vikram.rag 3140 
  def isPrivateDealUser(self, userId):
3141 
    """
3142 
    Parameters:
3143 
     - userId
3144 
    """
3145 
    self.send_isPrivateDealUser(userId)
3146 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3147 
 
11679 vikram.rag 3148 
  def send_isPrivateDealUser(self, userId):
3149 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3150 
    args = isPrivateDealUser_args()
3151 
    args.userId = userId
3152 
    args.write(self._oprot)
3153 
    self._oprot.writeMessageEnd()
3154 
    self._oprot.trans.flush()
3155 
 
3156 
  def recv_isPrivateDealUser(self, ):
3157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3158 
    if mtype == TMessageType.EXCEPTION:
3159 
      x = TApplicationException()
3160 
      x.read(self._iprot)
3161 
      self._iprot.readMessageEnd()
3162 
      raise x
3163 
    result = isPrivateDealUser_result()
3164 
    result.read(self._iprot)
3165 
    self._iprot.readMessageEnd()
3166 
    if result.success is not None:
3167 
      return result.success
3168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3169 
 
11890 kshitij.so 3170 
  def addPrivateDealUser(self, userId):
3171 
    """
3172 
    Parameters:
3173 
     - userId
3174 
    """
3175 
    self.send_addPrivateDealUser(userId)
3176 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3177 
 
11890 kshitij.so 3178 
  def send_addPrivateDealUser(self, userId):
3179 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3180 
    args = addPrivateDealUser_args()
3181 
    args.userId = userId
3182 
    args.write(self._oprot)
3183 
    self._oprot.writeMessageEnd()
3184 
    self._oprot.trans.flush()
3185 
 
3186 
  def recv_addPrivateDealUser(self, ):
3187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3188 
    if mtype == TMessageType.EXCEPTION:
3189 
      x = TApplicationException()
3190 
      x.read(self._iprot)
3191 
      self._iprot.readMessageEnd()
3192 
      raise x
3193 
    result = addPrivateDealUser_result()
3194 
    result.read(self._iprot)
3195 
    self._iprot.readMessageEnd()
3196 
    if result.success is not None:
3197 
      return result.success
3198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3199 
 
3200 
  def changePrivateDealUserStatus(self, userId, isActive):
3201 
    """
3202 
    Parameters:
3203 
     - userId
3204 
     - isActive
3205 
    """
3206 
    self.send_changePrivateDealUserStatus(userId, isActive)
3207 
    return self.recv_changePrivateDealUserStatus()
3208 
 
3209 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3210 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3211 
    args = changePrivateDealUserStatus_args()
3212 
    args.userId = userId
3213 
    args.isActive = isActive
3214 
    args.write(self._oprot)
3215 
    self._oprot.writeMessageEnd()
3216 
    self._oprot.trans.flush()
3217 
 
3218 
  def recv_changePrivateDealUserStatus(self, ):
3219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3220 
    if mtype == TMessageType.EXCEPTION:
3221 
      x = TApplicationException()
3222 
      x.read(self._iprot)
3223 
      self._iprot.readMessageEnd()
3224 
      raise x
3225 
    result = changePrivateDealUserStatus_result()
3226 
    result.read(self._iprot)
3227 
    self._iprot.readMessageEnd()
3228 
    if result.success is not None:
3229 
      return result.success
3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3231 
 
3232 
  def getPrivateDealUser(self, userId):
3233 
    """
3234 
    Parameters:
3235 
     - userId
3236 
    """
3237 
    self.send_getPrivateDealUser(userId)
3238 
    return self.recv_getPrivateDealUser()
3239 
 
3240 
  def send_getPrivateDealUser(self, userId):
3241 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3242 
    args = getPrivateDealUser_args()
3243 
    args.userId = userId
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_getPrivateDealUser(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = getPrivateDealUser_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    if result.success is not None:
3259 
      return result.success
3260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3261 
 
3262 
 
3376 rajveer 3263 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3264 
  def __init__(self, handler):
3376 rajveer 3265 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3266 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3267 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3268 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3269 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3270 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3271 
    self._processMap["createUser"] = Processor.process_createUser
3272 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3273 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3274 
    self._processMap["userExists"] = Processor.process_userExists
3275 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3276 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3277 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3278 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3279 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3280 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3281 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3282 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3283 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3284 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3285 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3286 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3287 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3288 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3289 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3290 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3291 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3292 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3293 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3294 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3295 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3296 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3297 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3298 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3299 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3300 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3301 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3302 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3303 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3304 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3305 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3306 
    self._processMap["getCart"] = Processor.process_getCart
3307 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3308 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3309 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3310 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3311 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3312 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3313 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3314 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3315 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3316 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3317 
    self._processMap["validateCart"] = Processor.process_validateCart
3318 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3319 
    self._processMap["checkOut"] = Processor.process_checkOut
3320 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3321 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3322 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3323 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3324 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3325 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3326 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3327 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3328 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3329 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3330 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3331 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3332 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3333 
    self._processMap["insureItem"] = Processor.process_insureItem
3334 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3335 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3336 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3337 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3338 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3339 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3340 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3341 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3342 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
94 ashish 3343 
 
3344 
  def process(self, iprot, oprot):
3345 
    (name, type, seqid) = iprot.readMessageBegin()
3346 
    if name not in self._processMap:
3347 
      iprot.skip(TType.STRUCT)
3348 
      iprot.readMessageEnd()
3349 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3350 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3351 
      x.write(oprot)
3352 
      oprot.writeMessageEnd()
3353 
      oprot.trans.flush()
3354 
      return
3355 
    else:
3356 
      self._processMap[name](self, seqid, iprot, oprot)
3357 
    return True
3358 
 
559 chandransh 3359 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3360 
    args = createAnonymousUser_args()
94 ashish 3361 
    args.read(iprot)
3362 
    iprot.readMessageEnd()
559 chandransh 3363 
    result = createAnonymousUser_result()
94 ashish 3364 
    try:
559 chandransh 3365 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3366 
    except UserContextException, ucex:
3367 
      result.ucex = ucex
3368 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3369 
    result.write(oprot)
3370 
    oprot.writeMessageEnd()
3371 
    oprot.trans.flush()
3372 
 
559 chandransh 3373 
  def process_getUserById(self, seqid, iprot, oprot):
3374 
    args = getUserById_args()
94 ashish 3375 
    args.read(iprot)
3376 
    iprot.readMessageEnd()
559 chandransh 3377 
    result = getUserById_result()
94 ashish 3378 
    try:
559 chandransh 3379 
      result.success = self._handler.getUserById(args.userId)
3380 
    except UserContextException, ucex:
3381 
      result.ucex = ucex
3382 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3383 
    result.write(oprot)
3384 
    oprot.writeMessageEnd()
3385 
    oprot.trans.flush()
3386 
 
5326 rajveer 3387 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3388 
    args = getUserByCartId_args()
3389 
    args.read(iprot)
3390 
    iprot.readMessageEnd()
3391 
    result = getUserByCartId_result()
3392 
    try:
3393 
      result.success = self._handler.getUserByCartId(args.cartId)
3394 
    except UserContextException, ucex:
3395 
      result.ucex = ucex
3396 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3397 
    result.write(oprot)
3398 
    oprot.writeMessageEnd()
3399 
    oprot.trans.flush()
3400 
 
1491 vikas 3401 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3402 
    args = getUserByEmail_args()
3403 
    args.read(iprot)
3404 
    iprot.readMessageEnd()
3405 
    result = getUserByEmail_result()
3406 
    try:
3407 
      result.success = self._handler.getUserByEmail(args.email)
3408 
    except UserContextException, ucex:
3409 
      result.ucex = ucex
3410 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3411 
    result.write(oprot)
3412 
    oprot.writeMessageEnd()
3413 
    oprot.trans.flush()
3414 
 
3032 mandeep.dh 3415 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3416 
    args = getUserByMobileNumber_args()
3417 
    args.read(iprot)
3418 
    iprot.readMessageEnd()
3419 
    result = getUserByMobileNumber_result()
3420 
    try:
3421 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3422 
    except UserContextException, ucex:
3423 
      result.ucex = ucex
3424 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3425 
    result.write(oprot)
3426 
    oprot.writeMessageEnd()
3427 
    oprot.trans.flush()
3428 
 
559 chandransh 3429 
  def process_createUser(self, seqid, iprot, oprot):
3430 
    args = createUser_args()
94 ashish 3431 
    args.read(iprot)
3432 
    iprot.readMessageEnd()
559 chandransh 3433 
    result = createUser_result()
94 ashish 3434 
    try:
559 chandransh 3435 
      result.success = self._handler.createUser(args.user)
3436 
    except UserContextException, ucex:
3437 
      result.ucex = ucex
3438 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3439 
    result.write(oprot)
3440 
    oprot.writeMessageEnd()
3441 
    oprot.trans.flush()
3442 
 
559 chandransh 3443 
  def process_updateUser(self, seqid, iprot, oprot):
3444 
    args = updateUser_args()
94 ashish 3445 
    args.read(iprot)
3446 
    iprot.readMessageEnd()
559 chandransh 3447 
    result = updateUser_result()
94 ashish 3448 
    try:
559 chandransh 3449 
      result.success = self._handler.updateUser(args.user)
3450 
    except UserContextException, ucex:
3451 
      result.ucex = ucex
3452 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3453 
    result.write(oprot)
3454 
    oprot.writeMessageEnd()
3455 
    oprot.trans.flush()
3456 
 
122 ashish 3457 
  def process_authenticateUser(self, seqid, iprot, oprot):
3458 
    args = authenticateUser_args()
3459 
    args.read(iprot)
3460 
    iprot.readMessageEnd()
3461 
    result = authenticateUser_result()
3462 
    try:
559 chandransh 3463 
      result.success = self._handler.authenticateUser(args.email, args.password)
3464 
    except AuthenticationException, auex:
3465 
      result.auex = auex
122 ashish 3466 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3467 
    result.write(oprot)
3468 
    oprot.writeMessageEnd()
3469 
    oprot.trans.flush()
3470 
 
94 ashish 3471 
  def process_userExists(self, seqid, iprot, oprot):
3472 
    args = userExists_args()
3473 
    args.read(iprot)
3474 
    iprot.readMessageEnd()
3475 
    result = userExists_result()
3476 
    try:
3477 
      result.success = self._handler.userExists(args.email)
3478 
    except UserContextException, ucx:
3479 
      result.ucx = ucx
3480 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3481 
    result.write(oprot)
3482 
    oprot.writeMessageEnd()
3483 
    oprot.trans.flush()
3484 
 
3485 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3486 
    args = addAddressForUser_args()
3487 
    args.read(iprot)
3488 
    iprot.readMessageEnd()
3489 
    result = addAddressForUser_result()
3490 
    try:
567 rajveer 3491 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3492 
    except UserContextException, ucx:
3493 
      result.ucx = ucx
3494 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3495 
    result.write(oprot)
3496 
    oprot.writeMessageEnd()
3497 
    oprot.trans.flush()
3498 
 
3499 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3500 
    args = removeAddressForUser_args()
3501 
    args.read(iprot)
3502 
    iprot.readMessageEnd()
3503 
    result = removeAddressForUser_result()
3504 
    try:
3505 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3506 
    except UserContextException, ucx:
3507 
      result.ucx = ucx
3508 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3509 
    result.write(oprot)
3510 
    oprot.writeMessageEnd()
3511 
    oprot.trans.flush()
3512 
 
3513 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3514 
    args = setUserAsLoggedIn_args()
3515 
    args.read(iprot)
3516 
    iprot.readMessageEnd()
3517 
    result = setUserAsLoggedIn_result()
3518 
    try:
3519 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3520 
    except UserContextException, ucx:
3521 
      result.ucx = ucx
3522 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3523 
    result.write(oprot)
3524 
    oprot.writeMessageEnd()
3525 
    oprot.trans.flush()
3526 
 
3527 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3528 
    args = setUserAsLoggedOut_args()
3529 
    args.read(iprot)
3530 
    iprot.readMessageEnd()
3531 
    result = setUserAsLoggedOut_result()
3532 
    try:
3533 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3534 
    except UserContextException, ucx:
3535 
      result.ucx = ucx
3536 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3537 
    result.write(oprot)
3538 
    oprot.writeMessageEnd()
3539 
    oprot.trans.flush()
3540 
 
504 rajveer 3541 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3542 
    args = setDefaultAddress_args()
3543 
    args.read(iprot)
3544 
    iprot.readMessageEnd()
3545 
    result = setDefaultAddress_result()
3546 
    try:
3547 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3548 
    except UserContextException, ucx:
3549 
      result.ucx = ucx
3550 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3551 
    result.write(oprot)
3552 
    oprot.writeMessageEnd()
3553 
    oprot.trans.flush()
3554 
 
94 ashish 3555 
  def process_updatePassword(self, seqid, iprot, oprot):
3556 
    args = updatePassword_args()
3557 
    args.read(iprot)
3558 
    iprot.readMessageEnd()
3559 
    result = updatePassword_result()
3560 
    try:
594 rajveer 3561 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3562 
    except UserContextException, ucx:
3563 
      result.ucx = ucx
3564 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3565 
    result.write(oprot)
3566 
    oprot.writeMessageEnd()
3567 
    oprot.trans.flush()
3568 
 
581 rajveer 3569 
  def process_forgotPassword(self, seqid, iprot, oprot):
3570 
    args = forgotPassword_args()
3571 
    args.read(iprot)
3572 
    iprot.readMessageEnd()
3573 
    result = forgotPassword_result()
3574 
    try:
884 rajveer 3575 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3576 
    except UserContextException, ucx:
3577 
      result.ucx = ucx
3578 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3579 
    result.write(oprot)
3580 
    oprot.writeMessageEnd()
3581 
    oprot.trans.flush()
3582 
 
594 rajveer 3583 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3584 
    args = getAllAddressesForUser_args()
3585 
    args.read(iprot)
3586 
    iprot.readMessageEnd()
3587 
    result = getAllAddressesForUser_result()
3588 
    try:
3589 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3590 
    except UserContextException, ucx:
3591 
      result.ucx = ucx
3592 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3593 
    result.write(oprot)
3594 
    oprot.writeMessageEnd()
3595 
    oprot.trans.flush()
3596 
 
1894 vikas 3597 
  def process_getAddressById(self, seqid, iprot, oprot):
3598 
    args = getAddressById_args()
3599 
    args.read(iprot)
3600 
    iprot.readMessageEnd()
3601 
    result = getAddressById_result()
3602 
    try:
3603 
      result.success = self._handler.getAddressById(args.addressId)
3604 
    except UserContextException, ucx:
3605 
      result.ucx = ucx
3606 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3607 
    result.write(oprot)
3608 
    oprot.writeMessageEnd()
3609 
    oprot.trans.flush()
3610 
 
594 rajveer 3611 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3612 
    args = getDefaultAddressId_args()
3613 
    args.read(iprot)
3614 
    iprot.readMessageEnd()
3615 
    result = getDefaultAddressId_result()
3616 
    try:
3617 
      result.success = self._handler.getDefaultAddressId(args.userId)
3618 
    except UserContextException, ucx:
3619 
      result.ucx = ucx
3620 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3621 
    result.write(oprot)
3622 
    oprot.writeMessageEnd()
3623 
    oprot.trans.flush()
3624 
 
785 rajveer 3625 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3626 
    args = getDefaultPincode_args()
3627 
    args.read(iprot)
3628 
    iprot.readMessageEnd()
3629 
    result = getDefaultPincode_result()
3630 
    try:
3631 
      result.success = self._handler.getDefaultPincode(args.userId)
3632 
    except UserContextException, ucx:
3633 
      result.ucx = ucx
3634 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3635 
    result.write(oprot)
3636 
    oprot.writeMessageEnd()
3637 
    oprot.trans.flush()
3638 
 
1274 varun.gupt 3639 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3640 
    args = saveUserCommunication_args()
3641 
    args.read(iprot)
3642 
    iprot.readMessageEnd()
3643 
    result = saveUserCommunication_result()
3644 
    try:
3645 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3646 
    except UserCommunicationException, ucx:
3647 
      result.ucx = ucx
3648 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3649 
    result.write(oprot)
3650 
    oprot.writeMessageEnd()
3651 
    oprot.trans.flush()
3652 
 
1590 varun.gupt 3653 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3654 
    args = getUserCommunicationById_args()
3655 
    args.read(iprot)
3656 
    iprot.readMessageEnd()
3657 
    result = getUserCommunicationById_result()
3658 
    try:
3659 
      result.success = self._handler.getUserCommunicationById(args.id)
3660 
    except UserCommunicationException, ucx:
3661 
      result.ucx = ucx
3662 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3663 
    result.write(oprot)
3664 
    oprot.writeMessageEnd()
3665 
    oprot.trans.flush()
3666 
 
3667 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3668 
    args = getUserCommunicationByUser_args()
3669 
    args.read(iprot)
3670 
    iprot.readMessageEnd()
3671 
    result = getUserCommunicationByUser_result()
3672 
    try:
3673 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3674 
    except UserCommunicationException, ucx:
3675 
      result.ucx = ucx
3676 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3677 
    result.write(oprot)
3678 
    oprot.writeMessageEnd()
3679 
    oprot.trans.flush()
3680 
 
3681 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3682 
    args = getAllUserCommunications_args()
3683 
    args.read(iprot)
3684 
    iprot.readMessageEnd()
3685 
    result = getAllUserCommunications_result()
3686 
    try:
3687 
      result.success = self._handler.getAllUserCommunications()
3688 
    except UserCommunicationException, ucx:
3689 
      result.ucx = ucx
3690 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3691 
    result.write(oprot)
3692 
    oprot.writeMessageEnd()
3693 
    oprot.trans.flush()
3694 
 
5407 amar.kumar 3695 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3696 
    args = removeUserCommunication_args()
3697 
    args.read(iprot)
3698 
    iprot.readMessageEnd()
3699 
    result = removeUserCommunication_result()
3700 
    try:
3701 
      self._handler.removeUserCommunication(args.id)
3702 
    except UserCommunicationException, ucx:
3703 
      result.ucx = ucx
3704 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3705 
    result.write(oprot)
3706 
    oprot.writeMessageEnd()
3707 
    oprot.trans.flush()
3708 
 
1845 vikas 3709 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3710 
    args = createMasterAffiliate_args()
3711 
    args.read(iprot)
3712 
    iprot.readMessageEnd()
3713 
    result = createMasterAffiliate_result()
3714 
    try:
1859 vikas 3715 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3716 
    except UserAffiliateException, utx:
1845 vikas 3717 
      result.utx = utx
3718 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3719 
    result.write(oprot)
3720 
    oprot.writeMessageEnd()
3721 
    oprot.trans.flush()
3722 
 
1899 vikas 3723 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3724 
    args = getAllMasterAffiliates_args()
3725 
    args.read(iprot)
3726 
    iprot.readMessageEnd()
3727 
    result = getAllMasterAffiliates_result()
3728 
    try:
3729 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3730 
    except UserAffiliateException, utx:
1899 vikas 3731 
      result.utx = utx
3732 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3733 
    result.write(oprot)
3734 
    oprot.writeMessageEnd()
3735 
    oprot.trans.flush()
3736 
 
1845 vikas 3737 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3738 
    args = getMasterAffiliateById_args()
3739 
    args.read(iprot)
3740 
    iprot.readMessageEnd()
3741 
    result = getMasterAffiliateById_result()
3742 
    try:
3743 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3744 
    except UserAffiliateException, utx:
1845 vikas 3745 
      result.utx = utx
3746 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3747 
    result.write(oprot)
3748 
    oprot.writeMessageEnd()
3749 
    oprot.trans.flush()
3750 
 
3751 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3752 
    args = getMasterAffiliateByName_args()
3753 
    args.read(iprot)
3754 
    iprot.readMessageEnd()
3755 
    result = getMasterAffiliateByName_result()
3756 
    try:
3757 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3758 
    except UserAffiliateException, utx:
1845 vikas 3759 
      result.utx = utx
3760 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3761 
    result.write(oprot)
3762 
    oprot.writeMessageEnd()
3763 
    oprot.trans.flush()
3764 
 
3765 
  def process_createAffiliate(self, seqid, iprot, oprot):
3766 
    args = createAffiliate_args()
3767 
    args.read(iprot)
3768 
    iprot.readMessageEnd()
3769 
    result = createAffiliate_result()
3770 
    try:
1859 vikas 3771 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3772 
    except UserAffiliateException, utx:
1845 vikas 3773 
      result.utx = utx
3774 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3775 
    result.write(oprot)
3776 
    oprot.writeMessageEnd()
3777 
    oprot.trans.flush()
3778 
 
3779 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3780 
    args = getAffiliateById_args()
3781 
    args.read(iprot)
3782 
    iprot.readMessageEnd()
3783 
    result = getAffiliateById_result()
3784 
    try:
3785 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3786 
    except UserAffiliateException, utx:
1845 vikas 3787 
      result.utx = utx
3788 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3789 
    result.write(oprot)
3790 
    oprot.writeMessageEnd()
3791 
    oprot.trans.flush()
3792 
 
3793 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3794 
    args = getAffiliateByName_args()
3795 
    args.read(iprot)
3796 
    iprot.readMessageEnd()
3797 
    result = getAffiliateByName_result()
3798 
    try:
3799 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3800 
    except UserAffiliateException, utx:
1845 vikas 3801 
      result.utx = utx
3802 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3803 
    result.write(oprot)
3804 
    oprot.writeMessageEnd()
3805 
    oprot.trans.flush()
3806 
 
3807 
  def process_getTrackerById(self, seqid, iprot, oprot):
3808 
    args = getTrackerById_args()
3809 
    args.read(iprot)
3810 
    iprot.readMessageEnd()
3811 
    result = getTrackerById_result()
3812 
    try:
1996 vikas 3813 
      result.success = self._handler.getTrackerById(args.id)
3814 
    except UserAffiliateException, utx:
1845 vikas 3815 
      result.utx = utx
3816 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3817 
    result.write(oprot)
3818 
    oprot.writeMessageEnd()
3819 
    oprot.trans.flush()
3820 
 
1996 vikas 3821 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3822 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3823 
    args.read(iprot)
3824 
    iprot.readMessageEnd()
1996 vikas 3825 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3826 
    try:
1996 vikas 3827 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3828 
    except UserAffiliateException, utx:
1845 vikas 3829 
      result.utx = utx
1996 vikas 3830 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3831 
    result.write(oprot)
3832 
    oprot.writeMessageEnd()
3833 
    oprot.trans.flush()
3834 
 
3835 
  def process_addTrackLog(self, seqid, iprot, oprot):
3836 
    args = addTrackLog_args()
3837 
    args.read(iprot)
3838 
    iprot.readMessageEnd()
3839 
    result = addTrackLog_result()
3840 
    try:
1996 vikas 3841 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3842 
    except UserAffiliateException, utx:
1845 vikas 3843 
      result.utx = utx
3844 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3845 
    result.write(oprot)
3846 
    oprot.writeMessageEnd()
3847 
    oprot.trans.flush()
3848 
 
3849 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3850 
    args = getTrackLogById_args()
3851 
    args.read(iprot)
3852 
    iprot.readMessageEnd()
3853 
    result = getTrackLogById_result()
3854 
    try:
3855 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3856 
    except UserAffiliateException, utx:
1845 vikas 3857 
      result.utx = utx
3858 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3859 
    result.write(oprot)
3860 
    oprot.writeMessageEnd()
3861 
    oprot.trans.flush()
3862 
 
1996 vikas 3863 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3864 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3865 
    args.read(iprot)
3866 
    iprot.readMessageEnd()
1996 vikas 3867 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3868 
    try:
3293 vikas 3869 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3870 
    except UserAffiliateException, utx:
1845 vikas 3871 
      result.utx = utx
1996 vikas 3872 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3873 
    result.write(oprot)
3874 
    oprot.writeMessageEnd()
3875 
    oprot.trans.flush()
3876 
 
3877 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3878 
    args = getTrackLogsByUser_args()
3879 
    args.read(iprot)
3880 
    iprot.readMessageEnd()
3881 
    result = getTrackLogsByUser_result()
3882 
    try:
3883 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3884 
    except UserAffiliateException, utx:
1845 vikas 3885 
      result.utx = utx
3886 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3887 
    result.write(oprot)
3888 
    oprot.writeMessageEnd()
3889 
    oprot.trans.flush()
3890 
 
3891 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3892 
    args = getTrackLogs_args()
3893 
    args.read(iprot)
3894 
    iprot.readMessageEnd()
3895 
    result = getTrackLogs_result()
3896 
    try:
1996 vikas 3897 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3898 
    except UserAffiliateException, utx:
1845 vikas 3899 
      result.utx = utx
3900 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3901 
    result.write(oprot)
3902 
    oprot.writeMessageEnd()
3903 
    oprot.trans.flush()
3904 
 
559 chandransh 3905 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3906 
    args = getCurrentCart_args()
94 ashish 3907 
    args.read(iprot)
3908 
    iprot.readMessageEnd()
559 chandransh 3909 
    result = getCurrentCart_result()
94 ashish 3910 
    try:
559 chandransh 3911 
      result.success = self._handler.getCurrentCart(args.userId)
3912 
    except ShoppingCartException, scx:
3913 
      result.scx = scx
3914 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3915 
    result.write(oprot)
3916 
    oprot.writeMessageEnd()
3917 
    oprot.trans.flush()
3918 
 
559 chandransh 3919 
  def process_getCart(self, seqid, iprot, oprot):
3920 
    args = getCart_args()
94 ashish 3921 
    args.read(iprot)
3922 
    iprot.readMessageEnd()
559 chandransh 3923 
    result = getCart_result()
94 ashish 3924 
    try:
559 chandransh 3925 
      result.success = self._handler.getCart(args.cartId)
3926 
    except ShoppingCartException, scx:
3927 
      result.scx = scx
3928 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3929 
    result.write(oprot)
3930 
    oprot.writeMessageEnd()
3931 
    oprot.trans.flush()
3932 
 
559 chandransh 3933 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3934 
    args = getCartsByTime_args()
94 ashish 3935 
    args.read(iprot)
3936 
    iprot.readMessageEnd()
559 chandransh 3937 
    result = getCartsByTime_result()
94 ashish 3938 
    try:
559 chandransh 3939 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3940 
    except ShoppingCartException, scx:
3941 
      result.scx = scx
3942 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3943 
    result.write(oprot)
3944 
    oprot.writeMessageEnd()
3945 
    oprot.trans.flush()
3946 
 
559 chandransh 3947 
  def process_addItemToCart(self, seqid, iprot, oprot):
3948 
    args = addItemToCart_args()
130 ashish 3949 
    args.read(iprot)
3950 
    iprot.readMessageEnd()
559 chandransh 3951 
    result = addItemToCart_result()
130 ashish 3952 
    try:
3557 rajveer 3953 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 3954 
    except ShoppingCartException, scx:
3955 
      result.scx = scx
3956 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3957 
    result.write(oprot)
3958 
    oprot.writeMessageEnd()
3959 
    oprot.trans.flush()
3960 
 
559 chandransh 3961 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3962 
    args = deleteItemFromCart_args()
3963 
    args.read(iprot)
3964 
    iprot.readMessageEnd()
3965 
    result = deleteItemFromCart_result()
3966 
    try:
3967 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3968 
    except ShoppingCartException, scx:
3969 
      result.scx = scx
3970 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3971 
    result.write(oprot)
3972 
    oprot.writeMessageEnd()
3973 
    oprot.trans.flush()
130 ashish 3974 
 
559 chandransh 3975 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3976 
    args = addAddressToCart_args()
3977 
    args.read(iprot)
3978 
    iprot.readMessageEnd()
3979 
    result = addAddressToCart_result()
575 chandransh 3980 
    try:
3981 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3982 
    except ShoppingCartException, scx:
3983 
      result.scx = scx
559 chandransh 3984 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3985 
    result.write(oprot)
3986 
    oprot.writeMessageEnd()
3987 
    oprot.trans.flush()
3988 
 
5553 rajveer 3989 
  def process_addStoreToCart(self, seqid, iprot, oprot):
3990 
    args = addStoreToCart_args()
3991 
    args.read(iprot)
3992 
    iprot.readMessageEnd()
3993 
    result = addStoreToCart_result()
3994 
    try:
3995 
      self._handler.addStoreToCart(args.cartId, args.storeId)
3996 
    except ShoppingCartException, scx:
3997 
      result.scx = scx
3998 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
3999 
    result.write(oprot)
4000 
    oprot.writeMessageEnd()
4001 
    oprot.trans.flush()
4002 
 
1976 varun.gupt 4003 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4004 
    args = applyCouponToCart_args()
4005 
    args.read(iprot)
4006 
    iprot.readMessageEnd()
4007 
    result = applyCouponToCart_result()
4008 
    try:
6922 anupam.sin 4009 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4010 
    except ShoppingCartException, scx:
4011 
      result.scx = scx
4012 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4013 
    result.write(oprot)
4014 
    oprot.writeMessageEnd()
4015 
    oprot.trans.flush()
4016 
 
4017 
  def process_removeCoupon(self, seqid, iprot, oprot):
4018 
    args = removeCoupon_args()
4019 
    args.read(iprot)
4020 
    iprot.readMessageEnd()
4021 
    result = removeCoupon_result()
4022 
    try:
4023 
      self._handler.removeCoupon(args.cartId)
4024 
    except ShoppingCartException, scx:
4025 
      result.scx = scx
4026 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4027 
    result.write(oprot)
4028 
    oprot.writeMessageEnd()
4029 
    oprot.trans.flush()
4030 
 
3554 varun.gupt 4031 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4032 
    args = deleteDiscountsFromCart_args()
4033 
    args.read(iprot)
4034 
    iprot.readMessageEnd()
4035 
    result = deleteDiscountsFromCart_result()
4036 
    try:
4037 
      self._handler.deleteDiscountsFromCart(args.cartId)
4038 
    except ShoppingCartException, scx:
4039 
      result.scx = scx
4040 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4041 
    result.write(oprot)
4042 
    oprot.writeMessageEnd()
4043 
    oprot.trans.flush()
4044 
 
4045 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4046 
    args = saveDiscounts_args()
4047 
    args.read(iprot)
4048 
    iprot.readMessageEnd()
4049 
    result = saveDiscounts_result()
4050 
    try:
4051 
      self._handler.saveDiscounts(args.discounts)
4052 
    except ShoppingCartException, scx:
4053 
      result.scx = scx
4054 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4055 
    result.write(oprot)
4056 
    oprot.writeMessageEnd()
4057 
    oprot.trans.flush()
4058 
 
690 chandransh 4059 
  def process_createOrders(self, seqid, iprot, oprot):
4060 
    args = createOrders_args()
559 chandransh 4061 
    args.read(iprot)
4062 
    iprot.readMessageEnd()
690 chandransh 4063 
    result = createOrders_result()
559 chandransh 4064 
    try:
11526 amit.gupta 4065 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4066 
    except ShoppingCartException, scx:
4067 
      result.scx = scx
690 chandransh 4068 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4069 
    result.write(oprot)
4070 
    oprot.writeMessageEnd()
4071 
    oprot.trans.flush()
4072 
 
4073 
  def process_validateCart(self, seqid, iprot, oprot):
4074 
    args = validateCart_args()
4075 
    args.read(iprot)
4076 
    iprot.readMessageEnd()
4077 
    result = validateCart_result()
575 chandransh 4078 
    try:
3557 rajveer 4079 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4080 
    except ShoppingCartException, scex:
4081 
      result.scex = scex
559 chandransh 4082 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4083 
    result.write(oprot)
4084 
    oprot.writeMessageEnd()
4085 
    oprot.trans.flush()
4086 
 
690 chandransh 4087 
  def process_mergeCart(self, seqid, iprot, oprot):
4088 
    args = mergeCart_args()
575 chandransh 4089 
    args.read(iprot)
4090 
    iprot.readMessageEnd()
690 chandransh 4091 
    result = mergeCart_result()
4092 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4093 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4094 
    result.write(oprot)
4095 
    oprot.writeMessageEnd()
4096 
    oprot.trans.flush()
4097 
 
4098 
  def process_checkOut(self, seqid, iprot, oprot):
4099 
    args = checkOut_args()
4100 
    args.read(iprot)
4101 
    iprot.readMessageEnd()
4102 
    result = checkOut_result()
575 chandransh 4103 
    try:
690 chandransh 4104 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4105 
    except ShoppingCartException, scex:
4106 
      result.scex = scex
690 chandransh 4107 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4108 
    result.write(oprot)
4109 
    oprot.writeMessageEnd()
4110 
    oprot.trans.flush()
4111 
 
690 chandransh 4112 
  def process_resetCart(self, seqid, iprot, oprot):
4113 
    args = resetCart_args()
559 chandransh 4114 
    args.read(iprot)
4115 
    iprot.readMessageEnd()
690 chandransh 4116 
    result = resetCart_result()
4117 
    try:
4118 
      result.success = self._handler.resetCart(args.cartId, args.items)
4119 
    except ShoppingCartException, scex:
4120 
      result.scex = scex
4121 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4122 
    result.write(oprot)
4123 
    oprot.writeMessageEnd()
4124 
    oprot.trans.flush()
4125 
 
2981 rajveer 4126 
  def process_getUserCount(self, seqid, iprot, oprot):
4127 
    args = getUserCount_args()
559 chandransh 4128 
    args.read(iprot)
4129 
    iprot.readMessageEnd()
2981 rajveer 4130 
    result = getUserCount_result()
4131 
    result.success = self._handler.getUserCount(args.userType)
4132 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
2981 rajveer 4137 
  def process_getAllUsers(self, seqid, iprot, oprot):
4138 
    args = getAllUsers_args()
559 chandransh 4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
2981 rajveer 4141 
    result = getAllUsers_result()
4142 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4143 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4144 
    result.write(oprot)
4145 
    oprot.writeMessageEnd()
4146 
    oprot.trans.flush()
4147 
 
2981 rajveer 4148 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4149 
    args = getMyResearchItems_args()
559 chandransh 4150 
    args.read(iprot)
4151 
    iprot.readMessageEnd()
2981 rajveer 4152 
    result = getMyResearchItems_result()
559 chandransh 4153 
    try:
2981 rajveer 4154 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4155 
    except WidgetException, scx:
4156 
      result.scx = scx
2981 rajveer 4157 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4158 
    result.write(oprot)
4159 
    oprot.writeMessageEnd()
4160 
    oprot.trans.flush()
4161 
 
2981 rajveer 4162 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4163 
    args = updateMyResearch_args()
772 rajveer 4164 
    args.read(iprot)
4165 
    iprot.readMessageEnd()
2981 rajveer 4166 
    result = updateMyResearch_result()
4167 
    try:
4168 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4169 
    except WidgetException, scx:
4170 
      result.scx = scx
4171 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4172 
    result.write(oprot)
4173 
    oprot.writeMessageEnd()
4174 
    oprot.trans.flush()
559 chandransh 4175 
 
2981 rajveer 4176 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4177 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4178 
    args.read(iprot)
4179 
    iprot.readMessageEnd()
2981 rajveer 4180 
    result = deleteItemFromMyResearch_result()
4181 
    try:
4182 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4183 
    except WidgetException, scx:
4184 
      result.scx = scx
4185 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4186 
    result.write(oprot)
4187 
    oprot.writeMessageEnd()
4188 
    oprot.trans.flush()
772 rajveer 4189 
 
2981 rajveer 4190 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4191 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4192 
    args.read(iprot)
4193 
    iprot.readMessageEnd()
2981 rajveer 4194 
    result = getBrowseHistoryItems_result()
4195 
    try:
4196 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4197 
    except WidgetException, scx:
4198 
      result.scx = scx
4199 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
1596 ankur.sing 4203 
 
2981 rajveer 4204 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4205 
    args = updateBrowseHistory_args()
2642 varun.gupt 4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
2981 rajveer 4208 
    result = updateBrowseHistory_result()
4209 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4210 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4211 
    result.write(oprot)
4212 
    oprot.writeMessageEnd()
4213 
    oprot.trans.flush()
1673 ankur.sing 4214 
 
3385 varun.gupt 4215 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4216 
    args = getCartsWithCouponCount_args()
4217 
    args.read(iprot)
4218 
    iprot.readMessageEnd()
4219 
    result = getCartsWithCouponCount_result()
4220 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4221 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4222 
    result.write(oprot)
4223 
    oprot.writeMessageEnd()
4224 
    oprot.trans.flush()
2642 varun.gupt 4225 
 
3499 mandeep.dh 4226 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4227 
    args = increaseTrustLevel_args()
4228 
    args.read(iprot)
4229 
    iprot.readMessageEnd()
4230 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4231 
    return
3385 varun.gupt 4232 
 
5407 amar.kumar 4233 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4234 
    args = getTrustLevel_args()
4235 
    args.read(iprot)
4236 
    iprot.readMessageEnd()
4237 
    result = getTrustLevel_result()
4238 
    result.success = self._handler.getTrustLevel(args.userId)
4239 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4240 
    result.write(oprot)
4241 
    oprot.writeMessageEnd()
4242 
    oprot.trans.flush()
4243 
 
4668 varun.gupt 4244 
  def process_showCODOption(self, seqid, iprot, oprot):
4245 
    args = showCODOption_args()
4246 
    args.read(iprot)
4247 
    iprot.readMessageEnd()
4248 
    result = showCODOption_result()
4249 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4250 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4251 
    result.write(oprot)
4252 
    oprot.writeMessageEnd()
4253 
    oprot.trans.flush()
3499 mandeep.dh 4254 
 
5623 anupam.sin 4255 
  def process_getUserEmails(self, seqid, iprot, oprot):
4256 
    args = getUserEmails_args()
4257 
    args.read(iprot)
4258 
    iprot.readMessageEnd()
4259 
    result = getUserEmails_result()
4260 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4261 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4262 
    result.write(oprot)
4263 
    oprot.writeMessageEnd()
4264 
    oprot.trans.flush()
4668 varun.gupt 4265 
 
6903 anupam.sin 4266 
  def process_insureItem(self, seqid, iprot, oprot):
4267 
    args = insureItem_args()
4268 
    args.read(iprot)
4269 
    iprot.readMessageEnd()
4270 
    result = insureItem_result()
9299 kshitij.so 4271 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4272 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4273 
    result.write(oprot)
4274 
    oprot.writeMessageEnd()
4275 
    oprot.trans.flush()
4276 
 
4277 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4278 
    args = cancelInsurance_args()
4279 
    args.read(iprot)
4280 
    iprot.readMessageEnd()
4281 
    result = cancelInsurance_result()
4282 
    result.success = self._handler.cancelInsurance(args.cartId)
4283 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4284 
    result.write(oprot)
4285 
    oprot.writeMessageEnd()
4286 
    oprot.trans.flush()
4287 
 
4288 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4289 
    args = storeInsuranceSpecificDetails_args()
4290 
    args.read(iprot)
4291 
    iprot.readMessageEnd()
4292 
    result = storeInsuranceSpecificDetails_result()
4293 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4294 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4295 
    result.write(oprot)
4296 
    oprot.writeMessageEnd()
4297 
    oprot.trans.flush()
4298 
 
4299 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4300 
    args = isInsuranceDetailPresent_args()
4301 
    args.read(iprot)
4302 
    iprot.readMessageEnd()
4303 
    result = isInsuranceDetailPresent_result()
4304 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4305 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4306 
    result.write(oprot)
4307 
    oprot.writeMessageEnd()
4308 
    oprot.trans.flush()
4309 
 
9791 rajveer 4310 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4311 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4312 
    args.read(iprot)
4313 
    iprot.readMessageEnd()
9791 rajveer 4314 
    result = getProductsAddedToCart_result()
4315 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4316 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4317 
    result.write(oprot)
4318 
    oprot.writeMessageEnd()
4319 
    oprot.trans.flush()
5623 anupam.sin 4320 
 
11592 amit.gupta 4321 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4322 
    args = validateCartPlus_args()
4323 
    args.read(iprot)
4324 
    iprot.readMessageEnd()
4325 
    result = validateCartPlus_result()
4326 
    try:
4327 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId)
4328 
    except ShoppingCartException, scex:
4329 
      result.scex = scex
4330 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4331 
    result.write(oprot)
4332 
    oprot.writeMessageEnd()
4333 
    oprot.trans.flush()
6821 amar.kumar 4334 
 
11679 vikram.rag 4335 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4336 
    args = isPrivateDealUser_args()
4337 
    args.read(iprot)
4338 
    iprot.readMessageEnd()
4339 
    result = isPrivateDealUser_result()
4340 
    result.success = self._handler.isPrivateDealUser(args.userId)
4341 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4342 
    result.write(oprot)
4343 
    oprot.writeMessageEnd()
4344 
    oprot.trans.flush()
11592 amit.gupta 4345 
 
11890 kshitij.so 4346 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4347 
    args = addPrivateDealUser_args()
4348 
    args.read(iprot)
4349 
    iprot.readMessageEnd()
4350 
    result = addPrivateDealUser_result()
4351 
    result.success = self._handler.addPrivateDealUser(args.userId)
4352 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
11679 vikram.rag 4356 
 
11890 kshitij.so 4357 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4358 
    args = changePrivateDealUserStatus_args()
4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
4361 
    result = changePrivateDealUserStatus_result()
4362 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4363 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4364 
    result.write(oprot)
4365 
    oprot.writeMessageEnd()
4366 
    oprot.trans.flush()
4367 
 
4368 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4369 
    args = getPrivateDealUser_args()
4370 
    args.read(iprot)
4371 
    iprot.readMessageEnd()
4372 
    result = getPrivateDealUser_result()
4373 
    result.success = self._handler.getPrivateDealUser(args.userId)
4374 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4375 
    result.write(oprot)
4376 
    oprot.writeMessageEnd()
4377 
    oprot.trans.flush()
4378 
 
4379 
 
94 ashish 4380 
# HELPER FUNCTIONS AND STRUCTURES
4381 
 
559 chandransh 4382 
class createAnonymousUser_args:
94 ashish 4383 
  """
4384 
  Attributes:
559 chandransh 4385 
   - jsessionId
94 ashish 4386 
  """
4387 
 
4388 
  thrift_spec = (
4389 
    None, # 0
559 chandransh 4390 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4391 
  )
4392 
 
559 chandransh 4393 
  def __init__(self, jsessionId=None,):
4394 
    self.jsessionId = jsessionId
94 ashish 4395 
 
4396 
  def read(self, iprot):
4397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4399 
      return
4400 
    iprot.readStructBegin()
4401 
    while True:
4402 
      (fname, ftype, fid) = iprot.readFieldBegin()
4403 
      if ftype == TType.STOP:
4404 
        break
4405 
      if fid == 1:
559 chandransh 4406 
        if ftype == TType.STRING:
4407 
          self.jsessionId = iprot.readString();
94 ashish 4408 
        else:
4409 
          iprot.skip(ftype)
4410 
      else:
4411 
        iprot.skip(ftype)
4412 
      iprot.readFieldEnd()
4413 
    iprot.readStructEnd()
4414 
 
4415 
  def write(self, oprot):
4416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4418 
      return
559 chandransh 4419 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4420 
    if self.jsessionId is not None:
559 chandransh 4421 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4422 
      oprot.writeString(self.jsessionId)
94 ashish 4423 
      oprot.writeFieldEnd()
4424 
    oprot.writeFieldStop()
4425 
    oprot.writeStructEnd()
4426 
 
3431 rajveer 4427 
  def validate(self):
4428 
    return
4429 
 
4430 
 
94 ashish 4431 
  def __repr__(self):
4432 
    L = ['%s=%r' % (key, value)
4433 
      for key, value in self.__dict__.iteritems()]
4434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4435 
 
4436 
  def __eq__(self, other):
4437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4438 
 
4439 
  def __ne__(self, other):
4440 
    return not (self == other)
4441 
 
559 chandransh 4442 
class createAnonymousUser_result:
94 ashish 4443 
  """
4444 
  Attributes:
4445 
   - success
559 chandransh 4446 
   - ucex
94 ashish 4447 
  """
4448 
 
4449 
  thrift_spec = (
559 chandransh 4450 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4451 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4452 
  )
4453 
 
559 chandransh 4454 
  def __init__(self, success=None, ucex=None,):
94 ashish 4455 
    self.success = success
559 chandransh 4456 
    self.ucex = ucex
94 ashish 4457 
 
4458 
  def read(self, iprot):
4459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4461 
      return
4462 
    iprot.readStructBegin()
4463 
    while True:
4464 
      (fname, ftype, fid) = iprot.readFieldBegin()
4465 
      if ftype == TType.STOP:
4466 
        break
4467 
      if fid == 0:
4468 
        if ftype == TType.STRUCT:
559 chandransh 4469 
          self.success = User()
94 ashish 4470 
          self.success.read(iprot)
4471 
        else:
4472 
          iprot.skip(ftype)
4473 
      elif fid == 1:
4474 
        if ftype == TType.STRUCT:
559 chandransh 4475 
          self.ucex = UserContextException()
4476 
          self.ucex.read(iprot)
94 ashish 4477 
        else:
4478 
          iprot.skip(ftype)
4479 
      else:
4480 
        iprot.skip(ftype)
4481 
      iprot.readFieldEnd()
4482 
    iprot.readStructEnd()
4483 
 
4484 
  def write(self, oprot):
4485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4487 
      return
559 chandransh 4488 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4489 
    if self.success is not None:
94 ashish 4490 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4491 
      self.success.write(oprot)
4492 
      oprot.writeFieldEnd()
3431 rajveer 4493 
    if self.ucex is not None:
559 chandransh 4494 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4495 
      self.ucex.write(oprot)
94 ashish 4496 
      oprot.writeFieldEnd()
4497 
    oprot.writeFieldStop()
4498 
    oprot.writeStructEnd()
4499 
 
3431 rajveer 4500 
  def validate(self):
4501 
    return
4502 
 
4503 
 
94 ashish 4504 
  def __repr__(self):
4505 
    L = ['%s=%r' % (key, value)
4506 
      for key, value in self.__dict__.iteritems()]
4507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4508 
 
4509 
  def __eq__(self, other):
4510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4511 
 
4512 
  def __ne__(self, other):
4513 
    return not (self == other)
4514 
 
559 chandransh 4515 
class getUserById_args:
94 ashish 4516 
  """
4517 
  Attributes:
4518 
   - userId
4519 
  """
4520 
 
4521 
  thrift_spec = (
4522 
    None, # 0
4523 
    (1, TType.I64, 'userId', None, None, ), # 1
4524 
  )
4525 
 
559 chandransh 4526 
  def __init__(self, userId=None,):
94 ashish 4527 
    self.userId = userId
4528 
 
4529 
  def read(self, iprot):
4530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4532 
      return
4533 
    iprot.readStructBegin()
4534 
    while True:
4535 
      (fname, ftype, fid) = iprot.readFieldBegin()
4536 
      if ftype == TType.STOP:
4537 
        break
4538 
      if fid == 1:
4539 
        if ftype == TType.I64:
4540 
          self.userId = iprot.readI64();
4541 
        else:
4542 
          iprot.skip(ftype)
4543 
      else:
4544 
        iprot.skip(ftype)
4545 
      iprot.readFieldEnd()
4546 
    iprot.readStructEnd()
4547 
 
4548 
  def write(self, oprot):
4549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4551 
      return
559 chandransh 4552 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4553 
    if self.userId is not None:
94 ashish 4554 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4555 
      oprot.writeI64(self.userId)
4556 
      oprot.writeFieldEnd()
4557 
    oprot.writeFieldStop()
4558 
    oprot.writeStructEnd()
4559 
 
3431 rajveer 4560 
  def validate(self):
4561 
    return
4562 
 
4563 
 
94 ashish 4564 
  def __repr__(self):
4565 
    L = ['%s=%r' % (key, value)
4566 
      for key, value in self.__dict__.iteritems()]
4567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4568 
 
4569 
  def __eq__(self, other):
4570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4571 
 
4572 
  def __ne__(self, other):
4573 
    return not (self == other)
4574 
 
559 chandransh 4575 
class getUserById_result:
94 ashish 4576 
  """
4577 
  Attributes:
4578 
   - success
559 chandransh 4579 
   - ucex
94 ashish 4580 
  """
4581 
 
4582 
  thrift_spec = (
559 chandransh 4583 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4584 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4585 
  )
4586 
 
559 chandransh 4587 
  def __init__(self, success=None, ucex=None,):
94 ashish 4588 
    self.success = success
559 chandransh 4589 
    self.ucex = ucex
94 ashish 4590 
 
4591 
  def read(self, iprot):
4592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4594 
      return
4595 
    iprot.readStructBegin()
4596 
    while True:
4597 
      (fname, ftype, fid) = iprot.readFieldBegin()
4598 
      if ftype == TType.STOP:
4599 
        break
4600 
      if fid == 0:
4601 
        if ftype == TType.STRUCT:
559 chandransh 4602 
          self.success = User()
94 ashish 4603 
          self.success.read(iprot)
4604 
        else:
4605 
          iprot.skip(ftype)
4606 
      elif fid == 1:
4607 
        if ftype == TType.STRUCT:
559 chandransh 4608 
          self.ucex = UserContextException()
4609 
          self.ucex.read(iprot)
94 ashish 4610 
        else:
4611 
          iprot.skip(ftype)
4612 
      else:
4613 
        iprot.skip(ftype)
4614 
      iprot.readFieldEnd()
4615 
    iprot.readStructEnd()
4616 
 
4617 
  def write(self, oprot):
4618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4620 
      return
559 chandransh 4621 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4622 
    if self.success is not None:
94 ashish 4623 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4624 
      self.success.write(oprot)
4625 
      oprot.writeFieldEnd()
3431 rajveer 4626 
    if self.ucex is not None:
559 chandransh 4627 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4628 
      self.ucex.write(oprot)
94 ashish 4629 
      oprot.writeFieldEnd()
4630 
    oprot.writeFieldStop()
4631 
    oprot.writeStructEnd()
4632 
 
3431 rajveer 4633 
  def validate(self):
4634 
    return
4635 
 
4636 
 
94 ashish 4637 
  def __repr__(self):
4638 
    L = ['%s=%r' % (key, value)
4639 
      for key, value in self.__dict__.iteritems()]
4640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4641 
 
4642 
  def __eq__(self, other):
4643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4644 
 
4645 
  def __ne__(self, other):
4646 
    return not (self == other)
4647 
 
5326 rajveer 4648 
class getUserByCartId_args:
1491 vikas 4649 
  """
4650 
  Attributes:
5326 rajveer 4651 
   - cartId
1491 vikas 4652 
  """
4653 
 
4654 
  thrift_spec = (
4655 
    None, # 0
5326 rajveer 4656 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4657 
  )
4658 
 
5326 rajveer 4659 
  def __init__(self, cartId=None,):
4660 
    self.cartId = cartId
1491 vikas 4661 
 
4662 
  def read(self, iprot):
4663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4665 
      return
4666 
    iprot.readStructBegin()
4667 
    while True:
4668 
      (fname, ftype, fid) = iprot.readFieldBegin()
4669 
      if ftype == TType.STOP:
4670 
        break
4671 
      if fid == 1:
5326 rajveer 4672 
        if ftype == TType.I64:
4673 
          self.cartId = iprot.readI64();
1491 vikas 4674 
        else:
4675 
          iprot.skip(ftype)
4676 
      else:
4677 
        iprot.skip(ftype)
4678 
      iprot.readFieldEnd()
4679 
    iprot.readStructEnd()
4680 
 
4681 
  def write(self, oprot):
4682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4684 
      return
5326 rajveer 4685 
    oprot.writeStructBegin('getUserByCartId_args')
4686 
    if self.cartId is not None:
4687 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4688 
      oprot.writeI64(self.cartId)
1491 vikas 4689 
      oprot.writeFieldEnd()
4690 
    oprot.writeFieldStop()
4691 
    oprot.writeStructEnd()
4692 
 
3431 rajveer 4693 
  def validate(self):
4694 
    return
4695 
 
4696 
 
1491 vikas 4697 
  def __repr__(self):
4698 
    L = ['%s=%r' % (key, value)
4699 
      for key, value in self.__dict__.iteritems()]
4700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4701 
 
4702 
  def __eq__(self, other):
4703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4704 
 
4705 
  def __ne__(self, other):
4706 
    return not (self == other)
4707 
 
5326 rajveer 4708 
class getUserByCartId_result:
1491 vikas 4709 
  """
4710 
  Attributes:
4711 
   - success
4712 
   - ucex
4713 
  """
4714 
 
4715 
  thrift_spec = (
4716 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4717 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4718 
  )
4719 
 
4720 
  def __init__(self, success=None, ucex=None,):
4721 
    self.success = success
4722 
    self.ucex = ucex
4723 
 
4724 
  def read(self, iprot):
4725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4727 
      return
4728 
    iprot.readStructBegin()
4729 
    while True:
4730 
      (fname, ftype, fid) = iprot.readFieldBegin()
4731 
      if ftype == TType.STOP:
4732 
        break
4733 
      if fid == 0:
4734 
        if ftype == TType.STRUCT:
4735 
          self.success = User()
4736 
          self.success.read(iprot)
4737 
        else:
4738 
          iprot.skip(ftype)
4739 
      elif fid == 1:
4740 
        if ftype == TType.STRUCT:
4741 
          self.ucex = UserContextException()
4742 
          self.ucex.read(iprot)
4743 
        else:
4744 
          iprot.skip(ftype)
4745 
      else:
4746 
        iprot.skip(ftype)
4747 
      iprot.readFieldEnd()
4748 
    iprot.readStructEnd()
4749 
 
4750 
  def write(self, oprot):
4751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4753 
      return
5326 rajveer 4754 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 4755 
    if self.success is not None:
1491 vikas 4756 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4757 
      self.success.write(oprot)
4758 
      oprot.writeFieldEnd()
3431 rajveer 4759 
    if self.ucex is not None:
1491 vikas 4760 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4761 
      self.ucex.write(oprot)
4762 
      oprot.writeFieldEnd()
4763 
    oprot.writeFieldStop()
4764 
    oprot.writeStructEnd()
4765 
 
3431 rajveer 4766 
  def validate(self):
4767 
    return
4768 
 
4769 
 
1491 vikas 4770 
  def __repr__(self):
4771 
    L = ['%s=%r' % (key, value)
4772 
      for key, value in self.__dict__.iteritems()]
4773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4774 
 
4775 
  def __eq__(self, other):
4776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4777 
 
4778 
  def __ne__(self, other):
4779 
    return not (self == other)
4780 
 
5326 rajveer 4781 
class getUserByEmail_args:
3032 mandeep.dh 4782 
  """
4783 
  Attributes:
5326 rajveer 4784 
   - email
3032 mandeep.dh 4785 
  """
4786 
 
4787 
  thrift_spec = (
4788 
    None, # 0
5326 rajveer 4789 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 4790 
  )
4791 
 
5326 rajveer 4792 
  def __init__(self, email=None,):
4793 
    self.email = email
3032 mandeep.dh 4794 
 
4795 
  def read(self, iprot):
4796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4798 
      return
4799 
    iprot.readStructBegin()
4800 
    while True:
4801 
      (fname, ftype, fid) = iprot.readFieldBegin()
4802 
      if ftype == TType.STOP:
4803 
        break
4804 
      if fid == 1:
5326 rajveer 4805 
        if ftype == TType.STRING:
4806 
          self.email = iprot.readString();
3032 mandeep.dh 4807 
        else:
4808 
          iprot.skip(ftype)
4809 
      else:
4810 
        iprot.skip(ftype)
4811 
      iprot.readFieldEnd()
4812 
    iprot.readStructEnd()
4813 
 
4814 
  def write(self, oprot):
4815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4817 
      return
5326 rajveer 4818 
    oprot.writeStructBegin('getUserByEmail_args')
4819 
    if self.email is not None:
4820 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4821 
      oprot.writeString(self.email)
3032 mandeep.dh 4822 
      oprot.writeFieldEnd()
4823 
    oprot.writeFieldStop()
4824 
    oprot.writeStructEnd()
4825 
 
3431 rajveer 4826 
  def validate(self):
4827 
    return
4828 
 
4829 
 
3032 mandeep.dh 4830 
  def __repr__(self):
4831 
    L = ['%s=%r' % (key, value)
4832 
      for key, value in self.__dict__.iteritems()]
4833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4834 
 
4835 
  def __eq__(self, other):
4836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4837 
 
4838 
  def __ne__(self, other):
4839 
    return not (self == other)
4840 
 
5326 rajveer 4841 
class getUserByEmail_result:
3032 mandeep.dh 4842 
  """
4843 
  Attributes:
4844 
   - success
4845 
   - ucex
4846 
  """
4847 
 
4848 
  thrift_spec = (
4849 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4850 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4851 
  )
4852 
 
4853 
  def __init__(self, success=None, ucex=None,):
4854 
    self.success = success
4855 
    self.ucex = ucex
4856 
 
4857 
  def read(self, iprot):
4858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4860 
      return
4861 
    iprot.readStructBegin()
4862 
    while True:
4863 
      (fname, ftype, fid) = iprot.readFieldBegin()
4864 
      if ftype == TType.STOP:
4865 
        break
4866 
      if fid == 0:
4867 
        if ftype == TType.STRUCT:
4868 
          self.success = User()
4869 
          self.success.read(iprot)
4870 
        else:
4871 
          iprot.skip(ftype)
4872 
      elif fid == 1:
4873 
        if ftype == TType.STRUCT:
4874 
          self.ucex = UserContextException()
4875 
          self.ucex.read(iprot)
4876 
        else:
4877 
          iprot.skip(ftype)
4878 
      else:
4879 
        iprot.skip(ftype)
4880 
      iprot.readFieldEnd()
4881 
    iprot.readStructEnd()
4882 
 
4883 
  def write(self, oprot):
4884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4886 
      return
5326 rajveer 4887 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 4888 
    if self.success is not None:
3032 mandeep.dh 4889 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4890 
      self.success.write(oprot)
4891 
      oprot.writeFieldEnd()
3431 rajveer 4892 
    if self.ucex is not None:
3032 mandeep.dh 4893 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4894 
      self.ucex.write(oprot)
4895 
      oprot.writeFieldEnd()
4896 
    oprot.writeFieldStop()
4897 
    oprot.writeStructEnd()
4898 
 
3431 rajveer 4899 
  def validate(self):
4900 
    return
4901 
 
4902 
 
3032 mandeep.dh 4903 
  def __repr__(self):
4904 
    L = ['%s=%r' % (key, value)
4905 
      for key, value in self.__dict__.iteritems()]
4906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4907 
 
4908 
  def __eq__(self, other):
4909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4910 
 
4911 
  def __ne__(self, other):
4912 
    return not (self == other)
4913 
 
5326 rajveer 4914 
class getUserByMobileNumber_args:
94 ashish 4915 
  """
4916 
  Attributes:
5326 rajveer 4917 
   - mobileNumber
94 ashish 4918 
  """
4919 
 
4920 
  thrift_spec = (
4921 
    None, # 0
5326 rajveer 4922 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 4923 
  )
4924 
 
5326 rajveer 4925 
  def __init__(self, mobileNumber=None,):
4926 
    self.mobileNumber = mobileNumber
94 ashish 4927 
 
4928 
  def read(self, iprot):
4929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4931 
      return
4932 
    iprot.readStructBegin()
4933 
    while True:
4934 
      (fname, ftype, fid) = iprot.readFieldBegin()
4935 
      if ftype == TType.STOP:
4936 
        break
4937 
      if fid == 1:
5326 rajveer 4938 
        if ftype == TType.I64:
4939 
          self.mobileNumber = iprot.readI64();
94 ashish 4940 
        else:
4941 
          iprot.skip(ftype)
4942 
      else:
4943 
        iprot.skip(ftype)
4944 
      iprot.readFieldEnd()
4945 
    iprot.readStructEnd()
4946 
 
4947 
  def write(self, oprot):
4948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4950 
      return
5326 rajveer 4951 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4952 
    if self.mobileNumber is not None:
4953 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4954 
      oprot.writeI64(self.mobileNumber)
94 ashish 4955 
      oprot.writeFieldEnd()
4956 
    oprot.writeFieldStop()
4957 
    oprot.writeStructEnd()
4958 
 
3431 rajveer 4959 
  def validate(self):
4960 
    return
4961 
 
4962 
 
94 ashish 4963 
  def __repr__(self):
4964 
    L = ['%s=%r' % (key, value)
4965 
      for key, value in self.__dict__.iteritems()]
4966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4967 
 
4968 
  def __eq__(self, other):
4969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4970 
 
4971 
  def __ne__(self, other):
4972 
    return not (self == other)
4973 
 
5326 rajveer 4974 
class getUserByMobileNumber_result:
94 ashish 4975 
  """
4976 
  Attributes:
4977 
   - success
559 chandransh 4978 
   - ucex
94 ashish 4979 
  """
4980 
 
4981 
  thrift_spec = (
559 chandransh 4982 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4983 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4984 
  )
4985 
 
559 chandransh 4986 
  def __init__(self, success=None, ucex=None,):
94 ashish 4987 
    self.success = success
559 chandransh 4988 
    self.ucex = ucex
94 ashish 4989 
 
4990 
  def read(self, iprot):
4991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4993 
      return
4994 
    iprot.readStructBegin()
4995 
    while True:
4996 
      (fname, ftype, fid) = iprot.readFieldBegin()
4997 
      if ftype == TType.STOP:
4998 
        break
4999 
      if fid == 0:
5000 
        if ftype == TType.STRUCT:
559 chandransh 5001 
          self.success = User()
94 ashish 5002 
          self.success.read(iprot)
5003 
        else:
5004 
          iprot.skip(ftype)
5005 
      elif fid == 1:
5006 
        if ftype == TType.STRUCT:
559 chandransh 5007 
          self.ucex = UserContextException()
5008 
          self.ucex.read(iprot)
94 ashish 5009 
        else:
5010 
          iprot.skip(ftype)
5011 
      else:
5012 
        iprot.skip(ftype)
5013 
      iprot.readFieldEnd()
5014 
    iprot.readStructEnd()
5015 
 
5016 
  def write(self, oprot):
5017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5019 
      return
5326 rajveer 5020 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5021 
    if self.success is not None:
94 ashish 5022 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5023 
      self.success.write(oprot)
5024 
      oprot.writeFieldEnd()
3431 rajveer 5025 
    if self.ucex is not None:
559 chandransh 5026 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5027 
      self.ucex.write(oprot)
94 ashish 5028 
      oprot.writeFieldEnd()
5029 
    oprot.writeFieldStop()
5030 
    oprot.writeStructEnd()
5031 
 
3431 rajveer 5032 
  def validate(self):
5033 
    return
5034 
 
5035 
 
94 ashish 5036 
  def __repr__(self):
5037 
    L = ['%s=%r' % (key, value)
5038 
      for key, value in self.__dict__.iteritems()]
5039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5040 
 
5041 
  def __eq__(self, other):
5042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5043 
 
5044 
  def __ne__(self, other):
5045 
    return not (self == other)
5046 
 
5326 rajveer 5047 
class createUser_args:
94 ashish 5048 
  """
5049 
  Attributes:
559 chandransh 5050 
   - user
94 ashish 5051 
  """
5052 
 
5053 
  thrift_spec = (
5054 
    None, # 0
559 chandransh 5055 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5056 
  )
5057 
 
559 chandransh 5058 
  def __init__(self, user=None,):
5059 
    self.user = user
94 ashish 5060 
 
5061 
  def read(self, iprot):
5062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5064 
      return
5065 
    iprot.readStructBegin()
5066 
    while True:
5067 
      (fname, ftype, fid) = iprot.readFieldBegin()
5068 
      if ftype == TType.STOP:
5069 
        break
5070 
      if fid == 1:
559 chandransh 5071 
        if ftype == TType.STRUCT:
5072 
          self.user = User()
5073 
          self.user.read(iprot)
94 ashish 5074 
        else:
5075 
          iprot.skip(ftype)
5076 
      else:
5077 
        iprot.skip(ftype)
5078 
      iprot.readFieldEnd()
5079 
    iprot.readStructEnd()
5080 
 
5081 
  def write(self, oprot):
5082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5084 
      return
5326 rajveer 5085 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5086 
    if self.user is not None:
559 chandransh 5087 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5088 
      self.user.write(oprot)
94 ashish 5089 
      oprot.writeFieldEnd()
5090 
    oprot.writeFieldStop()
5091 
    oprot.writeStructEnd()
5092 
 
3431 rajveer 5093 
  def validate(self):
5094 
    return
5095 
 
5096 
 
94 ashish 5097 
  def __repr__(self):
5098 
    L = ['%s=%r' % (key, value)
5099 
      for key, value in self.__dict__.iteritems()]
5100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5101 
 
5102 
  def __eq__(self, other):
5103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5104 
 
5105 
  def __ne__(self, other):
5106 
    return not (self == other)
5107 
 
5326 rajveer 5108 
class createUser_result:
94 ashish 5109 
  """
5110 
  Attributes:
5111 
   - success
559 chandransh 5112 
   - ucex
94 ashish 5113 
  """
5114 
 
5115 
  thrift_spec = (
559 chandransh 5116 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5117 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5118 
  )
5119 
 
559 chandransh 5120 
  def __init__(self, success=None, ucex=None,):
94 ashish 5121 
    self.success = success
559 chandransh 5122 
    self.ucex = ucex
94 ashish 5123 
 
5124 
  def read(self, iprot):
5125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5127 
      return
5128 
    iprot.readStructBegin()
5129 
    while True:
5130 
      (fname, ftype, fid) = iprot.readFieldBegin()
5131 
      if ftype == TType.STOP:
5132 
        break
5133 
      if fid == 0:
5134 
        if ftype == TType.STRUCT:
559 chandransh 5135 
          self.success = User()
94 ashish 5136 
          self.success.read(iprot)
5137 
        else:
5138 
          iprot.skip(ftype)
5139 
      elif fid == 1:
5140 
        if ftype == TType.STRUCT:
559 chandransh 5141 
          self.ucex = UserContextException()
5142 
          self.ucex.read(iprot)
94 ashish 5143 
        else:
5144 
          iprot.skip(ftype)
5145 
      else:
5146 
        iprot.skip(ftype)
5147 
      iprot.readFieldEnd()
5148 
    iprot.readStructEnd()
5149 
 
5150 
  def write(self, oprot):
5151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5153 
      return
5326 rajveer 5154 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5155 
    if self.success is not None:
94 ashish 5156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5157 
      self.success.write(oprot)
5158 
      oprot.writeFieldEnd()
3431 rajveer 5159 
    if self.ucex is not None:
559 chandransh 5160 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5161 
      self.ucex.write(oprot)
94 ashish 5162 
      oprot.writeFieldEnd()
5163 
    oprot.writeFieldStop()
5164 
    oprot.writeStructEnd()
5165 
 
3431 rajveer 5166 
  def validate(self):
5167 
    return
5168 
 
5169 
 
94 ashish 5170 
  def __repr__(self):
5171 
    L = ['%s=%r' % (key, value)
5172 
      for key, value in self.__dict__.iteritems()]
5173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5174 
 
5175 
  def __eq__(self, other):
5176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5177 
 
5178 
  def __ne__(self, other):
5179 
    return not (self == other)
5180 
 
5326 rajveer 5181 
class updateUser_args:
94 ashish 5182 
  """
5183 
  Attributes:
5326 rajveer 5184 
   - user
94 ashish 5185 
  """
5186 
 
5187 
  thrift_spec = (
5188 
    None, # 0
5326 rajveer 5189 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5190 
  )
5191 
 
5326 rajveer 5192 
  def __init__(self, user=None,):
5193 
    self.user = user
94 ashish 5194 
 
5195 
  def read(self, iprot):
5196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5198 
      return
5199 
    iprot.readStructBegin()
5200 
    while True:
5201 
      (fname, ftype, fid) = iprot.readFieldBegin()
5202 
      if ftype == TType.STOP:
5203 
        break
5204 
      if fid == 1:
5326 rajveer 5205 
        if ftype == TType.STRUCT:
5206 
          self.user = User()
5207 
          self.user.read(iprot)
94 ashish 5208 
        else:
5209 
          iprot.skip(ftype)
5210 
      else:
5211 
        iprot.skip(ftype)
5212 
      iprot.readFieldEnd()
5213 
    iprot.readStructEnd()
5214 
 
5215 
  def write(self, oprot):
5216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5218 
      return
5326 rajveer 5219 
    oprot.writeStructBegin('updateUser_args')
5220 
    if self.user is not None:
5221 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5222 
      self.user.write(oprot)
94 ashish 5223 
      oprot.writeFieldEnd()
5224 
    oprot.writeFieldStop()
5225 
    oprot.writeStructEnd()
5226 
 
3431 rajveer 5227 
  def validate(self):
5228 
    return
5229 
 
5230 
 
94 ashish 5231 
  def __repr__(self):
5232 
    L = ['%s=%r' % (key, value)
5233 
      for key, value in self.__dict__.iteritems()]
5234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5235 
 
5236 
  def __eq__(self, other):
5237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5238 
 
5239 
  def __ne__(self, other):
5240 
    return not (self == other)
5241 
 
5326 rajveer 5242 
class updateUser_result:
94 ashish 5243 
  """
5244 
  Attributes:
5245 
   - success
559 chandransh 5246 
   - ucex
94 ashish 5247 
  """
5248 
 
5249 
  thrift_spec = (
5326 rajveer 5250 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5251 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5252 
  )
5253 
 
559 chandransh 5254 
  def __init__(self, success=None, ucex=None,):
94 ashish 5255 
    self.success = success
559 chandransh 5256 
    self.ucex = ucex
94 ashish 5257 
 
5258 
  def read(self, iprot):
5259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5261 
      return
5262 
    iprot.readStructBegin()
5263 
    while True:
5264 
      (fname, ftype, fid) = iprot.readFieldBegin()
5265 
      if ftype == TType.STOP:
5266 
        break
5267 
      if fid == 0:
5326 rajveer 5268 
        if ftype == TType.STRUCT:
5269 
          self.success = User()
5270 
          self.success.read(iprot)
94 ashish 5271 
        else:
5272 
          iprot.skip(ftype)
5273 
      elif fid == 1:
5274 
        if ftype == TType.STRUCT:
559 chandransh 5275 
          self.ucex = UserContextException()
5276 
          self.ucex.read(iprot)
94 ashish 5277 
        else:
5278 
          iprot.skip(ftype)
5279 
      else:
5280 
        iprot.skip(ftype)
5281 
      iprot.readFieldEnd()
5282 
    iprot.readStructEnd()
5283 
 
5284 
  def write(self, oprot):
5285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5287 
      return
5326 rajveer 5288 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5289 
    if self.success is not None:
5326 rajveer 5290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5291 
      self.success.write(oprot)
94 ashish 5292 
      oprot.writeFieldEnd()
3431 rajveer 5293 
    if self.ucex is not None:
559 chandransh 5294 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5295 
      self.ucex.write(oprot)
94 ashish 5296 
      oprot.writeFieldEnd()
5297 
    oprot.writeFieldStop()
5298 
    oprot.writeStructEnd()
5299 
 
3431 rajveer 5300 
  def validate(self):
5301 
    return
5302 
 
5303 
 
94 ashish 5304 
  def __repr__(self):
5305 
    L = ['%s=%r' % (key, value)
5306 
      for key, value in self.__dict__.iteritems()]
5307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5308 
 
5309 
  def __eq__(self, other):
5310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5311 
 
5312 
  def __ne__(self, other):
5313 
    return not (self == other)
5314 
 
559 chandransh 5315 
class authenticateUser_args:
94 ashish 5316 
  """
5317 
  Attributes:
5318 
   - email
5319 
   - password
5320 
  """
5321 
 
5322 
  thrift_spec = (
5323 
    None, # 0
5324 
    (1, TType.STRING, 'email', None, None, ), # 1
5325 
    (2, TType.STRING, 'password', None, None, ), # 2
5326 
  )
5327 
 
5328 
  def __init__(self, email=None, password=None,):
5329 
    self.email = email
5330 
    self.password = password
5331 
 
5332 
  def read(self, iprot):
5333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5335 
      return
5336 
    iprot.readStructBegin()
5337 
    while True:
5338 
      (fname, ftype, fid) = iprot.readFieldBegin()
5339 
      if ftype == TType.STOP:
5340 
        break
5341 
      if fid == 1:
5342 
        if ftype == TType.STRING:
5343 
          self.email = iprot.readString();
5344 
        else:
5345 
          iprot.skip(ftype)
5346 
      elif fid == 2:
5347 
        if ftype == TType.STRING:
5348 
          self.password = iprot.readString();
5349 
        else:
5350 
          iprot.skip(ftype)
5351 
      else:
5352 
        iprot.skip(ftype)
5353 
      iprot.readFieldEnd()
5354 
    iprot.readStructEnd()
5355 
 
5356 
  def write(self, oprot):
5357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5359 
      return
559 chandransh 5360 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5361 
    if self.email is not None:
94 ashish 5362 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5363 
      oprot.writeString(self.email)
5364 
      oprot.writeFieldEnd()
3431 rajveer 5365 
    if self.password is not None:
94 ashish 5366 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5367 
      oprot.writeString(self.password)
5368 
      oprot.writeFieldEnd()
5369 
    oprot.writeFieldStop()
5370 
    oprot.writeStructEnd()
5371 
 
3431 rajveer 5372 
  def validate(self):
5373 
    return
5374 
 
5375 
 
94 ashish 5376 
  def __repr__(self):
5377 
    L = ['%s=%r' % (key, value)
5378 
      for key, value in self.__dict__.iteritems()]
5379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5380 
 
5381 
  def __eq__(self, other):
5382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5383 
 
5384 
  def __ne__(self, other):
5385 
    return not (self == other)
5386 
 
559 chandransh 5387 
class authenticateUser_result:
94 ashish 5388 
  """
5389 
  Attributes:
5390 
   - success
559 chandransh 5391 
   - auex
94 ashish 5392 
  """
5393 
 
5394 
  thrift_spec = (
559 chandransh 5395 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5396 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5397 
  )
5398 
 
559 chandransh 5399 
  def __init__(self, success=None, auex=None,):
94 ashish 5400 
    self.success = success
559 chandransh 5401 
    self.auex = auex
94 ashish 5402 
 
5403 
  def read(self, iprot):
5404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5406 
      return
5407 
    iprot.readStructBegin()
5408 
    while True:
5409 
      (fname, ftype, fid) = iprot.readFieldBegin()
5410 
      if ftype == TType.STOP:
5411 
        break
5412 
      if fid == 0:
5413 
        if ftype == TType.STRUCT:
559 chandransh 5414 
          self.success = User()
94 ashish 5415 
          self.success.read(iprot)
5416 
        else:
5417 
          iprot.skip(ftype)
5418 
      elif fid == 1:
5419 
        if ftype == TType.STRUCT:
559 chandransh 5420 
          self.auex = AuthenticationException()
5421 
          self.auex.read(iprot)
94 ashish 5422 
        else:
5423 
          iprot.skip(ftype)
5424 
      else:
5425 
        iprot.skip(ftype)
5426 
      iprot.readFieldEnd()
5427 
    iprot.readStructEnd()
5428 
 
5429 
  def write(self, oprot):
5430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5432 
      return
559 chandransh 5433 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5434 
    if self.success is not None:
94 ashish 5435 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5436 
      self.success.write(oprot)
5437 
      oprot.writeFieldEnd()
3431 rajveer 5438 
    if self.auex is not None:
559 chandransh 5439 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5440 
      self.auex.write(oprot)
94 ashish 5441 
      oprot.writeFieldEnd()
5442 
    oprot.writeFieldStop()
5443 
    oprot.writeStructEnd()
5444 
 
3431 rajveer 5445 
  def validate(self):
5446 
    return
5447 
 
5448 
 
94 ashish 5449 
  def __repr__(self):
5450 
    L = ['%s=%r' % (key, value)
5451 
      for key, value in self.__dict__.iteritems()]
5452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5453 
 
5454 
  def __eq__(self, other):
5455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5456 
 
5457 
  def __ne__(self, other):
5458 
    return not (self == other)
5459 
 
559 chandransh 5460 
class userExists_args:
122 ashish 5461 
  """
5462 
  Attributes:
559 chandransh 5463 
   - email
122 ashish 5464 
  """
5465 
 
5466 
  thrift_spec = (
5467 
    None, # 0
559 chandransh 5468 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5469 
  )
5470 
 
559 chandransh 5471 
  def __init__(self, email=None,):
5472 
    self.email = email
122 ashish 5473 
 
5474 
  def read(self, iprot):
5475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5477 
      return
5478 
    iprot.readStructBegin()
5479 
    while True:
5480 
      (fname, ftype, fid) = iprot.readFieldBegin()
5481 
      if ftype == TType.STOP:
5482 
        break
5483 
      if fid == 1:
5484 
        if ftype == TType.STRING:
559 chandransh 5485 
          self.email = iprot.readString();
122 ashish 5486 
        else:
5487 
          iprot.skip(ftype)
559 chandransh 5488 
      else:
5489 
        iprot.skip(ftype)
5490 
      iprot.readFieldEnd()
5491 
    iprot.readStructEnd()
5492 
 
5493 
  def write(self, oprot):
5494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5496 
      return
5497 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5498 
    if self.email is not None:
559 chandransh 5499 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5500 
      oprot.writeString(self.email)
5501 
      oprot.writeFieldEnd()
5502 
    oprot.writeFieldStop()
5503 
    oprot.writeStructEnd()
5504 
 
3431 rajveer 5505 
  def validate(self):
5506 
    return
5507 
 
5508 
 
559 chandransh 5509 
  def __repr__(self):
5510 
    L = ['%s=%r' % (key, value)
5511 
      for key, value in self.__dict__.iteritems()]
5512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5513 
 
5514 
  def __eq__(self, other):
5515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5516 
 
5517 
  def __ne__(self, other):
5518 
    return not (self == other)
5519 
 
5520 
class userExists_result:
5521 
  """
5522 
  Attributes:
5523 
   - success
5524 
   - ucx
5525 
  """
5526 
 
5527 
  thrift_spec = (
5528 
    (0, TType.BOOL, 'success', None, None, ), # 0
5529 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5530 
  )
5531 
 
5532 
  def __init__(self, success=None, ucx=None,):
5533 
    self.success = success
5534 
    self.ucx = ucx
5535 
 
5536 
  def read(self, iprot):
5537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5539 
      return
5540 
    iprot.readStructBegin()
5541 
    while True:
5542 
      (fname, ftype, fid) = iprot.readFieldBegin()
5543 
      if ftype == TType.STOP:
5544 
        break
5545 
      if fid == 0:
5546 
        if ftype == TType.BOOL:
5547 
          self.success = iprot.readBool();
5548 
        else:
5549 
          iprot.skip(ftype)
5550 
      elif fid == 1:
5551 
        if ftype == TType.STRUCT:
5552 
          self.ucx = UserContextException()
5553 
          self.ucx.read(iprot)
5554 
        else:
5555 
          iprot.skip(ftype)
5556 
      else:
5557 
        iprot.skip(ftype)
5558 
      iprot.readFieldEnd()
5559 
    iprot.readStructEnd()
5560 
 
5561 
  def write(self, oprot):
5562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5564 
      return
5565 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5566 
    if self.success is not None:
559 chandransh 5567 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5568 
      oprot.writeBool(self.success)
5569 
      oprot.writeFieldEnd()
3431 rajveer 5570 
    if self.ucx is not None:
559 chandransh 5571 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5572 
      self.ucx.write(oprot)
5573 
      oprot.writeFieldEnd()
5574 
    oprot.writeFieldStop()
5575 
    oprot.writeStructEnd()
5576 
 
3431 rajveer 5577 
  def validate(self):
5578 
    return
5579 
 
5580 
 
559 chandransh 5581 
  def __repr__(self):
5582 
    L = ['%s=%r' % (key, value)
5583 
      for key, value in self.__dict__.iteritems()]
5584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5585 
 
5586 
  def __eq__(self, other):
5587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5588 
 
5589 
  def __ne__(self, other):
5590 
    return not (self == other)
5591 
 
5592 
class addAddressForUser_args:
5593 
  """
5594 
  Attributes:
5595 
   - userId
5596 
   - address
5597 
   - setDefault
5598 
  """
5599 
 
5600 
  thrift_spec = (
5601 
    None, # 0
5602 
    (1, TType.I64, 'userId', None, None, ), # 1
5603 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5604 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5605 
  )
5606 
 
567 rajveer 5607 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5608 
    self.userId = userId
5609 
    self.address = address
5610 
    self.setDefault = setDefault
5611 
 
5612 
  def read(self, iprot):
5613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5615 
      return
5616 
    iprot.readStructBegin()
5617 
    while True:
5618 
      (fname, ftype, fid) = iprot.readFieldBegin()
5619 
      if ftype == TType.STOP:
5620 
        break
5621 
      if fid == 1:
5622 
        if ftype == TType.I64:
5623 
          self.userId = iprot.readI64();
5624 
        else:
5625 
          iprot.skip(ftype)
122 ashish 5626 
      elif fid == 2:
559 chandransh 5627 
        if ftype == TType.STRUCT:
5628 
          self.address = Address()
5629 
          self.address.read(iprot)
122 ashish 5630 
        else:
5631 
          iprot.skip(ftype)
5632 
      elif fid == 3:
5633 
        if ftype == TType.BOOL:
559 chandransh 5634 
          self.setDefault = iprot.readBool();
122 ashish 5635 
        else:
5636 
          iprot.skip(ftype)
5637 
      else:
5638 
        iprot.skip(ftype)
5639 
      iprot.readFieldEnd()
5640 
    iprot.readStructEnd()
5641 
 
5642 
  def write(self, oprot):
5643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5645 
      return
559 chandransh 5646 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5647 
    if self.userId is not None:
559 chandransh 5648 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5649 
      oprot.writeI64(self.userId)
122 ashish 5650 
      oprot.writeFieldEnd()
3431 rajveer 5651 
    if self.address is not None:
559 chandransh 5652 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5653 
      self.address.write(oprot)
122 ashish 5654 
      oprot.writeFieldEnd()
3431 rajveer 5655 
    if self.setDefault is not None:
567 rajveer 5656 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5657 
      oprot.writeBool(self.setDefault)
5658 
      oprot.writeFieldEnd()
122 ashish 5659 
    oprot.writeFieldStop()
5660 
    oprot.writeStructEnd()
5661 
 
3431 rajveer 5662 
  def validate(self):
5663 
    return
5664 
 
5665 
 
122 ashish 5666 
  def __repr__(self):
5667 
    L = ['%s=%r' % (key, value)
5668 
      for key, value in self.__dict__.iteritems()]
5669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5670 
 
5671 
  def __eq__(self, other):
5672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5673 
 
5674 
  def __ne__(self, other):
5675 
    return not (self == other)
5676 
 
559 chandransh 5677 
class addAddressForUser_result:
122 ashish 5678 
  """
5679 
  Attributes:
5680 
   - success
559 chandransh 5681 
   - ucx
122 ashish 5682 
  """
5683 
 
5684 
  thrift_spec = (
567 rajveer 5685 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5686 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5687 
  )
5688 
 
559 chandransh 5689 
  def __init__(self, success=None, ucx=None,):
122 ashish 5690 
    self.success = success
559 chandransh 5691 
    self.ucx = ucx
122 ashish 5692 
 
5693 
  def read(self, iprot):
5694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5696 
      return
5697 
    iprot.readStructBegin()
5698 
    while True:
5699 
      (fname, ftype, fid) = iprot.readFieldBegin()
5700 
      if ftype == TType.STOP:
5701 
        break
5702 
      if fid == 0:
567 rajveer 5703 
        if ftype == TType.I64:
5704 
          self.success = iprot.readI64();
122 ashish 5705 
        else:
5706 
          iprot.skip(ftype)
5707 
      elif fid == 1:
5708 
        if ftype == TType.STRUCT:
559 chandransh 5709 
          self.ucx = UserContextException()
5710 
          self.ucx.read(iprot)
122 ashish 5711 
        else:
5712 
          iprot.skip(ftype)
5713 
      else:
5714 
        iprot.skip(ftype)
5715 
      iprot.readFieldEnd()
5716 
    iprot.readStructEnd()
5717 
 
5718 
  def write(self, oprot):
5719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5721 
      return
559 chandransh 5722 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 5723 
    if self.success is not None:
567 rajveer 5724 
      oprot.writeFieldBegin('success', TType.I64, 0)
5725 
      oprot.writeI64(self.success)
122 ashish 5726 
      oprot.writeFieldEnd()
3431 rajveer 5727 
    if self.ucx is not None:
559 chandransh 5728 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5729 
      self.ucx.write(oprot)
122 ashish 5730 
      oprot.writeFieldEnd()
5731 
    oprot.writeFieldStop()
5732 
    oprot.writeStructEnd()
5733 
 
3431 rajveer 5734 
  def validate(self):
5735 
    return
5736 
 
5737 
 
122 ashish 5738 
  def __repr__(self):
5739 
    L = ['%s=%r' % (key, value)
5740 
      for key, value in self.__dict__.iteritems()]
5741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5742 
 
5743 
  def __eq__(self, other):
5744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5745 
 
5746 
  def __ne__(self, other):
5747 
    return not (self == other)
5748 
 
559 chandransh 5749 
class removeAddressForUser_args:
94 ashish 5750 
  """
5751 
  Attributes:
559 chandransh 5752 
   - userid
5753 
   - addressId
94 ashish 5754 
  """
5755 
 
5756 
  thrift_spec = (
5757 
    None, # 0
559 chandransh 5758 
    (1, TType.I64, 'userid', None, None, ), # 1
5759 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5760 
  )
5761 
 
559 chandransh 5762 
  def __init__(self, userid=None, addressId=None,):
5763 
    self.userid = userid
5764 
    self.addressId = addressId
94 ashish 5765 
 
5766 
  def read(self, iprot):
5767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5769 
      return
5770 
    iprot.readStructBegin()
5771 
    while True:
5772 
      (fname, ftype, fid) = iprot.readFieldBegin()
5773 
      if ftype == TType.STOP:
5774 
        break
5775 
      if fid == 1:
559 chandransh 5776 
        if ftype == TType.I64:
5777 
          self.userid = iprot.readI64();
94 ashish 5778 
        else:
5779 
          iprot.skip(ftype)
559 chandransh 5780 
      elif fid == 2:
5781 
        if ftype == TType.I64:
5782 
          self.addressId = iprot.readI64();
5783 
        else:
5784 
          iprot.skip(ftype)
94 ashish 5785 
      else:
5786 
        iprot.skip(ftype)
5787 
      iprot.readFieldEnd()
5788 
    iprot.readStructEnd()
5789 
 
5790 
  def write(self, oprot):
5791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5793 
      return
559 chandransh 5794 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 5795 
    if self.userid is not None:
559 chandransh 5796 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5797 
      oprot.writeI64(self.userid)
94 ashish 5798 
      oprot.writeFieldEnd()
3431 rajveer 5799 
    if self.addressId is not None:
559 chandransh 5800 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5801 
      oprot.writeI64(self.addressId)
5802 
      oprot.writeFieldEnd()
94 ashish 5803 
    oprot.writeFieldStop()
5804 
    oprot.writeStructEnd()
5805 
 
3431 rajveer 5806 
  def validate(self):
5807 
    return
5808 
 
5809 
 
94 ashish 5810 
  def __repr__(self):
5811 
    L = ['%s=%r' % (key, value)
5812 
      for key, value in self.__dict__.iteritems()]
5813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5814 
 
5815 
  def __eq__(self, other):
5816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5817 
 
5818 
  def __ne__(self, other):
5819 
    return not (self == other)
5820 
 
559 chandransh 5821 
class removeAddressForUser_result:
94 ashish 5822 
  """
5823 
  Attributes:
5824 
   - success
5825 
   - ucx
5826 
  """
5827 
 
5828 
  thrift_spec = (
5829 
    (0, TType.BOOL, 'success', None, None, ), # 0
5830 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5831 
  )
5832 
 
5833 
  def __init__(self, success=None, ucx=None,):
5834 
    self.success = success
5835 
    self.ucx = ucx
5836 
 
5837 
  def read(self, iprot):
5838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5840 
      return
5841 
    iprot.readStructBegin()
5842 
    while True:
5843 
      (fname, ftype, fid) = iprot.readFieldBegin()
5844 
      if ftype == TType.STOP:
5845 
        break
5846 
      if fid == 0:
5847 
        if ftype == TType.BOOL:
5848 
          self.success = iprot.readBool();
5849 
        else:
5850 
          iprot.skip(ftype)
5851 
      elif fid == 1:
5852 
        if ftype == TType.STRUCT:
5853 
          self.ucx = UserContextException()
5854 
          self.ucx.read(iprot)
5855 
        else:
5856 
          iprot.skip(ftype)
5857 
      else:
5858 
        iprot.skip(ftype)
5859 
      iprot.readFieldEnd()
5860 
    iprot.readStructEnd()
5861 
 
5862 
  def write(self, oprot):
5863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5865 
      return
559 chandransh 5866 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 5867 
    if self.success is not None:
94 ashish 5868 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5869 
      oprot.writeBool(self.success)
5870 
      oprot.writeFieldEnd()
3431 rajveer 5871 
    if self.ucx is not None:
94 ashish 5872 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5873 
      self.ucx.write(oprot)
5874 
      oprot.writeFieldEnd()
5875 
    oprot.writeFieldStop()
5876 
    oprot.writeStructEnd()
5877 
 
3431 rajveer 5878 
  def validate(self):
5879 
    return
5880 
 
5881 
 
94 ashish 5882 
  def __repr__(self):
5883 
    L = ['%s=%r' % (key, value)
5884 
      for key, value in self.__dict__.iteritems()]
5885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5886 
 
5887 
  def __eq__(self, other):
5888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5889 
 
5890 
  def __ne__(self, other):
5891 
    return not (self == other)
5892 
 
559 chandransh 5893 
class setUserAsLoggedIn_args:
94 ashish 5894 
  """
5895 
  Attributes:
559 chandransh 5896 
   - userId
94 ashish 5897 
   - timestamp
5898 
  """
5899 
 
5900 
  thrift_spec = (
5901 
    None, # 0
559 chandransh 5902 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5903 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5904 
  )
5905 
 
559 chandransh 5906 
  def __init__(self, userId=None, timestamp=None,):
5907 
    self.userId = userId
94 ashish 5908 
    self.timestamp = timestamp
5909 
 
5910 
  def read(self, iprot):
5911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5913 
      return
5914 
    iprot.readStructBegin()
5915 
    while True:
5916 
      (fname, ftype, fid) = iprot.readFieldBegin()
5917 
      if ftype == TType.STOP:
5918 
        break
5919 
      if fid == 1:
559 chandransh 5920 
        if ftype == TType.I64:
5921 
          self.userId = iprot.readI64();
94 ashish 5922 
        else:
5923 
          iprot.skip(ftype)
5924 
      elif fid == 2:
5925 
        if ftype == TType.I64:
5926 
          self.timestamp = iprot.readI64();
5927 
        else:
5928 
          iprot.skip(ftype)
5929 
      else:
5930 
        iprot.skip(ftype)
5931 
      iprot.readFieldEnd()
5932 
    iprot.readStructEnd()
5933 
 
5934 
  def write(self, oprot):
5935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5937 
      return
559 chandransh 5938 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 5939 
    if self.userId is not None:
559 chandransh 5940 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5941 
      oprot.writeI64(self.userId)
94 ashish 5942 
      oprot.writeFieldEnd()
3431 rajveer 5943 
    if self.timestamp is not None:
94 ashish 5944 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5945 
      oprot.writeI64(self.timestamp)
5946 
      oprot.writeFieldEnd()
5947 
    oprot.writeFieldStop()
5948 
    oprot.writeStructEnd()
5949 
 
3431 rajveer 5950 
  def validate(self):
5951 
    return
5952 
 
5953 
 
94 ashish 5954 
  def __repr__(self):
5955 
    L = ['%s=%r' % (key, value)
5956 
      for key, value in self.__dict__.iteritems()]
5957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5958 
 
5959 
  def __eq__(self, other):
5960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5961 
 
5962 
  def __ne__(self, other):
5963 
    return not (self == other)
5964 
 
559 chandransh 5965 
class setUserAsLoggedIn_result:
94 ashish 5966 
  """
5967 
  Attributes:
5968 
   - success
5969 
   - ucx
5970 
  """
5971 
 
5972 
  thrift_spec = (
5973 
    (0, TType.BOOL, 'success', None, None, ), # 0
5974 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5975 
  )
5976 
 
5977 
  def __init__(self, success=None, ucx=None,):
5978 
    self.success = success
5979 
    self.ucx = ucx
5980 
 
5981 
  def read(self, iprot):
5982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5984 
      return
5985 
    iprot.readStructBegin()
5986 
    while True:
5987 
      (fname, ftype, fid) = iprot.readFieldBegin()
5988 
      if ftype == TType.STOP:
5989 
        break
5990 
      if fid == 0:
5991 
        if ftype == TType.BOOL:
5992 
          self.success = iprot.readBool();
5993 
        else:
5994 
          iprot.skip(ftype)
5995 
      elif fid == 1:
5996 
        if ftype == TType.STRUCT:
5997 
          self.ucx = UserContextException()
5998 
          self.ucx.read(iprot)
5999 
        else:
6000 
          iprot.skip(ftype)
6001 
      else:
6002 
        iprot.skip(ftype)
6003 
      iprot.readFieldEnd()
6004 
    iprot.readStructEnd()
6005 
 
6006 
  def write(self, oprot):
6007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6009 
      return
559 chandransh 6010 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6011 
    if self.success is not None:
94 ashish 6012 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6013 
      oprot.writeBool(self.success)
6014 
      oprot.writeFieldEnd()
3431 rajveer 6015 
    if self.ucx is not None:
94 ashish 6016 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6017 
      self.ucx.write(oprot)
6018 
      oprot.writeFieldEnd()
6019 
    oprot.writeFieldStop()
6020 
    oprot.writeStructEnd()
6021 
 
3431 rajveer 6022 
  def validate(self):
6023 
    return
6024 
 
6025 
 
94 ashish 6026 
  def __repr__(self):
6027 
    L = ['%s=%r' % (key, value)
6028 
      for key, value in self.__dict__.iteritems()]
6029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6030 
 
6031 
  def __eq__(self, other):
6032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6033 
 
6034 
  def __ne__(self, other):
6035 
    return not (self == other)
6036 
 
559 chandransh 6037 
class setUserAsLoggedOut_args:
94 ashish 6038 
  """
6039 
  Attributes:
6040 
   - userid
6041 
   - timestamp
6042 
  """
6043 
 
6044 
  thrift_spec = (
6045 
    None, # 0
559 chandransh 6046 
    (1, TType.I64, 'userid', None, None, ), # 1
6047 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6048 
  )
6049 
 
559 chandransh 6050 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6051 
    self.userid = userid
6052 
    self.timestamp = timestamp
6053 
 
6054 
  def read(self, iprot):
6055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6057 
      return
6058 
    iprot.readStructBegin()
6059 
    while True:
6060 
      (fname, ftype, fid) = iprot.readFieldBegin()
6061 
      if ftype == TType.STOP:
6062 
        break
6063 
      if fid == 1:
6064 
        if ftype == TType.I64:
6065 
          self.userid = iprot.readI64();
6066 
        else:
6067 
          iprot.skip(ftype)
559 chandransh 6068 
      elif fid == 2:
94 ashish 6069 
        if ftype == TType.I64:
6070 
          self.timestamp = iprot.readI64();
6071 
        else:
6072 
          iprot.skip(ftype)
6073 
      else:
6074 
        iprot.skip(ftype)
6075 
      iprot.readFieldEnd()
6076 
    iprot.readStructEnd()
6077 
 
6078 
  def write(self, oprot):
6079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6081 
      return
559 chandransh 6082 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6083 
    if self.userid is not None:
559 chandransh 6084 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6085 
      oprot.writeI64(self.userid)
6086 
      oprot.writeFieldEnd()
3431 rajveer 6087 
    if self.timestamp is not None:
559 chandransh 6088 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6089 
      oprot.writeI64(self.timestamp)
6090 
      oprot.writeFieldEnd()
6091 
    oprot.writeFieldStop()
6092 
    oprot.writeStructEnd()
6093 
 
3431 rajveer 6094 
  def validate(self):
6095 
    return
6096 
 
6097 
 
94 ashish 6098 
  def __repr__(self):
6099 
    L = ['%s=%r' % (key, value)
6100 
      for key, value in self.__dict__.iteritems()]
6101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6102 
 
6103 
  def __eq__(self, other):
6104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6105 
 
6106 
  def __ne__(self, other):
6107 
    return not (self == other)
6108 
 
559 chandransh 6109 
class setUserAsLoggedOut_result:
94 ashish 6110 
  """
6111 
  Attributes:
6112 
   - success
6113 
   - ucx
6114 
  """
6115 
 
6116 
  thrift_spec = (
6117 
    (0, TType.BOOL, 'success', None, None, ), # 0
6118 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6119 
  )
6120 
 
6121 
  def __init__(self, success=None, ucx=None,):
6122 
    self.success = success
6123 
    self.ucx = ucx
6124 
 
6125 
  def read(self, iprot):
6126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6128 
      return
6129 
    iprot.readStructBegin()
6130 
    while True:
6131 
      (fname, ftype, fid) = iprot.readFieldBegin()
6132 
      if ftype == TType.STOP:
6133 
        break
6134 
      if fid == 0:
6135 
        if ftype == TType.BOOL:
6136 
          self.success = iprot.readBool();
6137 
        else:
6138 
          iprot.skip(ftype)
6139 
      elif fid == 1:
6140 
        if ftype == TType.STRUCT:
6141 
          self.ucx = UserContextException()
6142 
          self.ucx.read(iprot)
6143 
        else:
6144 
          iprot.skip(ftype)
6145 
      else:
6146 
        iprot.skip(ftype)
6147 
      iprot.readFieldEnd()
6148 
    iprot.readStructEnd()
6149 
 
6150 
  def write(self, oprot):
6151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6153 
      return
559 chandransh 6154 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6155 
    if self.success is not None:
94 ashish 6156 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6157 
      oprot.writeBool(self.success)
6158 
      oprot.writeFieldEnd()
3431 rajveer 6159 
    if self.ucx is not None:
94 ashish 6160 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6161 
      self.ucx.write(oprot)
6162 
      oprot.writeFieldEnd()
6163 
    oprot.writeFieldStop()
6164 
    oprot.writeStructEnd()
6165 
 
3431 rajveer 6166 
  def validate(self):
6167 
    return
6168 
 
6169 
 
94 ashish 6170 
  def __repr__(self):
6171 
    L = ['%s=%r' % (key, value)
6172 
      for key, value in self.__dict__.iteritems()]
6173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6174 
 
6175 
  def __eq__(self, other):
6176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6177 
 
6178 
  def __ne__(self, other):
6179 
    return not (self == other)
6180 
 
559 chandransh 6181 
class setDefaultAddress_args:
94 ashish 6182 
  """
6183 
  Attributes:
6184 
   - userid
6185 
   - addressId
6186 
  """
6187 
 
6188 
  thrift_spec = (
6189 
    None, # 0
6190 
    (1, TType.I64, 'userid', None, None, ), # 1
6191 
    (2, TType.I64, 'addressId', None, None, ), # 2
6192 
  )
6193 
 
6194 
  def __init__(self, userid=None, addressId=None,):
6195 
    self.userid = userid
6196 
    self.addressId = addressId
6197 
 
6198 
  def read(self, iprot):
6199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6201 
      return
6202 
    iprot.readStructBegin()
6203 
    while True:
6204 
      (fname, ftype, fid) = iprot.readFieldBegin()
6205 
      if ftype == TType.STOP:
6206 
        break
6207 
      if fid == 1:
6208 
        if ftype == TType.I64:
6209 
          self.userid = iprot.readI64();
6210 
        else:
6211 
          iprot.skip(ftype)
6212 
      elif fid == 2:
6213 
        if ftype == TType.I64:
6214 
          self.addressId = iprot.readI64();
6215 
        else:
6216 
          iprot.skip(ftype)
6217 
      else:
6218 
        iprot.skip(ftype)
6219 
      iprot.readFieldEnd()
6220 
    iprot.readStructEnd()
6221 
 
6222 
  def write(self, oprot):
6223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6225 
      return
559 chandransh 6226 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6227 
    if self.userid is not None:
94 ashish 6228 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6229 
      oprot.writeI64(self.userid)
6230 
      oprot.writeFieldEnd()
3431 rajveer 6231 
    if self.addressId is not None:
94 ashish 6232 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6233 
      oprot.writeI64(self.addressId)
6234 
      oprot.writeFieldEnd()
6235 
    oprot.writeFieldStop()
6236 
    oprot.writeStructEnd()
6237 
 
3431 rajveer 6238 
  def validate(self):
6239 
    return
6240 
 
6241 
 
94 ashish 6242 
  def __repr__(self):
6243 
    L = ['%s=%r' % (key, value)
6244 
      for key, value in self.__dict__.iteritems()]
6245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6246 
 
6247 
  def __eq__(self, other):
6248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6249 
 
6250 
  def __ne__(self, other):
6251 
    return not (self == other)
6252 
 
559 chandransh 6253 
class setDefaultAddress_result:
94 ashish 6254 
  """
6255 
  Attributes:
6256 
   - success
6257 
   - ucx
6258 
  """
6259 
 
6260 
  thrift_spec = (
6261 
    (0, TType.BOOL, 'success', None, None, ), # 0
6262 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6263 
  )
6264 
 
6265 
  def __init__(self, success=None, ucx=None,):
6266 
    self.success = success
6267 
    self.ucx = ucx
6268 
 
6269 
  def read(self, iprot):
6270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6272 
      return
6273 
    iprot.readStructBegin()
6274 
    while True:
6275 
      (fname, ftype, fid) = iprot.readFieldBegin()
6276 
      if ftype == TType.STOP:
6277 
        break
6278 
      if fid == 0:
6279 
        if ftype == TType.BOOL:
6280 
          self.success = iprot.readBool();
6281 
        else:
6282 
          iprot.skip(ftype)
6283 
      elif fid == 1:
6284 
        if ftype == TType.STRUCT:
6285 
          self.ucx = UserContextException()
6286 
          self.ucx.read(iprot)
6287 
        else:
6288 
          iprot.skip(ftype)
6289 
      else:
6290 
        iprot.skip(ftype)
6291 
      iprot.readFieldEnd()
6292 
    iprot.readStructEnd()
6293 
 
6294 
  def write(self, oprot):
6295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6297 
      return
559 chandransh 6298 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6299 
    if self.success is not None:
94 ashish 6300 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6301 
      oprot.writeBool(self.success)
6302 
      oprot.writeFieldEnd()
3431 rajveer 6303 
    if self.ucx is not None:
94 ashish 6304 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6305 
      self.ucx.write(oprot)
6306 
      oprot.writeFieldEnd()
6307 
    oprot.writeFieldStop()
6308 
    oprot.writeStructEnd()
6309 
 
3431 rajveer 6310 
  def validate(self):
6311 
    return
6312 
 
6313 
 
94 ashish 6314 
  def __repr__(self):
6315 
    L = ['%s=%r' % (key, value)
6316 
      for key, value in self.__dict__.iteritems()]
6317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6318 
 
6319 
  def __eq__(self, other):
6320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6321 
 
6322 
  def __ne__(self, other):
6323 
    return not (self == other)
6324 
 
559 chandransh 6325 
class updatePassword_args:
94 ashish 6326 
  """
6327 
  Attributes:
559 chandransh 6328 
   - userid
594 rajveer 6329 
   - oldPassword
6330 
   - newPassword
94 ashish 6331 
  """
6332 
 
6333 
  thrift_spec = (
6334 
    None, # 0
559 chandransh 6335 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6336 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6337 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6338 
  )
6339 
 
594 rajveer 6340 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6341 
    self.userid = userid
594 rajveer 6342 
    self.oldPassword = oldPassword
6343 
    self.newPassword = newPassword
94 ashish 6344 
 
6345 
  def read(self, iprot):
6346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6348 
      return
6349 
    iprot.readStructBegin()
6350 
    while True:
6351 
      (fname, ftype, fid) = iprot.readFieldBegin()
6352 
      if ftype == TType.STOP:
6353 
        break
6354 
      if fid == 1:
6355 
        if ftype == TType.I64:
559 chandransh 6356 
          self.userid = iprot.readI64();
94 ashish 6357 
        else:
6358 
          iprot.skip(ftype)
6359 
      elif fid == 2:
559 chandransh 6360 
        if ftype == TType.STRING:
594 rajveer 6361 
          self.oldPassword = iprot.readString();
94 ashish 6362 
        else:
6363 
          iprot.skip(ftype)
594 rajveer 6364 
      elif fid == 3:
6365 
        if ftype == TType.STRING:
6366 
          self.newPassword = iprot.readString();
6367 
        else:
6368 
          iprot.skip(ftype)
94 ashish 6369 
      else:
6370 
        iprot.skip(ftype)
6371 
      iprot.readFieldEnd()
6372 
    iprot.readStructEnd()
6373 
 
6374 
  def write(self, oprot):
6375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6377 
      return
559 chandransh 6378 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6379 
    if self.userid is not None:
559 chandransh 6380 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6381 
      oprot.writeI64(self.userid)
94 ashish 6382 
      oprot.writeFieldEnd()
3431 rajveer 6383 
    if self.oldPassword is not None:
594 rajveer 6384 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6385 
      oprot.writeString(self.oldPassword)
94 ashish 6386 
      oprot.writeFieldEnd()
3431 rajveer 6387 
    if self.newPassword is not None:
594 rajveer 6388 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6389 
      oprot.writeString(self.newPassword)
6390 
      oprot.writeFieldEnd()
94 ashish 6391 
    oprot.writeFieldStop()
6392 
    oprot.writeStructEnd()
6393 
 
3431 rajveer 6394 
  def validate(self):
6395 
    return
6396 
 
6397 
 
94 ashish 6398 
  def __repr__(self):
6399 
    L = ['%s=%r' % (key, value)
6400 
      for key, value in self.__dict__.iteritems()]
6401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6402 
 
6403 
  def __eq__(self, other):
6404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6405 
 
6406 
  def __ne__(self, other):
6407 
    return not (self == other)
6408 
 
559 chandransh 6409 
class updatePassword_result:
94 ashish 6410 
  """
6411 
  Attributes:
6412 
   - success
6413 
   - ucx
6414 
  """
6415 
 
6416 
  thrift_spec = (
6417 
    (0, TType.BOOL, 'success', None, None, ), # 0
6418 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6419 
  )
6420 
 
6421 
  def __init__(self, success=None, ucx=None,):
6422 
    self.success = success
6423 
    self.ucx = ucx
6424 
 
6425 
  def read(self, iprot):
6426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6428 
      return
6429 
    iprot.readStructBegin()
6430 
    while True:
6431 
      (fname, ftype, fid) = iprot.readFieldBegin()
6432 
      if ftype == TType.STOP:
6433 
        break
6434 
      if fid == 0:
6435 
        if ftype == TType.BOOL:
6436 
          self.success = iprot.readBool();
6437 
        else:
6438 
          iprot.skip(ftype)
6439 
      elif fid == 1:
6440 
        if ftype == TType.STRUCT:
6441 
          self.ucx = UserContextException()
6442 
          self.ucx.read(iprot)
6443 
        else:
6444 
          iprot.skip(ftype)
6445 
      else:
6446 
        iprot.skip(ftype)
6447 
      iprot.readFieldEnd()
6448 
    iprot.readStructEnd()
6449 
 
6450 
  def write(self, oprot):
6451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6453 
      return
559 chandransh 6454 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6455 
    if self.success is not None:
94 ashish 6456 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6457 
      oprot.writeBool(self.success)
6458 
      oprot.writeFieldEnd()
3431 rajveer 6459 
    if self.ucx is not None:
94 ashish 6460 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6461 
      self.ucx.write(oprot)
6462 
      oprot.writeFieldEnd()
6463 
    oprot.writeFieldStop()
6464 
    oprot.writeStructEnd()
6465 
 
3431 rajveer 6466 
  def validate(self):
6467 
    return
6468 
 
6469 
 
94 ashish 6470 
  def __repr__(self):
6471 
    L = ['%s=%r' % (key, value)
6472 
      for key, value in self.__dict__.iteritems()]
6473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6474 
 
6475 
  def __eq__(self, other):
6476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6477 
 
6478 
  def __ne__(self, other):
6479 
    return not (self == other)
6480 
 
581 rajveer 6481 
class forgotPassword_args:
6482 
  """
6483 
  Attributes:
6484 
   - email
884 rajveer 6485 
   - newPassword
581 rajveer 6486 
  """
6487 
 
6488 
  thrift_spec = (
6489 
    None, # 0
6490 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6491 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6492 
  )
6493 
 
884 rajveer 6494 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6495 
    self.email = email
884 rajveer 6496 
    self.newPassword = newPassword
581 rajveer 6497 
 
6498 
  def read(self, iprot):
6499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6501 
      return
6502 
    iprot.readStructBegin()
6503 
    while True:
6504 
      (fname, ftype, fid) = iprot.readFieldBegin()
6505 
      if ftype == TType.STOP:
6506 
        break
6507 
      if fid == 1:
6508 
        if ftype == TType.STRING:
6509 
          self.email = iprot.readString();
6510 
        else:
6511 
          iprot.skip(ftype)
884 rajveer 6512 
      elif fid == 2:
6513 
        if ftype == TType.STRING:
6514 
          self.newPassword = iprot.readString();
6515 
        else:
6516 
          iprot.skip(ftype)
581 rajveer 6517 
      else:
6518 
        iprot.skip(ftype)
6519 
      iprot.readFieldEnd()
6520 
    iprot.readStructEnd()
6521 
 
6522 
  def write(self, oprot):
6523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6525 
      return
6526 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6527 
    if self.email is not None:
581 rajveer 6528 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6529 
      oprot.writeString(self.email)
6530 
      oprot.writeFieldEnd()
3431 rajveer 6531 
    if self.newPassword is not None:
884 rajveer 6532 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6533 
      oprot.writeString(self.newPassword)
6534 
      oprot.writeFieldEnd()
581 rajveer 6535 
    oprot.writeFieldStop()
6536 
    oprot.writeStructEnd()
6537 
 
3431 rajveer 6538 
  def validate(self):
6539 
    return
6540 
 
6541 
 
581 rajveer 6542 
  def __repr__(self):
6543 
    L = ['%s=%r' % (key, value)
6544 
      for key, value in self.__dict__.iteritems()]
6545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6546 
 
6547 
  def __eq__(self, other):
6548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6549 
 
6550 
  def __ne__(self, other):
6551 
    return not (self == other)
6552 
 
6553 
class forgotPassword_result:
6554 
  """
6555 
  Attributes:
6556 
   - success
6557 
   - ucx
6558 
  """
6559 
 
6560 
  thrift_spec = (
6561 
    (0, TType.BOOL, 'success', None, None, ), # 0
6562 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6563 
  )
6564 
 
6565 
  def __init__(self, success=None, ucx=None,):
6566 
    self.success = success
6567 
    self.ucx = ucx
6568 
 
6569 
  def read(self, iprot):
6570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6572 
      return
6573 
    iprot.readStructBegin()
6574 
    while True:
6575 
      (fname, ftype, fid) = iprot.readFieldBegin()
6576 
      if ftype == TType.STOP:
6577 
        break
6578 
      if fid == 0:
6579 
        if ftype == TType.BOOL:
6580 
          self.success = iprot.readBool();
6581 
        else:
6582 
          iprot.skip(ftype)
6583 
      elif fid == 1:
6584 
        if ftype == TType.STRUCT:
6585 
          self.ucx = UserContextException()
6586 
          self.ucx.read(iprot)
6587 
        else:
6588 
          iprot.skip(ftype)
6589 
      else:
6590 
        iprot.skip(ftype)
6591 
      iprot.readFieldEnd()
6592 
    iprot.readStructEnd()
6593 
 
6594 
  def write(self, oprot):
6595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6597 
      return
6598 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6599 
    if self.success is not None:
581 rajveer 6600 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6601 
      oprot.writeBool(self.success)
6602 
      oprot.writeFieldEnd()
3431 rajveer 6603 
    if self.ucx is not None:
581 rajveer 6604 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6605 
      self.ucx.write(oprot)
6606 
      oprot.writeFieldEnd()
6607 
    oprot.writeFieldStop()
6608 
    oprot.writeStructEnd()
6609 
 
3431 rajveer 6610 
  def validate(self):
6611 
    return
6612 
 
6613 
 
581 rajveer 6614 
  def __repr__(self):
6615 
    L = ['%s=%r' % (key, value)
6616 
      for key, value in self.__dict__.iteritems()]
6617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6618 
 
6619 
  def __eq__(self, other):
6620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6621 
 
6622 
  def __ne__(self, other):
6623 
    return not (self == other)
6624 
 
594 rajveer 6625 
class getAllAddressesForUser_args:
6626 
  """
6627 
  Attributes:
6628 
   - userId
6629 
  """
6630 
 
6631 
  thrift_spec = (
6632 
    None, # 0
6633 
    (1, TType.I64, 'userId', None, None, ), # 1
6634 
  )
6635 
 
6636 
  def __init__(self, userId=None,):
6637 
    self.userId = userId
6638 
 
6639 
  def read(self, iprot):
6640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6642 
      return
6643 
    iprot.readStructBegin()
6644 
    while True:
6645 
      (fname, ftype, fid) = iprot.readFieldBegin()
6646 
      if ftype == TType.STOP:
6647 
        break
6648 
      if fid == 1:
6649 
        if ftype == TType.I64:
6650 
          self.userId = iprot.readI64();
6651 
        else:
6652 
          iprot.skip(ftype)
6653 
      else:
6654 
        iprot.skip(ftype)
6655 
      iprot.readFieldEnd()
6656 
    iprot.readStructEnd()
6657 
 
6658 
  def write(self, oprot):
6659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6661 
      return
6662 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6663 
    if self.userId is not None:
594 rajveer 6664 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6665 
      oprot.writeI64(self.userId)
6666 
      oprot.writeFieldEnd()
6667 
    oprot.writeFieldStop()
6668 
    oprot.writeStructEnd()
6669 
 
3431 rajveer 6670 
  def validate(self):
6671 
    return
6672 
 
6673 
 
594 rajveer 6674 
  def __repr__(self):
6675 
    L = ['%s=%r' % (key, value)
6676 
      for key, value in self.__dict__.iteritems()]
6677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6678 
 
6679 
  def __eq__(self, other):
6680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6681 
 
6682 
  def __ne__(self, other):
6683 
    return not (self == other)
6684 
 
6685 
class getAllAddressesForUser_result:
6686 
  """
6687 
  Attributes:
6688 
   - success
6689 
   - ucx
6690 
  """
6691 
 
6692 
  thrift_spec = (
6693 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6694 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6695 
  )
6696 
 
6697 
  def __init__(self, success=None, ucx=None,):
6698 
    self.success = success
6699 
    self.ucx = ucx
6700 
 
6701 
  def read(self, iprot):
6702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6704 
      return
6705 
    iprot.readStructBegin()
6706 
    while True:
6707 
      (fname, ftype, fid) = iprot.readFieldBegin()
6708 
      if ftype == TType.STOP:
6709 
        break
6710 
      if fid == 0:
6711 
        if ftype == TType.LIST:
6712 
          self.success = []
11592 amit.gupta 6713 
          (_etype100, _size97) = iprot.readListBegin()
6714 
          for _i101 in xrange(_size97):
6715 
            _elem102 = Address()
6716 
            _elem102.read(iprot)
6717 
            self.success.append(_elem102)
594 rajveer 6718 
          iprot.readListEnd()
6719 
        else:
6720 
          iprot.skip(ftype)
6721 
      elif fid == 1:
6722 
        if ftype == TType.STRUCT:
6723 
          self.ucx = UserContextException()
6724 
          self.ucx.read(iprot)
6725 
        else:
6726 
          iprot.skip(ftype)
6727 
      else:
6728 
        iprot.skip(ftype)
6729 
      iprot.readFieldEnd()
6730 
    iprot.readStructEnd()
6731 
 
6732 
  def write(self, oprot):
6733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6735 
      return
6736 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 6737 
    if self.success is not None:
594 rajveer 6738 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6739 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 6740 
      for iter103 in self.success:
6741 
        iter103.write(oprot)
594 rajveer 6742 
      oprot.writeListEnd()
6743 
      oprot.writeFieldEnd()
3431 rajveer 6744 
    if self.ucx is not None:
594 rajveer 6745 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6746 
      self.ucx.write(oprot)
6747 
      oprot.writeFieldEnd()
6748 
    oprot.writeFieldStop()
6749 
    oprot.writeStructEnd()
6750 
 
3431 rajveer 6751 
  def validate(self):
6752 
    return
6753 
 
6754 
 
594 rajveer 6755 
  def __repr__(self):
6756 
    L = ['%s=%r' % (key, value)
6757 
      for key, value in self.__dict__.iteritems()]
6758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6759 
 
6760 
  def __eq__(self, other):
6761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6762 
 
6763 
  def __ne__(self, other):
6764 
    return not (self == other)
6765 
 
1894 vikas 6766 
class getAddressById_args:
6767 
  """
6768 
  Attributes:
6769 
   - addressId
6770 
  """
6771 
 
6772 
  thrift_spec = (
6773 
    None, # 0
6774 
    (1, TType.I64, 'addressId', None, None, ), # 1
6775 
  )
6776 
 
6777 
  def __init__(self, addressId=None,):
6778 
    self.addressId = addressId
6779 
 
6780 
  def read(self, iprot):
6781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6783 
      return
6784 
    iprot.readStructBegin()
6785 
    while True:
6786 
      (fname, ftype, fid) = iprot.readFieldBegin()
6787 
      if ftype == TType.STOP:
6788 
        break
6789 
      if fid == 1:
6790 
        if ftype == TType.I64:
6791 
          self.addressId = iprot.readI64();
6792 
        else:
6793 
          iprot.skip(ftype)
6794 
      else:
6795 
        iprot.skip(ftype)
6796 
      iprot.readFieldEnd()
6797 
    iprot.readStructEnd()
6798 
 
6799 
  def write(self, oprot):
6800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6802 
      return
6803 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 6804 
    if self.addressId is not None:
1894 vikas 6805 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6806 
      oprot.writeI64(self.addressId)
6807 
      oprot.writeFieldEnd()
6808 
    oprot.writeFieldStop()
6809 
    oprot.writeStructEnd()
6810 
 
3431 rajveer 6811 
  def validate(self):
6812 
    return
6813 
 
6814 
 
1894 vikas 6815 
  def __repr__(self):
6816 
    L = ['%s=%r' % (key, value)
6817 
      for key, value in self.__dict__.iteritems()]
6818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6819 
 
6820 
  def __eq__(self, other):
6821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6822 
 
6823 
  def __ne__(self, other):
6824 
    return not (self == other)
6825 
 
6826 
class getAddressById_result:
6827 
  """
6828 
  Attributes:
6829 
   - success
6830 
   - ucx
6831 
  """
6832 
 
6833 
  thrift_spec = (
6834 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6835 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6836 
  )
6837 
 
6838 
  def __init__(self, success=None, ucx=None,):
6839 
    self.success = success
6840 
    self.ucx = ucx
6841 
 
6842 
  def read(self, iprot):
6843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6845 
      return
6846 
    iprot.readStructBegin()
6847 
    while True:
6848 
      (fname, ftype, fid) = iprot.readFieldBegin()
6849 
      if ftype == TType.STOP:
6850 
        break
6851 
      if fid == 0:
6852 
        if ftype == TType.STRUCT:
6853 
          self.success = Address()
6854 
          self.success.read(iprot)
6855 
        else:
6856 
          iprot.skip(ftype)
6857 
      elif fid == 1:
6858 
        if ftype == TType.STRUCT:
6859 
          self.ucx = UserContextException()
6860 
          self.ucx.read(iprot)
6861 
        else:
6862 
          iprot.skip(ftype)
6863 
      else:
6864 
        iprot.skip(ftype)
6865 
      iprot.readFieldEnd()
6866 
    iprot.readStructEnd()
6867 
 
6868 
  def write(self, oprot):
6869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6871 
      return
6872 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 6873 
    if self.success is not None:
1894 vikas 6874 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6875 
      self.success.write(oprot)
6876 
      oprot.writeFieldEnd()
3431 rajveer 6877 
    if self.ucx is not None:
1894 vikas 6878 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6879 
      self.ucx.write(oprot)
6880 
      oprot.writeFieldEnd()
6881 
    oprot.writeFieldStop()
6882 
    oprot.writeStructEnd()
6883 
 
3431 rajveer 6884 
  def validate(self):
6885 
    return
6886 
 
6887 
 
1894 vikas 6888 
  def __repr__(self):
6889 
    L = ['%s=%r' % (key, value)
6890 
      for key, value in self.__dict__.iteritems()]
6891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6892 
 
6893 
  def __eq__(self, other):
6894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6895 
 
6896 
  def __ne__(self, other):
6897 
    return not (self == other)
6898 
 
594 rajveer 6899 
class getDefaultAddressId_args:
6900 
  """
6901 
  Attributes:
6902 
   - userId
6903 
  """
6904 
 
6905 
  thrift_spec = (
6906 
    None, # 0
6907 
    (1, TType.I64, 'userId', None, None, ), # 1
6908 
  )
6909 
 
6910 
  def __init__(self, userId=None,):
6911 
    self.userId = userId
6912 
 
6913 
  def read(self, iprot):
6914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6916 
      return
6917 
    iprot.readStructBegin()
6918 
    while True:
6919 
      (fname, ftype, fid) = iprot.readFieldBegin()
6920 
      if ftype == TType.STOP:
6921 
        break
6922 
      if fid == 1:
6923 
        if ftype == TType.I64:
6924 
          self.userId = iprot.readI64();
6925 
        else:
6926 
          iprot.skip(ftype)
6927 
      else:
6928 
        iprot.skip(ftype)
6929 
      iprot.readFieldEnd()
6930 
    iprot.readStructEnd()
6931 
 
6932 
  def write(self, oprot):
6933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6935 
      return
6936 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 6937 
    if self.userId is not None:
594 rajveer 6938 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6939 
      oprot.writeI64(self.userId)
6940 
      oprot.writeFieldEnd()
6941 
    oprot.writeFieldStop()
6942 
    oprot.writeStructEnd()
6943 
 
3431 rajveer 6944 
  def validate(self):
6945 
    return
6946 
 
6947 
 
594 rajveer 6948 
  def __repr__(self):
6949 
    L = ['%s=%r' % (key, value)
6950 
      for key, value in self.__dict__.iteritems()]
6951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6952 
 
6953 
  def __eq__(self, other):
6954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6955 
 
6956 
  def __ne__(self, other):
6957 
    return not (self == other)
6958 
 
6959 
class getDefaultAddressId_result:
6960 
  """
6961 
  Attributes:
6962 
   - success
6963 
   - ucx
6964 
  """
6965 
 
6966 
  thrift_spec = (
6967 
    (0, TType.I64, 'success', None, None, ), # 0
6968 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6969 
  )
6970 
 
6971 
  def __init__(self, success=None, ucx=None,):
6972 
    self.success = success
6973 
    self.ucx = ucx
6974 
 
6975 
  def read(self, iprot):
6976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6978 
      return
6979 
    iprot.readStructBegin()
6980 
    while True:
6981 
      (fname, ftype, fid) = iprot.readFieldBegin()
6982 
      if ftype == TType.STOP:
6983 
        break
6984 
      if fid == 0:
6985 
        if ftype == TType.I64:
6986 
          self.success = iprot.readI64();
6987 
        else:
6988 
          iprot.skip(ftype)
6989 
      elif fid == 1:
6990 
        if ftype == TType.STRUCT:
6991 
          self.ucx = UserContextException()
6992 
          self.ucx.read(iprot)
6993 
        else:
6994 
          iprot.skip(ftype)
6995 
      else:
6996 
        iprot.skip(ftype)
6997 
      iprot.readFieldEnd()
6998 
    iprot.readStructEnd()
6999 
 
7000 
  def write(self, oprot):
7001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7003 
      return
7004 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7005 
    if self.success is not None:
594 rajveer 7006 
      oprot.writeFieldBegin('success', TType.I64, 0)
7007 
      oprot.writeI64(self.success)
7008 
      oprot.writeFieldEnd()
3431 rajveer 7009 
    if self.ucx is not None:
594 rajveer 7010 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7011 
      self.ucx.write(oprot)
7012 
      oprot.writeFieldEnd()
7013 
    oprot.writeFieldStop()
7014 
    oprot.writeStructEnd()
7015 
 
3431 rajveer 7016 
  def validate(self):
7017 
    return
7018 
 
7019 
 
594 rajveer 7020 
  def __repr__(self):
7021 
    L = ['%s=%r' % (key, value)
7022 
      for key, value in self.__dict__.iteritems()]
7023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7024 
 
7025 
  def __eq__(self, other):
7026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7027 
 
7028 
  def __ne__(self, other):
7029 
    return not (self == other)
7030 
 
785 rajveer 7031 
class getDefaultPincode_args:
7032 
  """
7033 
  Attributes:
7034 
   - userId
7035 
  """
7036 
 
7037 
  thrift_spec = (
7038 
    None, # 0
7039 
    (1, TType.I64, 'userId', None, None, ), # 1
7040 
  )
7041 
 
7042 
  def __init__(self, userId=None,):
7043 
    self.userId = userId
7044 
 
7045 
  def read(self, iprot):
7046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7048 
      return
7049 
    iprot.readStructBegin()
7050 
    while True:
7051 
      (fname, ftype, fid) = iprot.readFieldBegin()
7052 
      if ftype == TType.STOP:
7053 
        break
7054 
      if fid == 1:
7055 
        if ftype == TType.I64:
7056 
          self.userId = iprot.readI64();
7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      else:
7060 
        iprot.skip(ftype)
7061 
      iprot.readFieldEnd()
7062 
    iprot.readStructEnd()
7063 
 
7064 
  def write(self, oprot):
7065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7067 
      return
7068 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7069 
    if self.userId is not None:
785 rajveer 7070 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7071 
      oprot.writeI64(self.userId)
7072 
      oprot.writeFieldEnd()
7073 
    oprot.writeFieldStop()
7074 
    oprot.writeStructEnd()
7075 
 
3431 rajveer 7076 
  def validate(self):
7077 
    return
7078 
 
7079 
 
785 rajveer 7080 
  def __repr__(self):
7081 
    L = ['%s=%r' % (key, value)
7082 
      for key, value in self.__dict__.iteritems()]
7083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7084 
 
7085 
  def __eq__(self, other):
7086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7087 
 
7088 
  def __ne__(self, other):
7089 
    return not (self == other)
7090 
 
7091 
class getDefaultPincode_result:
7092 
  """
7093 
  Attributes:
7094 
   - success
7095 
   - ucx
7096 
  """
7097 
 
7098 
  thrift_spec = (
7099 
    (0, TType.STRING, 'success', None, None, ), # 0
7100 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7101 
  )
7102 
 
7103 
  def __init__(self, success=None, ucx=None,):
7104 
    self.success = success
7105 
    self.ucx = ucx
7106 
 
7107 
  def read(self, iprot):
7108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7110 
      return
7111 
    iprot.readStructBegin()
7112 
    while True:
7113 
      (fname, ftype, fid) = iprot.readFieldBegin()
7114 
      if ftype == TType.STOP:
7115 
        break
7116 
      if fid == 0:
7117 
        if ftype == TType.STRING:
7118 
          self.success = iprot.readString();
7119 
        else:
7120 
          iprot.skip(ftype)
7121 
      elif fid == 1:
7122 
        if ftype == TType.STRUCT:
7123 
          self.ucx = UserContextException()
7124 
          self.ucx.read(iprot)
7125 
        else:
7126 
          iprot.skip(ftype)
7127 
      else:
7128 
        iprot.skip(ftype)
7129 
      iprot.readFieldEnd()
7130 
    iprot.readStructEnd()
7131 
 
7132 
  def write(self, oprot):
7133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7135 
      return
7136 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7137 
    if self.success is not None:
785 rajveer 7138 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7139 
      oprot.writeString(self.success)
7140 
      oprot.writeFieldEnd()
3431 rajveer 7141 
    if self.ucx is not None:
785 rajveer 7142 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7143 
      self.ucx.write(oprot)
7144 
      oprot.writeFieldEnd()
7145 
    oprot.writeFieldStop()
7146 
    oprot.writeStructEnd()
7147 
 
3431 rajveer 7148 
  def validate(self):
7149 
    return
7150 
 
7151 
 
785 rajveer 7152 
  def __repr__(self):
7153 
    L = ['%s=%r' % (key, value)
7154 
      for key, value in self.__dict__.iteritems()]
7155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7156 
 
7157 
  def __eq__(self, other):
7158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7159 
 
7160 
  def __ne__(self, other):
7161 
    return not (self == other)
7162 
 
1274 varun.gupt 7163 
class saveUserCommunication_args:
7164 
  """
7165 
  Attributes:
7166 
   - userId
7167 
   - replyTo
7168 
   - communicationType
7169 
   - orderId
7170 
   - airwaybillNo
7171 
   - productName
7172 
   - subject
7173 
   - message
7174 
  """
7175 
 
7176 
  thrift_spec = (
7177 
    None, # 0
7178 
    (1, TType.I64, 'userId', None, None, ), # 1
7179 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7180 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7181 
    (4, TType.I64, 'orderId', None, None, ), # 4
7182 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7183 
    (6, TType.STRING, 'productName', None, None, ), # 6
7184 
    (7, TType.STRING, 'subject', None, None, ), # 7
7185 
    (8, TType.STRING, 'message', None, None, ), # 8
7186 
  )
7187 
 
7188 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7189 
    self.userId = userId
7190 
    self.replyTo = replyTo
7191 
    self.communicationType = communicationType
7192 
    self.orderId = orderId
7193 
    self.airwaybillNo = airwaybillNo
7194 
    self.productName = productName
7195 
    self.subject = subject
7196 
    self.message = message
7197 
 
7198 
  def read(self, iprot):
7199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7201 
      return
7202 
    iprot.readStructBegin()
7203 
    while True:
7204 
      (fname, ftype, fid) = iprot.readFieldBegin()
7205 
      if ftype == TType.STOP:
7206 
        break
7207 
      if fid == 1:
7208 
        if ftype == TType.I64:
7209 
          self.userId = iprot.readI64();
7210 
        else:
7211 
          iprot.skip(ftype)
7212 
      elif fid == 2:
7213 
        if ftype == TType.STRING:
7214 
          self.replyTo = iprot.readString();
7215 
        else:
7216 
          iprot.skip(ftype)
7217 
      elif fid == 3:
7218 
        if ftype == TType.I64:
7219 
          self.communicationType = iprot.readI64();
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      elif fid == 4:
7223 
        if ftype == TType.I64:
7224 
          self.orderId = iprot.readI64();
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      elif fid == 5:
7228 
        if ftype == TType.STRING:
7229 
          self.airwaybillNo = iprot.readString();
7230 
        else:
7231 
          iprot.skip(ftype)
7232 
      elif fid == 6:
7233 
        if ftype == TType.STRING:
7234 
          self.productName = iprot.readString();
7235 
        else:
7236 
          iprot.skip(ftype)
7237 
      elif fid == 7:
7238 
        if ftype == TType.STRING:
7239 
          self.subject = iprot.readString();
7240 
        else:
7241 
          iprot.skip(ftype)
7242 
      elif fid == 8:
7243 
        if ftype == TType.STRING:
7244 
          self.message = iprot.readString();
7245 
        else:
7246 
          iprot.skip(ftype)
7247 
      else:
7248 
        iprot.skip(ftype)
7249 
      iprot.readFieldEnd()
7250 
    iprot.readStructEnd()
7251 
 
7252 
  def write(self, oprot):
7253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7255 
      return
7256 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7257 
    if self.userId is not None:
1274 varun.gupt 7258 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7259 
      oprot.writeI64(self.userId)
7260 
      oprot.writeFieldEnd()
3431 rajveer 7261 
    if self.replyTo is not None:
1274 varun.gupt 7262 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7263 
      oprot.writeString(self.replyTo)
7264 
      oprot.writeFieldEnd()
3431 rajveer 7265 
    if self.communicationType is not None:
1274 varun.gupt 7266 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7267 
      oprot.writeI64(self.communicationType)
7268 
      oprot.writeFieldEnd()
3431 rajveer 7269 
    if self.orderId is not None:
1274 varun.gupt 7270 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7271 
      oprot.writeI64(self.orderId)
7272 
      oprot.writeFieldEnd()
3431 rajveer 7273 
    if self.airwaybillNo is not None:
1274 varun.gupt 7274 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7275 
      oprot.writeString(self.airwaybillNo)
7276 
      oprot.writeFieldEnd()
3431 rajveer 7277 
    if self.productName is not None:
1274 varun.gupt 7278 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7279 
      oprot.writeString(self.productName)
7280 
      oprot.writeFieldEnd()
3431 rajveer 7281 
    if self.subject is not None:
1274 varun.gupt 7282 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7283 
      oprot.writeString(self.subject)
7284 
      oprot.writeFieldEnd()
3431 rajveer 7285 
    if self.message is not None:
1274 varun.gupt 7286 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7287 
      oprot.writeString(self.message)
7288 
      oprot.writeFieldEnd()
7289 
    oprot.writeFieldStop()
7290 
    oprot.writeStructEnd()
7291 
 
3431 rajveer 7292 
  def validate(self):
7293 
    return
7294 
 
7295 
 
1274 varun.gupt 7296 
  def __repr__(self):
7297 
    L = ['%s=%r' % (key, value)
7298 
      for key, value in self.__dict__.iteritems()]
7299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7300 
 
7301 
  def __eq__(self, other):
7302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7303 
 
7304 
  def __ne__(self, other):
7305 
    return not (self == other)
7306 
 
7307 
class saveUserCommunication_result:
7308 
  """
7309 
  Attributes:
7310 
   - success
7311 
   - ucx
7312 
  """
7313 
 
7314 
  thrift_spec = (
7315 
    (0, TType.BOOL, 'success', None, None, ), # 0
7316 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7317 
  )
7318 
 
7319 
  def __init__(self, success=None, ucx=None,):
7320 
    self.success = success
7321 
    self.ucx = ucx
7322 
 
7323 
  def read(self, iprot):
7324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7326 
      return
7327 
    iprot.readStructBegin()
7328 
    while True:
7329 
      (fname, ftype, fid) = iprot.readFieldBegin()
7330 
      if ftype == TType.STOP:
7331 
        break
7332 
      if fid == 0:
7333 
        if ftype == TType.BOOL:
7334 
          self.success = iprot.readBool();
7335 
        else:
7336 
          iprot.skip(ftype)
7337 
      elif fid == 1:
7338 
        if ftype == TType.STRUCT:
7339 
          self.ucx = UserCommunicationException()
7340 
          self.ucx.read(iprot)
7341 
        else:
7342 
          iprot.skip(ftype)
7343 
      else:
7344 
        iprot.skip(ftype)
7345 
      iprot.readFieldEnd()
7346 
    iprot.readStructEnd()
7347 
 
7348 
  def write(self, oprot):
7349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7351 
      return
7352 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7353 
    if self.success is not None:
1274 varun.gupt 7354 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7355 
      oprot.writeBool(self.success)
7356 
      oprot.writeFieldEnd()
3431 rajveer 7357 
    if self.ucx is not None:
1274 varun.gupt 7358 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7359 
      self.ucx.write(oprot)
7360 
      oprot.writeFieldEnd()
7361 
    oprot.writeFieldStop()
7362 
    oprot.writeStructEnd()
7363 
 
3431 rajveer 7364 
  def validate(self):
7365 
    return
7366 
 
7367 
 
1274 varun.gupt 7368 
  def __repr__(self):
7369 
    L = ['%s=%r' % (key, value)
7370 
      for key, value in self.__dict__.iteritems()]
7371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7372 
 
7373 
  def __eq__(self, other):
7374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7375 
 
7376 
  def __ne__(self, other):
7377 
    return not (self == other)
7378 
 
1590 varun.gupt 7379 
class getUserCommunicationById_args:
7380 
  """
7381 
  Attributes:
7382 
   - id
7383 
  """
7384 
 
7385 
  thrift_spec = (
7386 
    None, # 0
7387 
    (1, TType.I64, 'id', None, None, ), # 1
7388 
  )
7389 
 
7390 
  def __init__(self, id=None,):
7391 
    self.id = id
7392 
 
7393 
  def read(self, iprot):
7394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7396 
      return
7397 
    iprot.readStructBegin()
7398 
    while True:
7399 
      (fname, ftype, fid) = iprot.readFieldBegin()
7400 
      if ftype == TType.STOP:
7401 
        break
7402 
      if fid == 1:
7403 
        if ftype == TType.I64:
7404 
          self.id = iprot.readI64();
7405 
        else:
7406 
          iprot.skip(ftype)
7407 
      else:
7408 
        iprot.skip(ftype)
7409 
      iprot.readFieldEnd()
7410 
    iprot.readStructEnd()
7411 
 
7412 
  def write(self, oprot):
7413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7415 
      return
7416 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7417 
    if self.id is not None:
1590 varun.gupt 7418 
      oprot.writeFieldBegin('id', TType.I64, 1)
7419 
      oprot.writeI64(self.id)
7420 
      oprot.writeFieldEnd()
7421 
    oprot.writeFieldStop()
7422 
    oprot.writeStructEnd()
7423 
 
3431 rajveer 7424 
  def validate(self):
7425 
    return
7426 
 
7427 
 
1590 varun.gupt 7428 
  def __repr__(self):
7429 
    L = ['%s=%r' % (key, value)
7430 
      for key, value in self.__dict__.iteritems()]
7431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7432 
 
7433 
  def __eq__(self, other):
7434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7435 
 
7436 
  def __ne__(self, other):
7437 
    return not (self == other)
7438 
 
7439 
class getUserCommunicationById_result:
7440 
  """
7441 
  Attributes:
7442 
   - success
7443 
   - ucx
7444 
  """
7445 
 
7446 
  thrift_spec = (
7447 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7448 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7449 
  )
7450 
 
7451 
  def __init__(self, success=None, ucx=None,):
7452 
    self.success = success
7453 
    self.ucx = ucx
7454 
 
7455 
  def read(self, iprot):
7456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7458 
      return
7459 
    iprot.readStructBegin()
7460 
    while True:
7461 
      (fname, ftype, fid) = iprot.readFieldBegin()
7462 
      if ftype == TType.STOP:
7463 
        break
7464 
      if fid == 0:
7465 
        if ftype == TType.STRUCT:
7466 
          self.success = UserCommunication()
7467 
          self.success.read(iprot)
7468 
        else:
7469 
          iprot.skip(ftype)
7470 
      elif fid == 1:
7471 
        if ftype == TType.STRUCT:
7472 
          self.ucx = UserCommunicationException()
7473 
          self.ucx.read(iprot)
7474 
        else:
7475 
          iprot.skip(ftype)
7476 
      else:
7477 
        iprot.skip(ftype)
7478 
      iprot.readFieldEnd()
7479 
    iprot.readStructEnd()
7480 
 
7481 
  def write(self, oprot):
7482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7484 
      return
7485 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7486 
    if self.success is not None:
1590 varun.gupt 7487 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7488 
      self.success.write(oprot)
7489 
      oprot.writeFieldEnd()
3431 rajveer 7490 
    if self.ucx is not None:
1590 varun.gupt 7491 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7492 
      self.ucx.write(oprot)
7493 
      oprot.writeFieldEnd()
7494 
    oprot.writeFieldStop()
7495 
    oprot.writeStructEnd()
7496 
 
3431 rajveer 7497 
  def validate(self):
7498 
    return
7499 
 
7500 
 
1590 varun.gupt 7501 
  def __repr__(self):
7502 
    L = ['%s=%r' % (key, value)
7503 
      for key, value in self.__dict__.iteritems()]
7504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7505 
 
7506 
  def __eq__(self, other):
7507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7508 
 
7509 
  def __ne__(self, other):
7510 
    return not (self == other)
7511 
 
7512 
class getUserCommunicationByUser_args:
7513 
  """
7514 
  Attributes:
7515 
   - userId
7516 
  """
7517 
 
7518 
  thrift_spec = (
7519 
    None, # 0
7520 
    (1, TType.I64, 'userId', None, None, ), # 1
7521 
  )
7522 
 
7523 
  def __init__(self, userId=None,):
7524 
    self.userId = userId
7525 
 
7526 
  def read(self, iprot):
7527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7529 
      return
7530 
    iprot.readStructBegin()
7531 
    while True:
7532 
      (fname, ftype, fid) = iprot.readFieldBegin()
7533 
      if ftype == TType.STOP:
7534 
        break
7535 
      if fid == 1:
7536 
        if ftype == TType.I64:
7537 
          self.userId = iprot.readI64();
7538 
        else:
7539 
          iprot.skip(ftype)
7540 
      else:
7541 
        iprot.skip(ftype)
7542 
      iprot.readFieldEnd()
7543 
    iprot.readStructEnd()
7544 
 
7545 
  def write(self, oprot):
7546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7548 
      return
7549 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7550 
    if self.userId is not None:
1590 varun.gupt 7551 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7552 
      oprot.writeI64(self.userId)
7553 
      oprot.writeFieldEnd()
7554 
    oprot.writeFieldStop()
7555 
    oprot.writeStructEnd()
7556 
 
3431 rajveer 7557 
  def validate(self):
7558 
    return
7559 
 
7560 
 
1590 varun.gupt 7561 
  def __repr__(self):
7562 
    L = ['%s=%r' % (key, value)
7563 
      for key, value in self.__dict__.iteritems()]
7564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7565 
 
7566 
  def __eq__(self, other):
7567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7568 
 
7569 
  def __ne__(self, other):
7570 
    return not (self == other)
7571 
 
7572 
class getUserCommunicationByUser_result:
7573 
  """
7574 
  Attributes:
7575 
   - success
7576 
   - ucx
7577 
  """
7578 
 
7579 
  thrift_spec = (
7580 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7581 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7582 
  )
7583 
 
7584 
  def __init__(self, success=None, ucx=None,):
7585 
    self.success = success
7586 
    self.ucx = ucx
7587 
 
7588 
  def read(self, iprot):
7589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7591 
      return
7592 
    iprot.readStructBegin()
7593 
    while True:
7594 
      (fname, ftype, fid) = iprot.readFieldBegin()
7595 
      if ftype == TType.STOP:
7596 
        break
7597 
      if fid == 0:
7598 
        if ftype == TType.LIST:
7599 
          self.success = []
11592 amit.gupta 7600 
          (_etype107, _size104) = iprot.readListBegin()
7601 
          for _i108 in xrange(_size104):
7602 
            _elem109 = UserCommunication()
7603 
            _elem109.read(iprot)
7604 
            self.success.append(_elem109)
1590 varun.gupt 7605 
          iprot.readListEnd()
7606 
        else:
7607 
          iprot.skip(ftype)
7608 
      elif fid == 1:
7609 
        if ftype == TType.STRUCT:
7610 
          self.ucx = UserCommunicationException()
7611 
          self.ucx.read(iprot)
7612 
        else:
7613 
          iprot.skip(ftype)
7614 
      else:
7615 
        iprot.skip(ftype)
7616 
      iprot.readFieldEnd()
7617 
    iprot.readStructEnd()
7618 
 
7619 
  def write(self, oprot):
7620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7622 
      return
7623 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7624 
    if self.success is not None:
1590 varun.gupt 7625 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7626 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7627 
      for iter110 in self.success:
7628 
        iter110.write(oprot)
1590 varun.gupt 7629 
      oprot.writeListEnd()
7630 
      oprot.writeFieldEnd()
3431 rajveer 7631 
    if self.ucx is not None:
1590 varun.gupt 7632 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7633 
      self.ucx.write(oprot)
7634 
      oprot.writeFieldEnd()
7635 
    oprot.writeFieldStop()
7636 
    oprot.writeStructEnd()
7637 
 
3431 rajveer 7638 
  def validate(self):
7639 
    return
7640 
 
7641 
 
1590 varun.gupt 7642 
  def __repr__(self):
7643 
    L = ['%s=%r' % (key, value)
7644 
      for key, value in self.__dict__.iteritems()]
7645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7646 
 
7647 
  def __eq__(self, other):
7648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7649 
 
7650 
  def __ne__(self, other):
7651 
    return not (self == other)
7652 
 
7653 
class getAllUserCommunications_args:
7654 
 
7655 
  thrift_spec = (
7656 
  )
7657 
 
7658 
  def read(self, iprot):
7659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7661 
      return
7662 
    iprot.readStructBegin()
7663 
    while True:
7664 
      (fname, ftype, fid) = iprot.readFieldBegin()
7665 
      if ftype == TType.STOP:
7666 
        break
7667 
      else:
7668 
        iprot.skip(ftype)
7669 
      iprot.readFieldEnd()
7670 
    iprot.readStructEnd()
7671 
 
7672 
  def write(self, oprot):
7673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7675 
      return
7676 
    oprot.writeStructBegin('getAllUserCommunications_args')
7677 
    oprot.writeFieldStop()
7678 
    oprot.writeStructEnd()
7679 
 
3431 rajveer 7680 
  def validate(self):
7681 
    return
7682 
 
7683 
 
1590 varun.gupt 7684 
  def __repr__(self):
7685 
    L = ['%s=%r' % (key, value)
7686 
      for key, value in self.__dict__.iteritems()]
7687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7688 
 
7689 
  def __eq__(self, other):
7690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7691 
 
7692 
  def __ne__(self, other):
7693 
    return not (self == other)
7694 
 
7695 
class getAllUserCommunications_result:
7696 
  """
7697 
  Attributes:
7698 
   - success
7699 
   - ucx
7700 
  """
7701 
 
7702 
  thrift_spec = (
7703 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7704 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7705 
  )
7706 
 
7707 
  def __init__(self, success=None, ucx=None,):
7708 
    self.success = success
7709 
    self.ucx = ucx
7710 
 
7711 
  def read(self, iprot):
7712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7714 
      return
7715 
    iprot.readStructBegin()
7716 
    while True:
7717 
      (fname, ftype, fid) = iprot.readFieldBegin()
7718 
      if ftype == TType.STOP:
7719 
        break
7720 
      if fid == 0:
7721 
        if ftype == TType.LIST:
7722 
          self.success = []
11592 amit.gupta 7723 
          (_etype114, _size111) = iprot.readListBegin()
7724 
          for _i115 in xrange(_size111):
7725 
            _elem116 = UserCommunication()
7726 
            _elem116.read(iprot)
7727 
            self.success.append(_elem116)
1590 varun.gupt 7728 
          iprot.readListEnd()
7729 
        else:
7730 
          iprot.skip(ftype)
7731 
      elif fid == 1:
7732 
        if ftype == TType.STRUCT:
7733 
          self.ucx = UserCommunicationException()
7734 
          self.ucx.read(iprot)
7735 
        else:
7736 
          iprot.skip(ftype)
7737 
      else:
7738 
        iprot.skip(ftype)
7739 
      iprot.readFieldEnd()
7740 
    iprot.readStructEnd()
7741 
 
7742 
  def write(self, oprot):
7743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7745 
      return
7746 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 7747 
    if self.success is not None:
1590 varun.gupt 7748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7749 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7750 
      for iter117 in self.success:
7751 
        iter117.write(oprot)
1590 varun.gupt 7752 
      oprot.writeListEnd()
7753 
      oprot.writeFieldEnd()
3431 rajveer 7754 
    if self.ucx is not None:
1590 varun.gupt 7755 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7756 
      self.ucx.write(oprot)
7757 
      oprot.writeFieldEnd()
7758 
    oprot.writeFieldStop()
7759 
    oprot.writeStructEnd()
7760 
 
3431 rajveer 7761 
  def validate(self):
7762 
    return
7763 
 
7764 
 
1590 varun.gupt 7765 
  def __repr__(self):
7766 
    L = ['%s=%r' % (key, value)
7767 
      for key, value in self.__dict__.iteritems()]
7768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7769 
 
7770 
  def __eq__(self, other):
7771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7772 
 
7773 
  def __ne__(self, other):
7774 
    return not (self == other)
7775 
 
5407 amar.kumar 7776 
class removeUserCommunication_args:
7777 
  """
7778 
  Attributes:
7779 
   - id
7780 
  """
7781 
 
7782 
  thrift_spec = (
7783 
    None, # 0
7784 
    (1, TType.I64, 'id', None, None, ), # 1
7785 
  )
7786 
 
7787 
  def __init__(self, id=None,):
7788 
    self.id = id
7789 
 
7790 
  def read(self, iprot):
7791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7793 
      return
7794 
    iprot.readStructBegin()
7795 
    while True:
7796 
      (fname, ftype, fid) = iprot.readFieldBegin()
7797 
      if ftype == TType.STOP:
7798 
        break
7799 
      if fid == 1:
7800 
        if ftype == TType.I64:
7801 
          self.id = iprot.readI64();
7802 
        else:
7803 
          iprot.skip(ftype)
7804 
      else:
7805 
        iprot.skip(ftype)
7806 
      iprot.readFieldEnd()
7807 
    iprot.readStructEnd()
7808 
 
7809 
  def write(self, oprot):
7810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7812 
      return
7813 
    oprot.writeStructBegin('removeUserCommunication_args')
7814 
    if self.id is not None:
7815 
      oprot.writeFieldBegin('id', TType.I64, 1)
7816 
      oprot.writeI64(self.id)
7817 
      oprot.writeFieldEnd()
7818 
    oprot.writeFieldStop()
7819 
    oprot.writeStructEnd()
7820 
 
7821 
  def validate(self):
7822 
    return
7823 
 
7824 
 
7825 
  def __repr__(self):
7826 
    L = ['%s=%r' % (key, value)
7827 
      for key, value in self.__dict__.iteritems()]
7828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7829 
 
7830 
  def __eq__(self, other):
7831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7832 
 
7833 
  def __ne__(self, other):
7834 
    return not (self == other)
7835 
 
7836 
class removeUserCommunication_result:
7837 
  """
7838 
  Attributes:
7839 
   - ucx
7840 
  """
7841 
 
7842 
  thrift_spec = (
7843 
    None, # 0
7844 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7845 
  )
7846 
 
7847 
  def __init__(self, ucx=None,):
7848 
    self.ucx = ucx
7849 
 
7850 
  def read(self, iprot):
7851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7853 
      return
7854 
    iprot.readStructBegin()
7855 
    while True:
7856 
      (fname, ftype, fid) = iprot.readFieldBegin()
7857 
      if ftype == TType.STOP:
7858 
        break
7859 
      if fid == 1:
7860 
        if ftype == TType.STRUCT:
7861 
          self.ucx = UserCommunicationException()
7862 
          self.ucx.read(iprot)
7863 
        else:
7864 
          iprot.skip(ftype)
7865 
      else:
7866 
        iprot.skip(ftype)
7867 
      iprot.readFieldEnd()
7868 
    iprot.readStructEnd()
7869 
 
7870 
  def write(self, oprot):
7871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7873 
      return
7874 
    oprot.writeStructBegin('removeUserCommunication_result')
7875 
    if self.ucx is not None:
7876 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7877 
      self.ucx.write(oprot)
7878 
      oprot.writeFieldEnd()
7879 
    oprot.writeFieldStop()
7880 
    oprot.writeStructEnd()
7881 
 
7882 
  def validate(self):
7883 
    return
7884 
 
7885 
 
7886 
  def __repr__(self):
7887 
    L = ['%s=%r' % (key, value)
7888 
      for key, value in self.__dict__.iteritems()]
7889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7890 
 
7891 
  def __eq__(self, other):
7892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7893 
 
7894 
  def __ne__(self, other):
7895 
    return not (self == other)
7896 
 
1845 vikas 7897 
class createMasterAffiliate_args:
7898 
  """
7899 
  Attributes:
7900 
   - name
1859 vikas 7901 
   - addedOn
1845 vikas 7902 
  """
7903 
 
7904 
  thrift_spec = (
7905 
    None, # 0
7906 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7907 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7908 
  )
7909 
 
1859 vikas 7910 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7911 
    self.name = name
1859 vikas 7912 
    self.addedOn = addedOn
1845 vikas 7913 
 
7914 
  def read(self, iprot):
7915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7917 
      return
7918 
    iprot.readStructBegin()
7919 
    while True:
7920 
      (fname, ftype, fid) = iprot.readFieldBegin()
7921 
      if ftype == TType.STOP:
7922 
        break
7923 
      if fid == 1:
7924 
        if ftype == TType.STRING:
7925 
          self.name = iprot.readString();
7926 
        else:
7927 
          iprot.skip(ftype)
1859 vikas 7928 
      elif fid == 2:
7929 
        if ftype == TType.I64:
7930 
          self.addedOn = iprot.readI64();
7931 
        else:
7932 
          iprot.skip(ftype)
1845 vikas 7933 
      else:
7934 
        iprot.skip(ftype)
7935 
      iprot.readFieldEnd()
7936 
    iprot.readStructEnd()
7937 
 
7938 
  def write(self, oprot):
7939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7941 
      return
7942 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 7943 
    if self.name is not None:
1845 vikas 7944 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7945 
      oprot.writeString(self.name)
7946 
      oprot.writeFieldEnd()
3431 rajveer 7947 
    if self.addedOn is not None:
1859 vikas 7948 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7949 
      oprot.writeI64(self.addedOn)
7950 
      oprot.writeFieldEnd()
1845 vikas 7951 
    oprot.writeFieldStop()
7952 
    oprot.writeStructEnd()
7953 
 
3431 rajveer 7954 
  def validate(self):
7955 
    return
7956 
 
7957 
 
1845 vikas 7958 
  def __repr__(self):
7959 
    L = ['%s=%r' % (key, value)
7960 
      for key, value in self.__dict__.iteritems()]
7961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7962 
 
7963 
  def __eq__(self, other):
7964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7965 
 
7966 
  def __ne__(self, other):
7967 
    return not (self == other)
7968 
 
7969 
class createMasterAffiliate_result:
7970 
  """
7971 
  Attributes:
7972 
   - success
7973 
   - utx
7974 
  """
7975 
 
7976 
  thrift_spec = (
7977 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7978 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7979 
  )
7980 
 
7981 
  def __init__(self, success=None, utx=None,):
7982 
    self.success = success
7983 
    self.utx = utx
7984 
 
7985 
  def read(self, iprot):
7986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7988 
      return
7989 
    iprot.readStructBegin()
7990 
    while True:
7991 
      (fname, ftype, fid) = iprot.readFieldBegin()
7992 
      if ftype == TType.STOP:
7993 
        break
7994 
      if fid == 0:
7995 
        if ftype == TType.STRUCT:
7996 
          self.success = MasterAffiliate()
7997 
          self.success.read(iprot)
7998 
        else:
7999 
          iprot.skip(ftype)
8000 
      elif fid == 1:
8001 
        if ftype == TType.STRUCT:
1996 vikas 8002 
          self.utx = UserAffiliateException()
1845 vikas 8003 
          self.utx.read(iprot)
8004 
        else:
8005 
          iprot.skip(ftype)
8006 
      else:
8007 
        iprot.skip(ftype)
8008 
      iprot.readFieldEnd()
8009 
    iprot.readStructEnd()
8010 
 
8011 
  def write(self, oprot):
8012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8014 
      return
8015 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8016 
    if self.success is not None:
1845 vikas 8017 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8018 
      self.success.write(oprot)
8019 
      oprot.writeFieldEnd()
3431 rajveer 8020 
    if self.utx is not None:
1845 vikas 8021 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8022 
      self.utx.write(oprot)
8023 
      oprot.writeFieldEnd()
8024 
    oprot.writeFieldStop()
8025 
    oprot.writeStructEnd()
8026 
 
3431 rajveer 8027 
  def validate(self):
8028 
    return
8029 
 
8030 
 
1845 vikas 8031 
  def __repr__(self):
8032 
    L = ['%s=%r' % (key, value)
8033 
      for key, value in self.__dict__.iteritems()]
8034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8035 
 
8036 
  def __eq__(self, other):
8037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8038 
 
8039 
  def __ne__(self, other):
8040 
    return not (self == other)
8041 
 
1899 vikas 8042 
class getAllMasterAffiliates_args:
8043 
 
8044 
  thrift_spec = (
8045 
  )
8046 
 
8047 
  def read(self, iprot):
8048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8050 
      return
8051 
    iprot.readStructBegin()
8052 
    while True:
8053 
      (fname, ftype, fid) = iprot.readFieldBegin()
8054 
      if ftype == TType.STOP:
8055 
        break
8056 
      else:
8057 
        iprot.skip(ftype)
8058 
      iprot.readFieldEnd()
8059 
    iprot.readStructEnd()
8060 
 
8061 
  def write(self, oprot):
8062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8064 
      return
8065 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8066 
    oprot.writeFieldStop()
8067 
    oprot.writeStructEnd()
8068 
 
3431 rajveer 8069 
  def validate(self):
8070 
    return
8071 
 
8072 
 
1899 vikas 8073 
  def __repr__(self):
8074 
    L = ['%s=%r' % (key, value)
8075 
      for key, value in self.__dict__.iteritems()]
8076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8077 
 
8078 
  def __eq__(self, other):
8079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8080 
 
8081 
  def __ne__(self, other):
8082 
    return not (self == other)
8083 
 
8084 
class getAllMasterAffiliates_result:
8085 
  """
8086 
  Attributes:
8087 
   - success
8088 
   - utx
8089 
  """
8090 
 
8091 
  thrift_spec = (
8092 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8093 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8094 
  )
8095 
 
8096 
  def __init__(self, success=None, utx=None,):
8097 
    self.success = success
8098 
    self.utx = utx
8099 
 
8100 
  def read(self, iprot):
8101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8103 
      return
8104 
    iprot.readStructBegin()
8105 
    while True:
8106 
      (fname, ftype, fid) = iprot.readFieldBegin()
8107 
      if ftype == TType.STOP:
8108 
        break
8109 
      if fid == 0:
8110 
        if ftype == TType.LIST:
8111 
          self.success = []
11592 amit.gupta 8112 
          (_etype121, _size118) = iprot.readListBegin()
8113 
          for _i122 in xrange(_size118):
8114 
            _elem123 = MasterAffiliate()
8115 
            _elem123.read(iprot)
8116 
            self.success.append(_elem123)
1899 vikas 8117 
          iprot.readListEnd()
8118 
        else:
8119 
          iprot.skip(ftype)
8120 
      elif fid == 1:
8121 
        if ftype == TType.STRUCT:
1996 vikas 8122 
          self.utx = UserAffiliateException()
1899 vikas 8123 
          self.utx.read(iprot)
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      else:
8127 
        iprot.skip(ftype)
8128 
      iprot.readFieldEnd()
8129 
    iprot.readStructEnd()
8130 
 
8131 
  def write(self, oprot):
8132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8134 
      return
8135 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8136 
    if self.success is not None:
1899 vikas 8137 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8138 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8139 
      for iter124 in self.success:
8140 
        iter124.write(oprot)
1899 vikas 8141 
      oprot.writeListEnd()
8142 
      oprot.writeFieldEnd()
3431 rajveer 8143 
    if self.utx is not None:
1899 vikas 8144 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8145 
      self.utx.write(oprot)
8146 
      oprot.writeFieldEnd()
8147 
    oprot.writeFieldStop()
8148 
    oprot.writeStructEnd()
8149 
 
3431 rajveer 8150 
  def validate(self):
8151 
    return
8152 
 
8153 
 
1899 vikas 8154 
  def __repr__(self):
8155 
    L = ['%s=%r' % (key, value)
8156 
      for key, value in self.__dict__.iteritems()]
8157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8158 
 
8159 
  def __eq__(self, other):
8160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8161 
 
8162 
  def __ne__(self, other):
8163 
    return not (self == other)
8164 
 
1845 vikas 8165 
class getMasterAffiliateById_args:
8166 
  """
8167 
  Attributes:
8168 
   - id
8169 
  """
8170 
 
8171 
  thrift_spec = (
8172 
    None, # 0
8173 
    (1, TType.I64, 'id', None, None, ), # 1
8174 
  )
8175 
 
8176 
  def __init__(self, id=None,):
8177 
    self.id = id
8178 
 
8179 
  def read(self, iprot):
8180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8182 
      return
8183 
    iprot.readStructBegin()
8184 
    while True:
8185 
      (fname, ftype, fid) = iprot.readFieldBegin()
8186 
      if ftype == TType.STOP:
8187 
        break
8188 
      if fid == 1:
8189 
        if ftype == TType.I64:
8190 
          self.id = iprot.readI64();
8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      else:
8194 
        iprot.skip(ftype)
8195 
      iprot.readFieldEnd()
8196 
    iprot.readStructEnd()
8197 
 
8198 
  def write(self, oprot):
8199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8201 
      return
8202 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8203 
    if self.id is not None:
1845 vikas 8204 
      oprot.writeFieldBegin('id', TType.I64, 1)
8205 
      oprot.writeI64(self.id)
8206 
      oprot.writeFieldEnd()
8207 
    oprot.writeFieldStop()
8208 
    oprot.writeStructEnd()
8209 
 
3431 rajveer 8210 
  def validate(self):
8211 
    return
8212 
 
8213 
 
1845 vikas 8214 
  def __repr__(self):
8215 
    L = ['%s=%r' % (key, value)
8216 
      for key, value in self.__dict__.iteritems()]
8217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8218 
 
8219 
  def __eq__(self, other):
8220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8221 
 
8222 
  def __ne__(self, other):
8223 
    return not (self == other)
8224 
 
8225 
class getMasterAffiliateById_result:
8226 
  """
8227 
  Attributes:
8228 
   - success
8229 
   - utx
8230 
  """
8231 
 
8232 
  thrift_spec = (
8233 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8234 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8235 
  )
8236 
 
8237 
  def __init__(self, success=None, utx=None,):
8238 
    self.success = success
8239 
    self.utx = utx
8240 
 
8241 
  def read(self, iprot):
8242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8244 
      return
8245 
    iprot.readStructBegin()
8246 
    while True:
8247 
      (fname, ftype, fid) = iprot.readFieldBegin()
8248 
      if ftype == TType.STOP:
8249 
        break
8250 
      if fid == 0:
8251 
        if ftype == TType.STRUCT:
8252 
          self.success = MasterAffiliate()
8253 
          self.success.read(iprot)
8254 
        else:
8255 
          iprot.skip(ftype)
8256 
      elif fid == 1:
8257 
        if ftype == TType.STRUCT:
1996 vikas 8258 
          self.utx = UserAffiliateException()
1845 vikas 8259 
          self.utx.read(iprot)
8260 
        else:
8261 
          iprot.skip(ftype)
8262 
      else:
8263 
        iprot.skip(ftype)
8264 
      iprot.readFieldEnd()
8265 
    iprot.readStructEnd()
8266 
 
8267 
  def write(self, oprot):
8268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8270 
      return
8271 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8272 
    if self.success is not None:
1845 vikas 8273 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8274 
      self.success.write(oprot)
8275 
      oprot.writeFieldEnd()
3431 rajveer 8276 
    if self.utx is not None:
1845 vikas 8277 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8278 
      self.utx.write(oprot)
8279 
      oprot.writeFieldEnd()
8280 
    oprot.writeFieldStop()
8281 
    oprot.writeStructEnd()
8282 
 
3431 rajveer 8283 
  def validate(self):
8284 
    return
8285 
 
8286 
 
1845 vikas 8287 
  def __repr__(self):
8288 
    L = ['%s=%r' % (key, value)
8289 
      for key, value in self.__dict__.iteritems()]
8290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8291 
 
8292 
  def __eq__(self, other):
8293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8294 
 
8295 
  def __ne__(self, other):
8296 
    return not (self == other)
8297 
 
8298 
class getMasterAffiliateByName_args:
8299 
  """
8300 
  Attributes:
8301 
   - name
8302 
  """
8303 
 
8304 
  thrift_spec = (
8305 
    None, # 0
8306 
    (1, TType.STRING, 'name', None, None, ), # 1
8307 
  )
8308 
 
8309 
  def __init__(self, name=None,):
8310 
    self.name = name
8311 
 
8312 
  def read(self, iprot):
8313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8315 
      return
8316 
    iprot.readStructBegin()
8317 
    while True:
8318 
      (fname, ftype, fid) = iprot.readFieldBegin()
8319 
      if ftype == TType.STOP:
8320 
        break
8321 
      if fid == 1:
8322 
        if ftype == TType.STRING:
8323 
          self.name = iprot.readString();
8324 
        else:
8325 
          iprot.skip(ftype)
8326 
      else:
8327 
        iprot.skip(ftype)
8328 
      iprot.readFieldEnd()
8329 
    iprot.readStructEnd()
8330 
 
8331 
  def write(self, oprot):
8332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8334 
      return
8335 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8336 
    if self.name is not None:
1845 vikas 8337 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8338 
      oprot.writeString(self.name)
8339 
      oprot.writeFieldEnd()
8340 
    oprot.writeFieldStop()
8341 
    oprot.writeStructEnd()
8342 
 
3431 rajveer 8343 
  def validate(self):
8344 
    return
8345 
 
8346 
 
1845 vikas 8347 
  def __repr__(self):
8348 
    L = ['%s=%r' % (key, value)
8349 
      for key, value in self.__dict__.iteritems()]
8350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8351 
 
8352 
  def __eq__(self, other):
8353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8354 
 
8355 
  def __ne__(self, other):
8356 
    return not (self == other)
8357 
 
8358 
class getMasterAffiliateByName_result:
8359 
  """
8360 
  Attributes:
8361 
   - success
8362 
   - utx
8363 
  """
8364 
 
8365 
  thrift_spec = (
8366 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8367 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8368 
  )
8369 
 
8370 
  def __init__(self, success=None, utx=None,):
8371 
    self.success = success
8372 
    self.utx = utx
8373 
 
8374 
  def read(self, iprot):
8375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8377 
      return
8378 
    iprot.readStructBegin()
8379 
    while True:
8380 
      (fname, ftype, fid) = iprot.readFieldBegin()
8381 
      if ftype == TType.STOP:
8382 
        break
8383 
      if fid == 0:
8384 
        if ftype == TType.STRUCT:
8385 
          self.success = MasterAffiliate()
8386 
          self.success.read(iprot)
8387 
        else:
8388 
          iprot.skip(ftype)
8389 
      elif fid == 1:
8390 
        if ftype == TType.STRUCT:
1996 vikas 8391 
          self.utx = UserAffiliateException()
1845 vikas 8392 
          self.utx.read(iprot)
8393 
        else:
8394 
          iprot.skip(ftype)
8395 
      else:
8396 
        iprot.skip(ftype)
8397 
      iprot.readFieldEnd()
8398 
    iprot.readStructEnd()
8399 
 
8400 
  def write(self, oprot):
8401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8403 
      return
8404 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8405 
    if self.success is not None:
1845 vikas 8406 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8407 
      self.success.write(oprot)
8408 
      oprot.writeFieldEnd()
3431 rajveer 8409 
    if self.utx is not None:
1845 vikas 8410 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8411 
      self.utx.write(oprot)
8412 
      oprot.writeFieldEnd()
8413 
    oprot.writeFieldStop()
8414 
    oprot.writeStructEnd()
8415 
 
3431 rajveer 8416 
  def validate(self):
8417 
    return
8418 
 
8419 
 
1845 vikas 8420 
  def __repr__(self):
8421 
    L = ['%s=%r' % (key, value)
8422 
      for key, value in self.__dict__.iteritems()]
8423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8424 
 
8425 
  def __eq__(self, other):
8426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8427 
 
8428 
  def __ne__(self, other):
8429 
    return not (self == other)
8430 
 
8431 
class createAffiliate_args:
8432 
  """
8433 
  Attributes:
8434 
   - name
8435 
   - url
8436 
   - masterAffiliateId
1859 vikas 8437 
   - addedOn
1845 vikas 8438 
  """
8439 
 
8440 
  thrift_spec = (
8441 
    None, # 0
8442 
    (1, TType.STRING, 'name', None, None, ), # 1
8443 
    (2, TType.STRING, 'url', None, None, ), # 2
8444 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8445 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8446 
  )
8447 
 
1859 vikas 8448 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8449 
    self.name = name
8450 
    self.url = url
8451 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8452 
    self.addedOn = addedOn
1845 vikas 8453 
 
8454 
  def read(self, iprot):
8455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8457 
      return
8458 
    iprot.readStructBegin()
8459 
    while True:
8460 
      (fname, ftype, fid) = iprot.readFieldBegin()
8461 
      if ftype == TType.STOP:
8462 
        break
8463 
      if fid == 1:
8464 
        if ftype == TType.STRING:
8465 
          self.name = iprot.readString();
8466 
        else:
8467 
          iprot.skip(ftype)
8468 
      elif fid == 2:
8469 
        if ftype == TType.STRING:
8470 
          self.url = iprot.readString();
8471 
        else:
8472 
          iprot.skip(ftype)
8473 
      elif fid == 3:
8474 
        if ftype == TType.I64:
8475 
          self.masterAffiliateId = iprot.readI64();
8476 
        else:
8477 
          iprot.skip(ftype)
1859 vikas 8478 
      elif fid == 4:
8479 
        if ftype == TType.I64:
8480 
          self.addedOn = iprot.readI64();
8481 
        else:
8482 
          iprot.skip(ftype)
1845 vikas 8483 
      else:
8484 
        iprot.skip(ftype)
8485 
      iprot.readFieldEnd()
8486 
    iprot.readStructEnd()
8487 
 
8488 
  def write(self, oprot):
8489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8491 
      return
8492 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8493 
    if self.name is not None:
1845 vikas 8494 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8495 
      oprot.writeString(self.name)
8496 
      oprot.writeFieldEnd()
3431 rajveer 8497 
    if self.url is not None:
1845 vikas 8498 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8499 
      oprot.writeString(self.url)
8500 
      oprot.writeFieldEnd()
3431 rajveer 8501 
    if self.masterAffiliateId is not None:
1845 vikas 8502 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8503 
      oprot.writeI64(self.masterAffiliateId)
8504 
      oprot.writeFieldEnd()
3431 rajveer 8505 
    if self.addedOn is not None:
1859 vikas 8506 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8507 
      oprot.writeI64(self.addedOn)
8508 
      oprot.writeFieldEnd()
1845 vikas 8509 
    oprot.writeFieldStop()
8510 
    oprot.writeStructEnd()
8511 
 
3431 rajveer 8512 
  def validate(self):
8513 
    return
8514 
 
8515 
 
1845 vikas 8516 
  def __repr__(self):
8517 
    L = ['%s=%r' % (key, value)
8518 
      for key, value in self.__dict__.iteritems()]
8519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8520 
 
8521 
  def __eq__(self, other):
8522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8523 
 
8524 
  def __ne__(self, other):
8525 
    return not (self == other)
8526 
 
8527 
class createAffiliate_result:
8528 
  """
8529 
  Attributes:
8530 
   - success
8531 
   - utx
8532 
  """
8533 
 
8534 
  thrift_spec = (
8535 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8536 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8537 
  )
8538 
 
8539 
  def __init__(self, success=None, utx=None,):
8540 
    self.success = success
8541 
    self.utx = utx
8542 
 
8543 
  def read(self, iprot):
8544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8546 
      return
8547 
    iprot.readStructBegin()
8548 
    while True:
8549 
      (fname, ftype, fid) = iprot.readFieldBegin()
8550 
      if ftype == TType.STOP:
8551 
        break
8552 
      if fid == 0:
8553 
        if ftype == TType.STRUCT:
8554 
          self.success = Affiliate()
8555 
          self.success.read(iprot)
8556 
        else:
8557 
          iprot.skip(ftype)
8558 
      elif fid == 1:
8559 
        if ftype == TType.STRUCT:
1996 vikas 8560 
          self.utx = UserAffiliateException()
1845 vikas 8561 
          self.utx.read(iprot)
8562 
        else:
8563 
          iprot.skip(ftype)
8564 
      else:
8565 
        iprot.skip(ftype)
8566 
      iprot.readFieldEnd()
8567 
    iprot.readStructEnd()
8568 
 
8569 
  def write(self, oprot):
8570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8572 
      return
8573 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8574 
    if self.success is not None:
1845 vikas 8575 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8576 
      self.success.write(oprot)
8577 
      oprot.writeFieldEnd()
3431 rajveer 8578 
    if self.utx is not None:
1845 vikas 8579 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8580 
      self.utx.write(oprot)
8581 
      oprot.writeFieldEnd()
8582 
    oprot.writeFieldStop()
8583 
    oprot.writeStructEnd()
8584 
 
3431 rajveer 8585 
  def validate(self):
8586 
    return
8587 
 
8588 
 
1845 vikas 8589 
  def __repr__(self):
8590 
    L = ['%s=%r' % (key, value)
8591 
      for key, value in self.__dict__.iteritems()]
8592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8593 
 
8594 
  def __eq__(self, other):
8595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8596 
 
8597 
  def __ne__(self, other):
8598 
    return not (self == other)
8599 
 
8600 
class getAffiliateById_args:
8601 
  """
8602 
  Attributes:
8603 
   - id
8604 
  """
8605 
 
8606 
  thrift_spec = (
8607 
    None, # 0
8608 
    (1, TType.I64, 'id', None, None, ), # 1
8609 
  )
8610 
 
8611 
  def __init__(self, id=None,):
8612 
    self.id = id
8613 
 
8614 
  def read(self, iprot):
8615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8617 
      return
8618 
    iprot.readStructBegin()
8619 
    while True:
8620 
      (fname, ftype, fid) = iprot.readFieldBegin()
8621 
      if ftype == TType.STOP:
8622 
        break
8623 
      if fid == 1:
8624 
        if ftype == TType.I64:
8625 
          self.id = iprot.readI64();
8626 
        else:
8627 
          iprot.skip(ftype)
8628 
      else:
8629 
        iprot.skip(ftype)
8630 
      iprot.readFieldEnd()
8631 
    iprot.readStructEnd()
8632 
 
8633 
  def write(self, oprot):
8634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8636 
      return
8637 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8638 
    if self.id is not None:
1845 vikas 8639 
      oprot.writeFieldBegin('id', TType.I64, 1)
8640 
      oprot.writeI64(self.id)
8641 
      oprot.writeFieldEnd()
8642 
    oprot.writeFieldStop()
8643 
    oprot.writeStructEnd()
8644 
 
3431 rajveer 8645 
  def validate(self):
8646 
    return
8647 
 
8648 
 
1845 vikas 8649 
  def __repr__(self):
8650 
    L = ['%s=%r' % (key, value)
8651 
      for key, value in self.__dict__.iteritems()]
8652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8653 
 
8654 
  def __eq__(self, other):
8655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8656 
 
8657 
  def __ne__(self, other):
8658 
    return not (self == other)
8659 
 
8660 
class getAffiliateById_result:
8661 
  """
8662 
  Attributes:
8663 
   - success
8664 
   - utx
8665 
  """
8666 
 
8667 
  thrift_spec = (
8668 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8669 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8670 
  )
8671 
 
8672 
  def __init__(self, success=None, utx=None,):
8673 
    self.success = success
8674 
    self.utx = utx
8675 
 
8676 
  def read(self, iprot):
8677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8679 
      return
8680 
    iprot.readStructBegin()
8681 
    while True:
8682 
      (fname, ftype, fid) = iprot.readFieldBegin()
8683 
      if ftype == TType.STOP:
8684 
        break
8685 
      if fid == 0:
8686 
        if ftype == TType.STRUCT:
8687 
          self.success = Affiliate()
8688 
          self.success.read(iprot)
8689 
        else:
8690 
          iprot.skip(ftype)
8691 
      elif fid == 1:
8692 
        if ftype == TType.STRUCT:
1996 vikas 8693 
          self.utx = UserAffiliateException()
1845 vikas 8694 
          self.utx.read(iprot)
8695 
        else:
8696 
          iprot.skip(ftype)
8697 
      else:
8698 
        iprot.skip(ftype)
8699 
      iprot.readFieldEnd()
8700 
    iprot.readStructEnd()
8701 
 
8702 
  def write(self, oprot):
8703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8705 
      return
8706 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 8707 
    if self.success is not None:
1845 vikas 8708 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8709 
      self.success.write(oprot)
8710 
      oprot.writeFieldEnd()
3431 rajveer 8711 
    if self.utx is not None:
1845 vikas 8712 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8713 
      self.utx.write(oprot)
8714 
      oprot.writeFieldEnd()
8715 
    oprot.writeFieldStop()
8716 
    oprot.writeStructEnd()
8717 
 
3431 rajveer 8718 
  def validate(self):
8719 
    return
8720 
 
8721 
 
1845 vikas 8722 
  def __repr__(self):
8723 
    L = ['%s=%r' % (key, value)
8724 
      for key, value in self.__dict__.iteritems()]
8725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8726 
 
8727 
  def __eq__(self, other):
8728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8729 
 
8730 
  def __ne__(self, other):
8731 
    return not (self == other)
8732 
 
8733 
class getAffiliateByName_args:
8734 
  """
8735 
  Attributes:
8736 
   - name
8737 
  """
8738 
 
8739 
  thrift_spec = (
8740 
    None, # 0
8741 
    (1, TType.STRING, 'name', None, None, ), # 1
8742 
  )
8743 
 
8744 
  def __init__(self, name=None,):
8745 
    self.name = name
8746 
 
8747 
  def read(self, iprot):
8748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8750 
      return
8751 
    iprot.readStructBegin()
8752 
    while True:
8753 
      (fname, ftype, fid) = iprot.readFieldBegin()
8754 
      if ftype == TType.STOP:
8755 
        break
8756 
      if fid == 1:
8757 
        if ftype == TType.STRING:
8758 
          self.name = iprot.readString();
8759 
        else:
8760 
          iprot.skip(ftype)
8761 
      else:
8762 
        iprot.skip(ftype)
8763 
      iprot.readFieldEnd()
8764 
    iprot.readStructEnd()
8765 
 
8766 
  def write(self, oprot):
8767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8769 
      return
8770 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 8771 
    if self.name is not None:
1845 vikas 8772 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8773 
      oprot.writeString(self.name)
8774 
      oprot.writeFieldEnd()
8775 
    oprot.writeFieldStop()
8776 
    oprot.writeStructEnd()
8777 
 
3431 rajveer 8778 
  def validate(self):
8779 
    return
8780 
 
8781 
 
1845 vikas 8782 
  def __repr__(self):
8783 
    L = ['%s=%r' % (key, value)
8784 
      for key, value in self.__dict__.iteritems()]
8785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8786 
 
8787 
  def __eq__(self, other):
8788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8789 
 
8790 
  def __ne__(self, other):
8791 
    return not (self == other)
8792 
 
8793 
class getAffiliateByName_result:
8794 
  """
8795 
  Attributes:
8796 
   - success
8797 
   - utx
8798 
  """
8799 
 
8800 
  thrift_spec = (
8801 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8802 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8803 
  )
8804 
 
8805 
  def __init__(self, success=None, utx=None,):
8806 
    self.success = success
8807 
    self.utx = utx
8808 
 
8809 
  def read(self, iprot):
8810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8812 
      return
8813 
    iprot.readStructBegin()
8814 
    while True:
8815 
      (fname, ftype, fid) = iprot.readFieldBegin()
8816 
      if ftype == TType.STOP:
8817 
        break
8818 
      if fid == 0:
8819 
        if ftype == TType.STRUCT:
8820 
          self.success = Affiliate()
8821 
          self.success.read(iprot)
8822 
        else:
8823 
          iprot.skip(ftype)
8824 
      elif fid == 1:
8825 
        if ftype == TType.STRUCT:
1996 vikas 8826 
          self.utx = UserAffiliateException()
1845 vikas 8827 
          self.utx.read(iprot)
8828 
        else:
8829 
          iprot.skip(ftype)
8830 
      else:
8831 
        iprot.skip(ftype)
8832 
      iprot.readFieldEnd()
8833 
    iprot.readStructEnd()
8834 
 
8835 
  def write(self, oprot):
8836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8838 
      return
8839 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 8840 
    if self.success is not None:
1845 vikas 8841 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8842 
      self.success.write(oprot)
8843 
      oprot.writeFieldEnd()
3431 rajveer 8844 
    if self.utx is not None:
1845 vikas 8845 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8846 
      self.utx.write(oprot)
8847 
      oprot.writeFieldEnd()
8848 
    oprot.writeFieldStop()
8849 
    oprot.writeStructEnd()
8850 
 
3431 rajveer 8851 
  def validate(self):
8852 
    return
8853 
 
8854 
 
1845 vikas 8855 
  def __repr__(self):
8856 
    L = ['%s=%r' % (key, value)
8857 
      for key, value in self.__dict__.iteritems()]
8858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8859 
 
8860 
  def __eq__(self, other):
8861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8862 
 
8863 
  def __ne__(self, other):
8864 
    return not (self == other)
8865 
 
1996 vikas 8866 
class getTrackerById_args:
1845 vikas 8867 
  """
8868 
  Attributes:
8869 
   - id
8870 
  """
8871 
 
8872 
  thrift_spec = (
8873 
    None, # 0
8874 
    (1, TType.I64, 'id', None, None, ), # 1
8875 
  )
8876 
 
8877 
  def __init__(self, id=None,):
8878 
    self.id = id
8879 
 
8880 
  def read(self, iprot):
8881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8883 
      return
8884 
    iprot.readStructBegin()
8885 
    while True:
8886 
      (fname, ftype, fid) = iprot.readFieldBegin()
8887 
      if ftype == TType.STOP:
8888 
        break
8889 
      if fid == 1:
8890 
        if ftype == TType.I64:
8891 
          self.id = iprot.readI64();
8892 
        else:
8893 
          iprot.skip(ftype)
8894 
      else:
8895 
        iprot.skip(ftype)
8896 
      iprot.readFieldEnd()
8897 
    iprot.readStructEnd()
8898 
 
8899 
  def write(self, oprot):
8900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8902 
      return
1996 vikas 8903 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 8904 
    if self.id is not None:
1845 vikas 8905 
      oprot.writeFieldBegin('id', TType.I64, 1)
8906 
      oprot.writeI64(self.id)
8907 
      oprot.writeFieldEnd()
8908 
    oprot.writeFieldStop()
8909 
    oprot.writeStructEnd()
8910 
 
3431 rajveer 8911 
  def validate(self):
8912 
    return
8913 
 
8914 
 
1845 vikas 8915 
  def __repr__(self):
8916 
    L = ['%s=%r' % (key, value)
8917 
      for key, value in self.__dict__.iteritems()]
8918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8919 
 
8920 
  def __eq__(self, other):
8921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8922 
 
8923 
  def __ne__(self, other):
8924 
    return not (self == other)
8925 
 
8926 
class getTrackerById_result:
8927 
  """
8928 
  Attributes:
8929 
   - success
8930 
   - utx
8931 
  """
8932 
 
8933 
  thrift_spec = (
8934 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8935 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8936 
  )
8937 
 
8938 
  def __init__(self, success=None, utx=None,):
8939 
    self.success = success
8940 
    self.utx = utx
8941 
 
8942 
  def read(self, iprot):
8943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8945 
      return
8946 
    iprot.readStructBegin()
8947 
    while True:
8948 
      (fname, ftype, fid) = iprot.readFieldBegin()
8949 
      if ftype == TType.STOP:
8950 
        break
8951 
      if fid == 0:
8952 
        if ftype == TType.STRUCT:
8953 
          self.success = Tracker()
8954 
          self.success.read(iprot)
8955 
        else:
8956 
          iprot.skip(ftype)
8957 
      elif fid == 1:
8958 
        if ftype == TType.STRUCT:
1996 vikas 8959 
          self.utx = UserAffiliateException()
1845 vikas 8960 
          self.utx.read(iprot)
8961 
        else:
8962 
          iprot.skip(ftype)
8963 
      else:
8964 
        iprot.skip(ftype)
8965 
      iprot.readFieldEnd()
8966 
    iprot.readStructEnd()
8967 
 
8968 
  def write(self, oprot):
8969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8971 
      return
8972 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 8973 
    if self.success is not None:
1845 vikas 8974 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8975 
      self.success.write(oprot)
8976 
      oprot.writeFieldEnd()
3431 rajveer 8977 
    if self.utx is not None:
1845 vikas 8978 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8979 
      self.utx.write(oprot)
8980 
      oprot.writeFieldEnd()
8981 
    oprot.writeFieldStop()
8982 
    oprot.writeStructEnd()
8983 
 
3431 rajveer 8984 
  def validate(self):
8985 
    return
8986 
 
8987 
 
1845 vikas 8988 
  def __repr__(self):
8989 
    L = ['%s=%r' % (key, value)
8990 
      for key, value in self.__dict__.iteritems()]
8991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8992 
 
8993 
  def __eq__(self, other):
8994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8995 
 
8996 
  def __ne__(self, other):
8997 
    return not (self == other)
8998 
 
1996 vikas 8999 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9000 
  """
9001 
  Attributes:
1996 vikas 9002 
   - id
1845 vikas 9003 
  """
9004 
 
9005 
  thrift_spec = (
9006 
    None, # 0
1996 vikas 9007 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9008 
  )
9009 
 
1996 vikas 9010 
  def __init__(self, id=None,):
9011 
    self.id = id
1845 vikas 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 == 1:
9023 
        if ftype == TType.I64:
1996 vikas 9024 
          self.id = iprot.readI64();
1845 vikas 9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      else:
9028 
        iprot.skip(ftype)
9029 
      iprot.readFieldEnd()
9030 
    iprot.readStructEnd()
9031 
 
9032 
  def write(self, oprot):
9033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9035 
      return
1996 vikas 9036 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9037 
    if self.id is not None:
1996 vikas 9038 
      oprot.writeFieldBegin('id', TType.I64, 1)
9039 
      oprot.writeI64(self.id)
1845 vikas 9040 
      oprot.writeFieldEnd()
9041 
    oprot.writeFieldStop()
9042 
    oprot.writeStructEnd()
9043 
 
3431 rajveer 9044 
  def validate(self):
9045 
    return
9046 
 
9047 
 
1845 vikas 9048 
  def __repr__(self):
9049 
    L = ['%s=%r' % (key, value)
9050 
      for key, value in self.__dict__.iteritems()]
9051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9052 
 
9053 
  def __eq__(self, other):
9054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9055 
 
9056 
  def __ne__(self, other):
9057 
    return not (self == other)
9058 
 
1996 vikas 9059 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9060 
  """
9061 
  Attributes:
9062 
   - success
9063 
   - utx
9064 
  """
9065 
 
9066 
  thrift_spec = (
1996 vikas 9067 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9068 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9069 
  )
9070 
 
9071 
  def __init__(self, success=None, utx=None,):
9072 
    self.success = success
9073 
    self.utx = utx
9074 
 
9075 
  def read(self, iprot):
9076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9078 
      return
9079 
    iprot.readStructBegin()
9080 
    while True:
9081 
      (fname, ftype, fid) = iprot.readFieldBegin()
9082 
      if ftype == TType.STOP:
9083 
        break
9084 
      if fid == 0:
9085 
        if ftype == TType.LIST:
9086 
          self.success = []
11592 amit.gupta 9087 
          (_etype128, _size125) = iprot.readListBegin()
9088 
          for _i129 in xrange(_size125):
9089 
            _elem130 = Affiliate()
9090 
            _elem130.read(iprot)
9091 
            self.success.append(_elem130)
1845 vikas 9092 
          iprot.readListEnd()
9093 
        else:
9094 
          iprot.skip(ftype)
9095 
      elif fid == 1:
9096 
        if ftype == TType.STRUCT:
1996 vikas 9097 
          self.utx = UserAffiliateException()
1845 vikas 9098 
          self.utx.read(iprot)
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      else:
9102 
        iprot.skip(ftype)
9103 
      iprot.readFieldEnd()
9104 
    iprot.readStructEnd()
9105 
 
9106 
  def write(self, oprot):
9107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9109 
      return
1996 vikas 9110 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9111 
    if self.success is not None:
1845 vikas 9112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9113 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9114 
      for iter131 in self.success:
9115 
        iter131.write(oprot)
1845 vikas 9116 
      oprot.writeListEnd()
9117 
      oprot.writeFieldEnd()
3431 rajveer 9118 
    if self.utx is not None:
1845 vikas 9119 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9120 
      self.utx.write(oprot)
9121 
      oprot.writeFieldEnd()
9122 
    oprot.writeFieldStop()
9123 
    oprot.writeStructEnd()
9124 
 
3431 rajveer 9125 
  def validate(self):
9126 
    return
9127 
 
9128 
 
1845 vikas 9129 
  def __repr__(self):
9130 
    L = ['%s=%r' % (key, value)
9131 
      for key, value in self.__dict__.iteritems()]
9132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9133 
 
9134 
  def __eq__(self, other):
9135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9136 
 
9137 
  def __ne__(self, other):
9138 
    return not (self == other)
9139 
 
9140 
class addTrackLog_args:
9141 
  """
9142 
  Attributes:
1996 vikas 9143 
   - affiliateId
1845 vikas 9144 
   - userId
9145 
   - event
9146 
   - url
9147 
   - data
1859 vikas 9148 
   - addedOn
1845 vikas 9149 
  """
9150 
 
9151 
  thrift_spec = (
9152 
    None, # 0
1996 vikas 9153 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9154 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9155 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9156 
    (4, TType.STRING, 'url', None, None, ), # 4
9157 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9158 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9159 
  )
9160 
 
1996 vikas 9161 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9162 
    self.affiliateId = affiliateId
1845 vikas 9163 
    self.userId = userId
9164 
    self.event = event
9165 
    self.url = url
9166 
    self.data = data
1859 vikas 9167 
    self.addedOn = addedOn
1845 vikas 9168 
 
9169 
  def read(self, iprot):
9170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9172 
      return
9173 
    iprot.readStructBegin()
9174 
    while True:
9175 
      (fname, ftype, fid) = iprot.readFieldBegin()
9176 
      if ftype == TType.STOP:
9177 
        break
9178 
      if fid == 1:
9179 
        if ftype == TType.I64:
1996 vikas 9180 
          self.affiliateId = iprot.readI64();
1845 vikas 9181 
        else:
9182 
          iprot.skip(ftype)
9183 
      elif fid == 2:
9184 
        if ftype == TType.I64:
9185 
          self.userId = iprot.readI64();
9186 
        else:
9187 
          iprot.skip(ftype)
9188 
      elif fid == 3:
3378 vikas 9189 
        if ftype == TType.I32:
9190 
          self.event = iprot.readI32();
1845 vikas 9191 
        else:
9192 
          iprot.skip(ftype)
9193 
      elif fid == 4:
9194 
        if ftype == TType.STRING:
9195 
          self.url = iprot.readString();
9196 
        else:
9197 
          iprot.skip(ftype)
9198 
      elif fid == 5:
9199 
        if ftype == TType.STRING:
9200 
          self.data = iprot.readString();
9201 
        else:
9202 
          iprot.skip(ftype)
1859 vikas 9203 
      elif fid == 6:
9204 
        if ftype == TType.I64:
9205 
          self.addedOn = iprot.readI64();
9206 
        else:
9207 
          iprot.skip(ftype)
1845 vikas 9208 
      else:
9209 
        iprot.skip(ftype)
9210 
      iprot.readFieldEnd()
9211 
    iprot.readStructEnd()
9212 
 
9213 
  def write(self, oprot):
9214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9216 
      return
9217 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9218 
    if self.affiliateId is not None:
1996 vikas 9219 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9220 
      oprot.writeI64(self.affiliateId)
1845 vikas 9221 
      oprot.writeFieldEnd()
3431 rajveer 9222 
    if self.userId is not None:
1845 vikas 9223 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9224 
      oprot.writeI64(self.userId)
9225 
      oprot.writeFieldEnd()
3431 rajveer 9226 
    if self.event is not None:
3378 vikas 9227 
      oprot.writeFieldBegin('event', TType.I32, 3)
9228 
      oprot.writeI32(self.event)
1845 vikas 9229 
      oprot.writeFieldEnd()
3431 rajveer 9230 
    if self.url is not None:
1845 vikas 9231 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9232 
      oprot.writeString(self.url)
9233 
      oprot.writeFieldEnd()
3431 rajveer 9234 
    if self.data is not None:
1845 vikas 9235 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9236 
      oprot.writeString(self.data)
9237 
      oprot.writeFieldEnd()
3431 rajveer 9238 
    if self.addedOn is not None:
1859 vikas 9239 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9240 
      oprot.writeI64(self.addedOn)
9241 
      oprot.writeFieldEnd()
1845 vikas 9242 
    oprot.writeFieldStop()
9243 
    oprot.writeStructEnd()
9244 
 
3431 rajveer 9245 
  def validate(self):
9246 
    return
9247 
 
9248 
 
1845 vikas 9249 
  def __repr__(self):
9250 
    L = ['%s=%r' % (key, value)
9251 
      for key, value in self.__dict__.iteritems()]
9252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9253 
 
9254 
  def __eq__(self, other):
9255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9256 
 
9257 
  def __ne__(self, other):
9258 
    return not (self == other)
9259 
 
9260 
class addTrackLog_result:
9261 
  """
9262 
  Attributes:
9263 
   - success
9264 
   - utx
9265 
  """
9266 
 
9267 
  thrift_spec = (
9268 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9269 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9270 
  )
9271 
 
9272 
  def __init__(self, success=None, utx=None,):
9273 
    self.success = success
9274 
    self.utx = utx
9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      if fid == 0:
9286 
        if ftype == TType.I64:
9287 
          self.success = iprot.readI64();
9288 
        else:
9289 
          iprot.skip(ftype)
9290 
      elif fid == 1:
9291 
        if ftype == TType.STRUCT:
1996 vikas 9292 
          self.utx = UserAffiliateException()
1845 vikas 9293 
          self.utx.read(iprot)
9294 
        else:
9295 
          iprot.skip(ftype)
9296 
      else:
9297 
        iprot.skip(ftype)
9298 
      iprot.readFieldEnd()
9299 
    iprot.readStructEnd()
9300 
 
9301 
  def write(self, oprot):
9302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9304 
      return
9305 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9306 
    if self.success is not None:
1845 vikas 9307 
      oprot.writeFieldBegin('success', TType.I64, 0)
9308 
      oprot.writeI64(self.success)
9309 
      oprot.writeFieldEnd()
3431 rajveer 9310 
    if self.utx is not None:
1845 vikas 9311 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9312 
      self.utx.write(oprot)
9313 
      oprot.writeFieldEnd()
9314 
    oprot.writeFieldStop()
9315 
    oprot.writeStructEnd()
9316 
 
3431 rajveer 9317 
  def validate(self):
9318 
    return
9319 
 
9320 
 
1845 vikas 9321 
  def __repr__(self):
9322 
    L = ['%s=%r' % (key, value)
9323 
      for key, value in self.__dict__.iteritems()]
9324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9325 
 
9326 
  def __eq__(self, other):
9327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9328 
 
9329 
  def __ne__(self, other):
9330 
    return not (self == other)
9331 
 
9332 
class getTrackLogById_args:
9333 
  """
9334 
  Attributes:
9335 
   - id
9336 
  """
9337 
 
9338 
  thrift_spec = (
9339 
    None, # 0
9340 
    (1, TType.I64, 'id', None, None, ), # 1
9341 
  )
9342 
 
9343 
  def __init__(self, id=None,):
9344 
    self.id = id
9345 
 
9346 
  def read(self, iprot):
9347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9349 
      return
9350 
    iprot.readStructBegin()
9351 
    while True:
9352 
      (fname, ftype, fid) = iprot.readFieldBegin()
9353 
      if ftype == TType.STOP:
9354 
        break
9355 
      if fid == 1:
9356 
        if ftype == TType.I64:
9357 
          self.id = iprot.readI64();
9358 
        else:
9359 
          iprot.skip(ftype)
9360 
      else:
9361 
        iprot.skip(ftype)
9362 
      iprot.readFieldEnd()
9363 
    iprot.readStructEnd()
9364 
 
9365 
  def write(self, oprot):
9366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9368 
      return
9369 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9370 
    if self.id is not None:
1845 vikas 9371 
      oprot.writeFieldBegin('id', TType.I64, 1)
9372 
      oprot.writeI64(self.id)
9373 
      oprot.writeFieldEnd()
9374 
    oprot.writeFieldStop()
9375 
    oprot.writeStructEnd()
9376 
 
3431 rajveer 9377 
  def validate(self):
9378 
    return
9379 
 
9380 
 
1845 vikas 9381 
  def __repr__(self):
9382 
    L = ['%s=%r' % (key, value)
9383 
      for key, value in self.__dict__.iteritems()]
9384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9385 
 
9386 
  def __eq__(self, other):
9387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9388 
 
9389 
  def __ne__(self, other):
9390 
    return not (self == other)
9391 
 
9392 
class getTrackLogById_result:
9393 
  """
9394 
  Attributes:
9395 
   - success
9396 
   - utx
9397 
  """
9398 
 
9399 
  thrift_spec = (
9400 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9401 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9402 
  )
9403 
 
9404 
  def __init__(self, success=None, utx=None,):
9405 
    self.success = success
9406 
    self.utx = utx
9407 
 
9408 
  def read(self, iprot):
9409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9411 
      return
9412 
    iprot.readStructBegin()
9413 
    while True:
9414 
      (fname, ftype, fid) = iprot.readFieldBegin()
9415 
      if ftype == TType.STOP:
9416 
        break
9417 
      if fid == 0:
9418 
        if ftype == TType.STRUCT:
9419 
          self.success = TrackLog()
9420 
          self.success.read(iprot)
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      elif fid == 1:
9424 
        if ftype == TType.STRUCT:
1996 vikas 9425 
          self.utx = UserAffiliateException()
1845 vikas 9426 
          self.utx.read(iprot)
9427 
        else:
9428 
          iprot.skip(ftype)
9429 
      else:
9430 
        iprot.skip(ftype)
9431 
      iprot.readFieldEnd()
9432 
    iprot.readStructEnd()
9433 
 
9434 
  def write(self, oprot):
9435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9437 
      return
9438 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9439 
    if self.success is not None:
1845 vikas 9440 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9441 
      self.success.write(oprot)
9442 
      oprot.writeFieldEnd()
3431 rajveer 9443 
    if self.utx is not None:
1845 vikas 9444 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9445 
      self.utx.write(oprot)
9446 
      oprot.writeFieldEnd()
9447 
    oprot.writeFieldStop()
9448 
    oprot.writeStructEnd()
9449 
 
3431 rajveer 9450 
  def validate(self):
9451 
    return
9452 
 
9453 
 
1845 vikas 9454 
  def __repr__(self):
9455 
    L = ['%s=%r' % (key, value)
9456 
      for key, value in self.__dict__.iteritems()]
9457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9458 
 
9459 
  def __eq__(self, other):
9460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9461 
 
9462 
  def __ne__(self, other):
9463 
    return not (self == other)
9464 
 
1996 vikas 9465 
class getTrackLogsByAffiliate_args:
1845 vikas 9466 
  """
9467 
  Attributes:
1996 vikas 9468 
   - affiliateId
3293 vikas 9469 
   - startDate
9470 
   - endDate
1845 vikas 9471 
  """
9472 
 
9473 
  thrift_spec = (
9474 
    None, # 0
1996 vikas 9475 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9476 
    (2, TType.I64, 'startDate', None, None, ), # 2
9477 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9478 
  )
9479 
 
3293 vikas 9480 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9481 
    self.affiliateId = affiliateId
3293 vikas 9482 
    self.startDate = startDate
9483 
    self.endDate = endDate
1845 vikas 9484 
 
9485 
  def read(self, iprot):
9486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9488 
      return
9489 
    iprot.readStructBegin()
9490 
    while True:
9491 
      (fname, ftype, fid) = iprot.readFieldBegin()
9492 
      if ftype == TType.STOP:
9493 
        break
9494 
      if fid == 1:
9495 
        if ftype == TType.I64:
1996 vikas 9496 
          self.affiliateId = iprot.readI64();
1845 vikas 9497 
        else:
9498 
          iprot.skip(ftype)
3293 vikas 9499 
      elif fid == 2:
9500 
        if ftype == TType.I64:
9501 
          self.startDate = iprot.readI64();
9502 
        else:
9503 
          iprot.skip(ftype)
9504 
      elif fid == 3:
9505 
        if ftype == TType.I64:
9506 
          self.endDate = iprot.readI64();
9507 
        else:
9508 
          iprot.skip(ftype)
1845 vikas 9509 
      else:
9510 
        iprot.skip(ftype)
9511 
      iprot.readFieldEnd()
9512 
    iprot.readStructEnd()
9513 
 
9514 
  def write(self, oprot):
9515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9517 
      return
1996 vikas 9518 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9519 
    if self.affiliateId is not None:
1996 vikas 9520 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9521 
      oprot.writeI64(self.affiliateId)
1845 vikas 9522 
      oprot.writeFieldEnd()
3431 rajveer 9523 
    if self.startDate is not None:
3293 vikas 9524 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9525 
      oprot.writeI64(self.startDate)
9526 
      oprot.writeFieldEnd()
3431 rajveer 9527 
    if self.endDate is not None:
3293 vikas 9528 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9529 
      oprot.writeI64(self.endDate)
9530 
      oprot.writeFieldEnd()
1845 vikas 9531 
    oprot.writeFieldStop()
9532 
    oprot.writeStructEnd()
9533 
 
3431 rajveer 9534 
  def validate(self):
9535 
    return
9536 
 
9537 
 
1845 vikas 9538 
  def __repr__(self):
9539 
    L = ['%s=%r' % (key, value)
9540 
      for key, value in self.__dict__.iteritems()]
9541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9542 
 
9543 
  def __eq__(self, other):
9544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9545 
 
9546 
  def __ne__(self, other):
9547 
    return not (self == other)
9548 
 
1996 vikas 9549 
class getTrackLogsByAffiliate_result:
1845 vikas 9550 
  """
9551 
  Attributes:
9552 
   - success
9553 
   - utx
9554 
  """
9555 
 
9556 
  thrift_spec = (
9557 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9558 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9559 
  )
9560 
 
9561 
  def __init__(self, success=None, utx=None,):
9562 
    self.success = success
9563 
    self.utx = utx
9564 
 
9565 
  def read(self, iprot):
9566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9568 
      return
9569 
    iprot.readStructBegin()
9570 
    while True:
9571 
      (fname, ftype, fid) = iprot.readFieldBegin()
9572 
      if ftype == TType.STOP:
9573 
        break
9574 
      if fid == 0:
9575 
        if ftype == TType.LIST:
9576 
          self.success = []
11592 amit.gupta 9577 
          (_etype135, _size132) = iprot.readListBegin()
9578 
          for _i136 in xrange(_size132):
9579 
            _elem137 = TrackLog()
9580 
            _elem137.read(iprot)
9581 
            self.success.append(_elem137)
1845 vikas 9582 
          iprot.readListEnd()
9583 
        else:
9584 
          iprot.skip(ftype)
9585 
      elif fid == 1:
9586 
        if ftype == TType.STRUCT:
1996 vikas 9587 
          self.utx = UserAffiliateException()
1845 vikas 9588 
          self.utx.read(iprot)
9589 
        else:
9590 
          iprot.skip(ftype)
9591 
      else:
9592 
        iprot.skip(ftype)
9593 
      iprot.readFieldEnd()
9594 
    iprot.readStructEnd()
9595 
 
9596 
  def write(self, oprot):
9597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9599 
      return
1996 vikas 9600 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9601 
    if self.success is not None:
1845 vikas 9602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9604 
      for iter138 in self.success:
9605 
        iter138.write(oprot)
1845 vikas 9606 
      oprot.writeListEnd()
9607 
      oprot.writeFieldEnd()
3431 rajveer 9608 
    if self.utx is not None:
1845 vikas 9609 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9610 
      self.utx.write(oprot)
9611 
      oprot.writeFieldEnd()
9612 
    oprot.writeFieldStop()
9613 
    oprot.writeStructEnd()
9614 
 
3431 rajveer 9615 
  def validate(self):
9616 
    return
9617 
 
9618 
 
1845 vikas 9619 
  def __repr__(self):
9620 
    L = ['%s=%r' % (key, value)
9621 
      for key, value in self.__dict__.iteritems()]
9622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9623 
 
9624 
  def __eq__(self, other):
9625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9626 
 
9627 
  def __ne__(self, other):
9628 
    return not (self == other)
9629 
 
9630 
class getTrackLogsByUser_args:
9631 
  """
9632 
  Attributes:
9633 
   - userId
9634 
  """
9635 
 
9636 
  thrift_spec = (
9637 
    None, # 0
9638 
    (1, TType.I64, 'userId', None, None, ), # 1
9639 
  )
9640 
 
9641 
  def __init__(self, userId=None,):
9642 
    self.userId = userId
9643 
 
9644 
  def read(self, iprot):
9645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9647 
      return
9648 
    iprot.readStructBegin()
9649 
    while True:
9650 
      (fname, ftype, fid) = iprot.readFieldBegin()
9651 
      if ftype == TType.STOP:
9652 
        break
9653 
      if fid == 1:
9654 
        if ftype == TType.I64:
9655 
          self.userId = iprot.readI64();
9656 
        else:
9657 
          iprot.skip(ftype)
9658 
      else:
9659 
        iprot.skip(ftype)
9660 
      iprot.readFieldEnd()
9661 
    iprot.readStructEnd()
9662 
 
9663 
  def write(self, oprot):
9664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9666 
      return
9667 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9668 
    if self.userId is not None:
1845 vikas 9669 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9670 
      oprot.writeI64(self.userId)
9671 
      oprot.writeFieldEnd()
9672 
    oprot.writeFieldStop()
9673 
    oprot.writeStructEnd()
9674 
 
3431 rajveer 9675 
  def validate(self):
9676 
    return
9677 
 
9678 
 
1845 vikas 9679 
  def __repr__(self):
9680 
    L = ['%s=%r' % (key, value)
9681 
      for key, value in self.__dict__.iteritems()]
9682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9683 
 
9684 
  def __eq__(self, other):
9685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9686 
 
9687 
  def __ne__(self, other):
9688 
    return not (self == other)
9689 
 
9690 
class getTrackLogsByUser_result:
9691 
  """
9692 
  Attributes:
9693 
   - success
9694 
   - utx
9695 
  """
9696 
 
9697 
  thrift_spec = (
9698 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9699 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9700 
  )
9701 
 
9702 
  def __init__(self, success=None, utx=None,):
9703 
    self.success = success
9704 
    self.utx = utx
9705 
 
9706 
  def read(self, iprot):
9707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9709 
      return
9710 
    iprot.readStructBegin()
9711 
    while True:
9712 
      (fname, ftype, fid) = iprot.readFieldBegin()
9713 
      if ftype == TType.STOP:
9714 
        break
9715 
      if fid == 0:
9716 
        if ftype == TType.LIST:
9717 
          self.success = []
11592 amit.gupta 9718 
          (_etype142, _size139) = iprot.readListBegin()
9719 
          for _i143 in xrange(_size139):
9720 
            _elem144 = TrackLog()
9721 
            _elem144.read(iprot)
9722 
            self.success.append(_elem144)
1845 vikas 9723 
          iprot.readListEnd()
9724 
        else:
9725 
          iprot.skip(ftype)
9726 
      elif fid == 1:
9727 
        if ftype == TType.STRUCT:
1996 vikas 9728 
          self.utx = UserAffiliateException()
1845 vikas 9729 
          self.utx.read(iprot)
9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      else:
9733 
        iprot.skip(ftype)
9734 
      iprot.readFieldEnd()
9735 
    iprot.readStructEnd()
9736 
 
9737 
  def write(self, oprot):
9738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9740 
      return
9741 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 9742 
    if self.success is not None:
1845 vikas 9743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9745 
      for iter145 in self.success:
9746 
        iter145.write(oprot)
1845 vikas 9747 
      oprot.writeListEnd()
9748 
      oprot.writeFieldEnd()
3431 rajveer 9749 
    if self.utx is not None:
1845 vikas 9750 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9751 
      self.utx.write(oprot)
9752 
      oprot.writeFieldEnd()
9753 
    oprot.writeFieldStop()
9754 
    oprot.writeStructEnd()
9755 
 
3431 rajveer 9756 
  def validate(self):
9757 
    return
9758 
 
9759 
 
1845 vikas 9760 
  def __repr__(self):
9761 
    L = ['%s=%r' % (key, value)
9762 
      for key, value in self.__dict__.iteritems()]
9763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9764 
 
9765 
  def __eq__(self, other):
9766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9767 
 
9768 
  def __ne__(self, other):
9769 
    return not (self == other)
9770 
 
9771 
class getTrackLogs_args:
9772 
  """
9773 
  Attributes:
9774 
   - userId
9775 
   - event
9776 
   - url
9777 
  """
9778 
 
9779 
  thrift_spec = (
9780 
    None, # 0
1996 vikas 9781 
    (1, TType.I64, 'userId', None, None, ), # 1
9782 
    (2, TType.STRING, 'event', None, None, ), # 2
9783 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9784 
  )
9785 
 
1996 vikas 9786 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9787 
    self.userId = userId
9788 
    self.event = event
9789 
    self.url = url
9790 
 
9791 
  def read(self, iprot):
9792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9794 
      return
9795 
    iprot.readStructBegin()
9796 
    while True:
9797 
      (fname, ftype, fid) = iprot.readFieldBegin()
9798 
      if ftype == TType.STOP:
9799 
        break
9800 
      if fid == 1:
9801 
        if ftype == TType.I64:
1996 vikas 9802 
          self.userId = iprot.readI64();
1845 vikas 9803 
        else:
9804 
          iprot.skip(ftype)
9805 
      elif fid == 2:
9806 
        if ftype == TType.STRING:
9807 
          self.event = iprot.readString();
9808 
        else:
9809 
          iprot.skip(ftype)
1996 vikas 9810 
      elif fid == 3:
1845 vikas 9811 
        if ftype == TType.STRING:
9812 
          self.url = iprot.readString();
9813 
        else:
9814 
          iprot.skip(ftype)
9815 
      else:
9816 
        iprot.skip(ftype)
9817 
      iprot.readFieldEnd()
9818 
    iprot.readStructEnd()
9819 
 
9820 
  def write(self, oprot):
9821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9823 
      return
9824 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 9825 
    if self.userId is not None:
1996 vikas 9826 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9827 
      oprot.writeI64(self.userId)
9828 
      oprot.writeFieldEnd()
3431 rajveer 9829 
    if self.event is not None:
1996 vikas 9830 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9831 
      oprot.writeString(self.event)
9832 
      oprot.writeFieldEnd()
3431 rajveer 9833 
    if self.url is not None:
1996 vikas 9834 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9835 
      oprot.writeString(self.url)
9836 
      oprot.writeFieldEnd()
9837 
    oprot.writeFieldStop()
9838 
    oprot.writeStructEnd()
9839 
 
3431 rajveer 9840 
  def validate(self):
9841 
    return
9842 
 
9843 
 
1845 vikas 9844 
  def __repr__(self):
9845 
    L = ['%s=%r' % (key, value)
9846 
      for key, value in self.__dict__.iteritems()]
9847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9848 
 
9849 
  def __eq__(self, other):
9850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9851 
 
9852 
  def __ne__(self, other):
9853 
    return not (self == other)
9854 
 
9855 
class getTrackLogs_result:
9856 
  """
9857 
  Attributes:
9858 
   - success
9859 
   - utx
9860 
  """
9861 
 
9862 
  thrift_spec = (
9863 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9864 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9865 
  )
9866 
 
9867 
  def __init__(self, success=None, utx=None,):
9868 
    self.success = success
9869 
    self.utx = utx
9870 
 
9871 
  def read(self, iprot):
9872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9874 
      return
9875 
    iprot.readStructBegin()
9876 
    while True:
9877 
      (fname, ftype, fid) = iprot.readFieldBegin()
9878 
      if ftype == TType.STOP:
9879 
        break
9880 
      if fid == 0:
9881 
        if ftype == TType.LIST:
9882 
          self.success = []
11592 amit.gupta 9883 
          (_etype149, _size146) = iprot.readListBegin()
9884 
          for _i150 in xrange(_size146):
9885 
            _elem151 = TrackLog()
9886 
            _elem151.read(iprot)
9887 
            self.success.append(_elem151)
1845 vikas 9888 
          iprot.readListEnd()
9889 
        else:
9890 
          iprot.skip(ftype)
9891 
      elif fid == 1:
9892 
        if ftype == TType.STRUCT:
1996 vikas 9893 
          self.utx = UserAffiliateException()
1845 vikas 9894 
          self.utx.read(iprot)
9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      else:
9898 
        iprot.skip(ftype)
9899 
      iprot.readFieldEnd()
9900 
    iprot.readStructEnd()
9901 
 
9902 
  def write(self, oprot):
9903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9905 
      return
9906 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 9907 
    if self.success is not None:
1845 vikas 9908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9910 
      for iter152 in self.success:
9911 
        iter152.write(oprot)
1845 vikas 9912 
      oprot.writeListEnd()
9913 
      oprot.writeFieldEnd()
3431 rajveer 9914 
    if self.utx is not None:
1845 vikas 9915 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9916 
      self.utx.write(oprot)
9917 
      oprot.writeFieldEnd()
9918 
    oprot.writeFieldStop()
9919 
    oprot.writeStructEnd()
9920 
 
3431 rajveer 9921 
  def validate(self):
9922 
    return
9923 
 
9924 
 
1845 vikas 9925 
  def __repr__(self):
9926 
    L = ['%s=%r' % (key, value)
9927 
      for key, value in self.__dict__.iteritems()]
9928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9929 
 
9930 
  def __eq__(self, other):
9931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9932 
 
9933 
  def __ne__(self, other):
9934 
    return not (self == other)
9935 
 
559 chandransh 9936 
class getCurrentCart_args:
94 ashish 9937 
  """
9938 
  Attributes:
559 chandransh 9939 
   - userId
9940 
  """
9941 
 
9942 
  thrift_spec = (
9943 
    None, # 0
9944 
    (1, TType.I64, 'userId', None, None, ), # 1
9945 
  )
9946 
 
9947 
  def __init__(self, userId=None,):
9948 
    self.userId = userId
9949 
 
9950 
  def read(self, iprot):
9951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9953 
      return
9954 
    iprot.readStructBegin()
9955 
    while True:
9956 
      (fname, ftype, fid) = iprot.readFieldBegin()
9957 
      if ftype == TType.STOP:
9958 
        break
9959 
      if fid == 1:
9960 
        if ftype == TType.I64:
9961 
          self.userId = iprot.readI64();
9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      else:
9965 
        iprot.skip(ftype)
9966 
      iprot.readFieldEnd()
9967 
    iprot.readStructEnd()
9968 
 
9969 
  def write(self, oprot):
9970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9972 
      return
9973 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 9974 
    if self.userId is not None:
559 chandransh 9975 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9976 
      oprot.writeI64(self.userId)
9977 
      oprot.writeFieldEnd()
9978 
    oprot.writeFieldStop()
9979 
    oprot.writeStructEnd()
9980 
 
3431 rajveer 9981 
  def validate(self):
9982 
    return
9983 
 
9984 
 
559 chandransh 9985 
  def __repr__(self):
9986 
    L = ['%s=%r' % (key, value)
9987 
      for key, value in self.__dict__.iteritems()]
9988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9989 
 
9990 
  def __eq__(self, other):
9991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9992 
 
9993 
  def __ne__(self, other):
9994 
    return not (self == other)
9995 
 
9996 
class getCurrentCart_result:
9997 
  """
9998 
  Attributes:
94 ashish 9999 
   - success
559 chandransh 10000 
   - scx
94 ashish 10001 
  """
10002 
 
10003 
  thrift_spec = (
559 chandransh 10004 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10005 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10006 
  )
10007 
 
559 chandransh 10008 
  def __init__(self, success=None, scx=None,):
94 ashish 10009 
    self.success = success
559 chandransh 10010 
    self.scx = scx
94 ashish 10011 
 
10012 
  def read(self, iprot):
10013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10015 
      return
10016 
    iprot.readStructBegin()
10017 
    while True:
10018 
      (fname, ftype, fid) = iprot.readFieldBegin()
10019 
      if ftype == TType.STOP:
10020 
        break
10021 
      if fid == 0:
559 chandransh 10022 
        if ftype == TType.STRUCT:
10023 
          self.success = Cart()
10024 
          self.success.read(iprot)
94 ashish 10025 
        else:
10026 
          iprot.skip(ftype)
10027 
      elif fid == 1:
10028 
        if ftype == TType.STRUCT:
559 chandransh 10029 
          self.scx = ShoppingCartException()
10030 
          self.scx.read(iprot)
94 ashish 10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      else:
10034 
        iprot.skip(ftype)
10035 
      iprot.readFieldEnd()
10036 
    iprot.readStructEnd()
10037 
 
10038 
  def write(self, oprot):
10039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10041 
      return
559 chandransh 10042 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10043 
    if self.success is not None:
559 chandransh 10044 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10045 
      self.success.write(oprot)
94 ashish 10046 
      oprot.writeFieldEnd()
3431 rajveer 10047 
    if self.scx is not None:
559 chandransh 10048 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10049 
      self.scx.write(oprot)
94 ashish 10050 
      oprot.writeFieldEnd()
10051 
    oprot.writeFieldStop()
10052 
    oprot.writeStructEnd()
10053 
 
3431 rajveer 10054 
  def validate(self):
10055 
    return
10056 
 
10057 
 
94 ashish 10058 
  def __repr__(self):
10059 
    L = ['%s=%r' % (key, value)
10060 
      for key, value in self.__dict__.iteritems()]
10061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10062 
 
10063 
  def __eq__(self, other):
10064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10065 
 
10066 
  def __ne__(self, other):
10067 
    return not (self == other)
10068 
 
559 chandransh 10069 
class getCart_args:
504 rajveer 10070 
  """
10071 
  Attributes:
559 chandransh 10072 
   - cartId
504 rajveer 10073 
  """
10074 
 
10075 
  thrift_spec = (
10076 
    None, # 0
559 chandransh 10077 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10078 
  )
10079 
 
559 chandransh 10080 
  def __init__(self, cartId=None,):
10081 
    self.cartId = cartId
504 rajveer 10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
10092 
      if fid == 1:
10093 
        if ftype == TType.I64:
559 chandransh 10094 
          self.cartId = iprot.readI64();
504 rajveer 10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
559 chandransh 10106 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10107 
    if self.cartId is not None:
559 chandransh 10108 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10109 
      oprot.writeI64(self.cartId)
504 rajveer 10110 
      oprot.writeFieldEnd()
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
3431 rajveer 10114 
  def validate(self):
10115 
    return
10116 
 
10117 
 
504 rajveer 10118 
  def __repr__(self):
10119 
    L = ['%s=%r' % (key, value)
10120 
      for key, value in self.__dict__.iteritems()]
10121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10122 
 
10123 
  def __eq__(self, other):
10124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10125 
 
10126 
  def __ne__(self, other):
10127 
    return not (self == other)
10128 
 
559 chandransh 10129 
class getCart_result:
504 rajveer 10130 
  """
10131 
  Attributes:
10132 
   - success
559 chandransh 10133 
   - scx
504 rajveer 10134 
  """
10135 
 
10136 
  thrift_spec = (
559 chandransh 10137 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10138 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10139 
  )
10140 
 
559 chandransh 10141 
  def __init__(self, success=None, scx=None,):
504 rajveer 10142 
    self.success = success
559 chandransh 10143 
    self.scx = scx
504 rajveer 10144 
 
10145 
  def read(self, iprot):
10146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10148 
      return
10149 
    iprot.readStructBegin()
10150 
    while True:
10151 
      (fname, ftype, fid) = iprot.readFieldBegin()
10152 
      if ftype == TType.STOP:
10153 
        break
10154 
      if fid == 0:
559 chandransh 10155 
        if ftype == TType.STRUCT:
10156 
          self.success = Cart()
10157 
          self.success.read(iprot)
504 rajveer 10158 
        else:
10159 
          iprot.skip(ftype)
10160 
      elif fid == 1:
10161 
        if ftype == TType.STRUCT:
559 chandransh 10162 
          self.scx = ShoppingCartException()
10163 
          self.scx.read(iprot)
504 rajveer 10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      else:
10167 
        iprot.skip(ftype)
10168 
      iprot.readFieldEnd()
10169 
    iprot.readStructEnd()
10170 
 
10171 
  def write(self, oprot):
10172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10174 
      return
559 chandransh 10175 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10176 
    if self.success is not None:
559 chandransh 10177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10178 
      self.success.write(oprot)
504 rajveer 10179 
      oprot.writeFieldEnd()
3431 rajveer 10180 
    if self.scx is not None:
559 chandransh 10181 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10182 
      self.scx.write(oprot)
504 rajveer 10183 
      oprot.writeFieldEnd()
10184 
    oprot.writeFieldStop()
10185 
    oprot.writeStructEnd()
10186 
 
3431 rajveer 10187 
  def validate(self):
10188 
    return
10189 
 
10190 
 
504 rajveer 10191 
  def __repr__(self):
10192 
    L = ['%s=%r' % (key, value)
10193 
      for key, value in self.__dict__.iteritems()]
10194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10195 
 
10196 
  def __eq__(self, other):
10197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10198 
 
10199 
  def __ne__(self, other):
10200 
    return not (self == other)
10201 
 
559 chandransh 10202 
class getCartsByTime_args:
10203 
  """
10204 
  Attributes:
10205 
   - from_time
10206 
   - to_time
10207 
   - status
10208 
  """
10209 
 
10210 
  thrift_spec = (
10211 
    None, # 0
10212 
    (1, TType.I64, 'from_time', None, None, ), # 1
10213 
    (2, TType.I64, 'to_time', None, None, ), # 2
10214 
    (3, TType.I32, 'status', None, None, ), # 3
10215 
  )
10216 
 
10217 
  def __init__(self, from_time=None, to_time=None, status=None,):
10218 
    self.from_time = from_time
10219 
    self.to_time = to_time
10220 
    self.status = status
10221 
 
10222 
  def read(self, iprot):
10223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10225 
      return
10226 
    iprot.readStructBegin()
10227 
    while True:
10228 
      (fname, ftype, fid) = iprot.readFieldBegin()
10229 
      if ftype == TType.STOP:
10230 
        break
10231 
      if fid == 1:
94 ashish 10232 
        if ftype == TType.I64:
559 chandransh 10233 
          self.from_time = iprot.readI64();
94 ashish 10234 
        else:
10235 
          iprot.skip(ftype)
122 ashish 10236 
      elif fid == 2:
559 chandransh 10237 
        if ftype == TType.I64:
10238 
          self.to_time = iprot.readI64();
122 ashish 10239 
        else:
10240 
          iprot.skip(ftype)
559 chandransh 10241 
      elif fid == 3:
10242 
        if ftype == TType.I32:
10243 
          self.status = iprot.readI32();
10244 
        else:
10245 
          iprot.skip(ftype)
94 ashish 10246 
      else:
10247 
        iprot.skip(ftype)
10248 
      iprot.readFieldEnd()
10249 
    iprot.readStructEnd()
10250 
 
10251 
  def write(self, oprot):
10252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10254 
      return
559 chandransh 10255 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10256 
    if self.from_time is not None:
559 chandransh 10257 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10258 
      oprot.writeI64(self.from_time)
94 ashish 10259 
      oprot.writeFieldEnd()
3431 rajveer 10260 
    if self.to_time is not None:
559 chandransh 10261 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10262 
      oprot.writeI64(self.to_time)
122 ashish 10263 
      oprot.writeFieldEnd()
3431 rajveer 10264 
    if self.status is not None:
559 chandransh 10265 
      oprot.writeFieldBegin('status', TType.I32, 3)
10266 
      oprot.writeI32(self.status)
10267 
      oprot.writeFieldEnd()
94 ashish 10268 
    oprot.writeFieldStop()
10269 
    oprot.writeStructEnd()
10270 
 
3431 rajveer 10271 
  def validate(self):
10272 
    return
10273 
 
10274 
 
94 ashish 10275 
  def __repr__(self):
10276 
    L = ['%s=%r' % (key, value)
10277 
      for key, value in self.__dict__.iteritems()]
10278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10279 
 
10280 
  def __eq__(self, other):
10281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10282 
 
10283 
  def __ne__(self, other):
10284 
    return not (self == other)
10285 
 
559 chandransh 10286 
class getCartsByTime_result:
94 ashish 10287 
  """
10288 
  Attributes:
10289 
   - success
559 chandransh 10290 
   - scx
94 ashish 10291 
  """
10292 
 
10293 
  thrift_spec = (
559 chandransh 10294 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10295 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10296 
  )
10297 
 
559 chandransh 10298 
  def __init__(self, success=None, scx=None,):
94 ashish 10299 
    self.success = success
559 chandransh 10300 
    self.scx = scx
94 ashish 10301 
 
10302 
  def read(self, iprot):
10303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10305 
      return
10306 
    iprot.readStructBegin()
10307 
    while True:
10308 
      (fname, ftype, fid) = iprot.readFieldBegin()
10309 
      if ftype == TType.STOP:
10310 
        break
10311 
      if fid == 0:
559 chandransh 10312 
        if ftype == TType.LIST:
10313 
          self.success = []
11592 amit.gupta 10314 
          (_etype156, _size153) = iprot.readListBegin()
10315 
          for _i157 in xrange(_size153):
10316 
            _elem158 = Cart()
10317 
            _elem158.read(iprot)
10318 
            self.success.append(_elem158)
559 chandransh 10319 
          iprot.readListEnd()
94 ashish 10320 
        else:
10321 
          iprot.skip(ftype)
10322 
      elif fid == 1:
10323 
        if ftype == TType.STRUCT:
559 chandransh 10324 
          self.scx = ShoppingCartException()
10325 
          self.scx.read(iprot)
94 ashish 10326 
        else:
10327 
          iprot.skip(ftype)
10328 
      else:
10329 
        iprot.skip(ftype)
10330 
      iprot.readFieldEnd()
10331 
    iprot.readStructEnd()
10332 
 
10333 
  def write(self, oprot):
10334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10336 
      return
559 chandransh 10337 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10338 
    if self.success is not None:
559 chandransh 10339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10340 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10341 
      for iter159 in self.success:
10342 
        iter159.write(oprot)
559 chandransh 10343 
      oprot.writeListEnd()
94 ashish 10344 
      oprot.writeFieldEnd()
3431 rajveer 10345 
    if self.scx is not None:
559 chandransh 10346 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10347 
      self.scx.write(oprot)
94 ashish 10348 
      oprot.writeFieldEnd()
10349 
    oprot.writeFieldStop()
10350 
    oprot.writeStructEnd()
10351 
 
3431 rajveer 10352 
  def validate(self):
10353 
    return
10354 
 
10355 
 
94 ashish 10356 
  def __repr__(self):
10357 
    L = ['%s=%r' % (key, value)
10358 
      for key, value in self.__dict__.iteritems()]
10359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10360 
 
10361 
  def __eq__(self, other):
10362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10363 
 
10364 
  def __ne__(self, other):
10365 
    return not (self == other)
10366 
 
559 chandransh 10367 
class addItemToCart_args:
10368 
  """
10369 
  Attributes:
10370 
   - cartId
10371 
   - itemId
10372 
   - quantity
3557 rajveer 10373 
   - sourceId
559 chandransh 10374 
  """
10375 
 
10376 
  thrift_spec = (
10377 
    None, # 0
10378 
    (1, TType.I64, 'cartId', None, None, ), # 1
10379 
    (2, TType.I64, 'itemId', None, None, ), # 2
10380 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10381 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10382 
  )
10383 
 
3557 rajveer 10384 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10385 
    self.cartId = cartId
10386 
    self.itemId = itemId
10387 
    self.quantity = quantity
3557 rajveer 10388 
    self.sourceId = sourceId
559 chandransh 10389 
 
10390 
  def read(self, iprot):
10391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10393 
      return
10394 
    iprot.readStructBegin()
10395 
    while True:
10396 
      (fname, ftype, fid) = iprot.readFieldBegin()
10397 
      if ftype == TType.STOP:
10398 
        break
10399 
      if fid == 1:
10400 
        if ftype == TType.I64:
10401 
          self.cartId = iprot.readI64();
10402 
        else:
10403 
          iprot.skip(ftype)
10404 
      elif fid == 2:
10405 
        if ftype == TType.I64:
10406 
          self.itemId = iprot.readI64();
10407 
        else:
10408 
          iprot.skip(ftype)
10409 
      elif fid == 3:
10410 
        if ftype == TType.I64:
10411 
          self.quantity = iprot.readI64();
10412 
        else:
10413 
          iprot.skip(ftype)
3557 rajveer 10414 
      elif fid == 4:
10415 
        if ftype == TType.I64:
10416 
          self.sourceId = iprot.readI64();
10417 
        else:
10418 
          iprot.skip(ftype)
559 chandransh 10419 
      else:
10420 
        iprot.skip(ftype)
10421 
      iprot.readFieldEnd()
10422 
    iprot.readStructEnd()
10423 
 
10424 
  def write(self, oprot):
10425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10427 
      return
10428 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10429 
    if self.cartId is not None:
559 chandransh 10430 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10431 
      oprot.writeI64(self.cartId)
10432 
      oprot.writeFieldEnd()
3431 rajveer 10433 
    if self.itemId is not None:
559 chandransh 10434 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10435 
      oprot.writeI64(self.itemId)
10436 
      oprot.writeFieldEnd()
3431 rajveer 10437 
    if self.quantity is not None:
559 chandransh 10438 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10439 
      oprot.writeI64(self.quantity)
10440 
      oprot.writeFieldEnd()
3557 rajveer 10441 
    if self.sourceId is not None:
10442 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10443 
      oprot.writeI64(self.sourceId)
10444 
      oprot.writeFieldEnd()
559 chandransh 10445 
    oprot.writeFieldStop()
10446 
    oprot.writeStructEnd()
10447 
 
3431 rajveer 10448 
  def validate(self):
10449 
    return
10450 
 
10451 
 
559 chandransh 10452 
  def __repr__(self):
10453 
    L = ['%s=%r' % (key, value)
10454 
      for key, value in self.__dict__.iteritems()]
10455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10456 
 
10457 
  def __eq__(self, other):
10458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10459 
 
10460 
  def __ne__(self, other):
10461 
    return not (self == other)
10462 
 
10463 
class addItemToCart_result:
10464 
  """
10465 
  Attributes:
2035 rajveer 10466 
   - success
559 chandransh 10467 
   - scx
10468 
  """
10469 
 
10470 
  thrift_spec = (
2035 rajveer 10471 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10472 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10473 
  )
10474 
 
2035 rajveer 10475 
  def __init__(self, success=None, scx=None,):
10476 
    self.success = success
559 chandransh 10477 
    self.scx = scx
10478 
 
10479 
  def read(self, iprot):
10480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10482 
      return
10483 
    iprot.readStructBegin()
10484 
    while True:
10485 
      (fname, ftype, fid) = iprot.readFieldBegin()
10486 
      if ftype == TType.STOP:
10487 
        break
2035 rajveer 10488 
      if fid == 0:
10489 
        if ftype == TType.STRING:
10490 
          self.success = iprot.readString();
10491 
        else:
10492 
          iprot.skip(ftype)
10493 
      elif fid == 1:
559 chandransh 10494 
        if ftype == TType.STRUCT:
10495 
          self.scx = ShoppingCartException()
10496 
          self.scx.read(iprot)
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      else:
10500 
        iprot.skip(ftype)
10501 
      iprot.readFieldEnd()
10502 
    iprot.readStructEnd()
10503 
 
10504 
  def write(self, oprot):
10505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10507 
      return
10508 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10509 
    if self.success is not None:
2035 rajveer 10510 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10511 
      oprot.writeString(self.success)
10512 
      oprot.writeFieldEnd()
3431 rajveer 10513 
    if self.scx is not None:
559 chandransh 10514 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10515 
      self.scx.write(oprot)
10516 
      oprot.writeFieldEnd()
10517 
    oprot.writeFieldStop()
10518 
    oprot.writeStructEnd()
10519 
 
3431 rajveer 10520 
  def validate(self):
10521 
    return
10522 
 
10523 
 
559 chandransh 10524 
  def __repr__(self):
10525 
    L = ['%s=%r' % (key, value)
10526 
      for key, value in self.__dict__.iteritems()]
10527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10528 
 
10529 
  def __eq__(self, other):
10530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10531 
 
10532 
  def __ne__(self, other):
10533 
    return not (self == other)
10534 
 
10535 
class deleteItemFromCart_args:
10536 
  """
10537 
  Attributes:
10538 
   - cartId
10539 
   - itemId
10540 
  """
10541 
 
10542 
  thrift_spec = (
10543 
    None, # 0
10544 
    (1, TType.I64, 'cartId', None, None, ), # 1
10545 
    (2, TType.I64, 'itemId', None, None, ), # 2
10546 
  )
10547 
 
10548 
  def __init__(self, cartId=None, itemId=None,):
10549 
    self.cartId = cartId
10550 
    self.itemId = itemId
10551 
 
10552 
  def read(self, iprot):
10553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10555 
      return
10556 
    iprot.readStructBegin()
10557 
    while True:
10558 
      (fname, ftype, fid) = iprot.readFieldBegin()
10559 
      if ftype == TType.STOP:
10560 
        break
10561 
      if fid == 1:
10562 
        if ftype == TType.I64:
10563 
          self.cartId = iprot.readI64();
10564 
        else:
10565 
          iprot.skip(ftype)
10566 
      elif fid == 2:
10567 
        if ftype == TType.I64:
10568 
          self.itemId = iprot.readI64();
10569 
        else:
10570 
          iprot.skip(ftype)
10571 
      else:
10572 
        iprot.skip(ftype)
10573 
      iprot.readFieldEnd()
10574 
    iprot.readStructEnd()
10575 
 
10576 
  def write(self, oprot):
10577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10579 
      return
10580 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10581 
    if self.cartId is not None:
559 chandransh 10582 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10583 
      oprot.writeI64(self.cartId)
10584 
      oprot.writeFieldEnd()
3431 rajveer 10585 
    if self.itemId is not None:
559 chandransh 10586 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10587 
      oprot.writeI64(self.itemId)
10588 
      oprot.writeFieldEnd()
10589 
    oprot.writeFieldStop()
10590 
    oprot.writeStructEnd()
10591 
 
3431 rajveer 10592 
  def validate(self):
10593 
    return
10594 
 
10595 
 
559 chandransh 10596 
  def __repr__(self):
10597 
    L = ['%s=%r' % (key, value)
10598 
      for key, value in self.__dict__.iteritems()]
10599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10600 
 
10601 
  def __eq__(self, other):
10602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10603 
 
10604 
  def __ne__(self, other):
10605 
    return not (self == other)
10606 
 
10607 
class deleteItemFromCart_result:
10608 
  """
10609 
  Attributes:
10610 
   - scx
10611 
  """
10612 
 
10613 
  thrift_spec = (
10614 
    None, # 0
10615 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10616 
  )
10617 
 
10618 
  def __init__(self, scx=None,):
10619 
    self.scx = scx
10620 
 
10621 
  def read(self, iprot):
10622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10624 
      return
10625 
    iprot.readStructBegin()
10626 
    while True:
10627 
      (fname, ftype, fid) = iprot.readFieldBegin()
10628 
      if ftype == TType.STOP:
10629 
        break
10630 
      if fid == 1:
10631 
        if ftype == TType.STRUCT:
10632 
          self.scx = ShoppingCartException()
10633 
          self.scx.read(iprot)
10634 
        else:
10635 
          iprot.skip(ftype)
10636 
      else:
10637 
        iprot.skip(ftype)
10638 
      iprot.readFieldEnd()
10639 
    iprot.readStructEnd()
10640 
 
10641 
  def write(self, oprot):
10642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10644 
      return
10645 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10646 
    if self.scx is not None:
559 chandransh 10647 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10648 
      self.scx.write(oprot)
10649 
      oprot.writeFieldEnd()
10650 
    oprot.writeFieldStop()
10651 
    oprot.writeStructEnd()
10652 
 
3431 rajveer 10653 
  def validate(self):
10654 
    return
10655 
 
10656 
 
559 chandransh 10657 
  def __repr__(self):
10658 
    L = ['%s=%r' % (key, value)
10659 
      for key, value in self.__dict__.iteritems()]
10660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10661 
 
10662 
  def __eq__(self, other):
10663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10664 
 
10665 
  def __ne__(self, other):
10666 
    return not (self == other)
10667 
 
10668 
class addAddressToCart_args:
10669 
  """
10670 
  Attributes:
10671 
   - cartId
10672 
   - addressId
10673 
  """
10674 
 
10675 
  thrift_spec = (
10676 
    None, # 0
10677 
    (1, TType.I64, 'cartId', None, None, ), # 1
10678 
    (2, TType.I64, 'addressId', None, None, ), # 2
10679 
  )
10680 
 
10681 
  def __init__(self, cartId=None, addressId=None,):
10682 
    self.cartId = cartId
10683 
    self.addressId = addressId
10684 
 
10685 
  def read(self, iprot):
10686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10688 
      return
10689 
    iprot.readStructBegin()
10690 
    while True:
10691 
      (fname, ftype, fid) = iprot.readFieldBegin()
10692 
      if ftype == TType.STOP:
10693 
        break
10694 
      if fid == 1:
10695 
        if ftype == TType.I64:
10696 
          self.cartId = iprot.readI64();
10697 
        else:
10698 
          iprot.skip(ftype)
10699 
      elif fid == 2:
10700 
        if ftype == TType.I64:
10701 
          self.addressId = iprot.readI64();
10702 
        else:
10703 
          iprot.skip(ftype)
10704 
      else:
10705 
        iprot.skip(ftype)
10706 
      iprot.readFieldEnd()
10707 
    iprot.readStructEnd()
10708 
 
10709 
  def write(self, oprot):
10710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10712 
      return
10713 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 10714 
    if self.cartId is not None:
559 chandransh 10715 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10716 
      oprot.writeI64(self.cartId)
10717 
      oprot.writeFieldEnd()
3431 rajveer 10718 
    if self.addressId is not None:
559 chandransh 10719 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10720 
      oprot.writeI64(self.addressId)
10721 
      oprot.writeFieldEnd()
10722 
    oprot.writeFieldStop()
10723 
    oprot.writeStructEnd()
10724 
 
3431 rajveer 10725 
  def validate(self):
10726 
    return
10727 
 
10728 
 
559 chandransh 10729 
  def __repr__(self):
10730 
    L = ['%s=%r' % (key, value)
10731 
      for key, value in self.__dict__.iteritems()]
10732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10733 
 
10734 
  def __eq__(self, other):
10735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10736 
 
10737 
  def __ne__(self, other):
10738 
    return not (self == other)
10739 
 
10740 
class addAddressToCart_result:
575 chandransh 10741 
  """
10742 
  Attributes:
10743 
   - scx
10744 
  """
559 chandransh 10745 
 
10746 
  thrift_spec = (
575 chandransh 10747 
    None, # 0
10748 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10749 
  )
10750 
 
575 chandransh 10751 
  def __init__(self, scx=None,):
10752 
    self.scx = scx
10753 
 
559 chandransh 10754 
  def read(self, iprot):
10755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10757 
      return
10758 
    iprot.readStructBegin()
10759 
    while True:
10760 
      (fname, ftype, fid) = iprot.readFieldBegin()
10761 
      if ftype == TType.STOP:
10762 
        break
575 chandransh 10763 
      if fid == 1:
10764 
        if ftype == TType.STRUCT:
10765 
          self.scx = ShoppingCartException()
10766 
          self.scx.read(iprot)
10767 
        else:
10768 
          iprot.skip(ftype)
559 chandransh 10769 
      else:
10770 
        iprot.skip(ftype)
10771 
      iprot.readFieldEnd()
10772 
    iprot.readStructEnd()
10773 
 
10774 
  def write(self, oprot):
10775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10777 
      return
10778 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 10779 
    if self.scx is not None:
575 chandransh 10780 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10781 
      self.scx.write(oprot)
10782 
      oprot.writeFieldEnd()
559 chandransh 10783 
    oprot.writeFieldStop()
10784 
    oprot.writeStructEnd()
10785 
 
3431 rajveer 10786 
  def validate(self):
10787 
    return
10788 
 
10789 
 
559 chandransh 10790 
  def __repr__(self):
10791 
    L = ['%s=%r' % (key, value)
10792 
      for key, value in self.__dict__.iteritems()]
10793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10794 
 
10795 
  def __eq__(self, other):
10796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10797 
 
10798 
  def __ne__(self, other):
10799 
    return not (self == other)
10800 
 
5553 rajveer 10801 
class addStoreToCart_args:
10802 
  """
10803 
  Attributes:
10804 
   - cartId
10805 
   - storeId
10806 
  """
10807 
 
10808 
  thrift_spec = (
10809 
    None, # 0
10810 
    (1, TType.I64, 'cartId', None, None, ), # 1
10811 
    (2, TType.I64, 'storeId', None, None, ), # 2
10812 
  )
10813 
 
10814 
  def __init__(self, cartId=None, storeId=None,):
10815 
    self.cartId = cartId
10816 
    self.storeId = storeId
10817 
 
10818 
  def read(self, iprot):
10819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10821 
      return
10822 
    iprot.readStructBegin()
10823 
    while True:
10824 
      (fname, ftype, fid) = iprot.readFieldBegin()
10825 
      if ftype == TType.STOP:
10826 
        break
10827 
      if fid == 1:
10828 
        if ftype == TType.I64:
10829 
          self.cartId = iprot.readI64();
10830 
        else:
10831 
          iprot.skip(ftype)
10832 
      elif fid == 2:
10833 
        if ftype == TType.I64:
10834 
          self.storeId = iprot.readI64();
10835 
        else:
10836 
          iprot.skip(ftype)
10837 
      else:
10838 
        iprot.skip(ftype)
10839 
      iprot.readFieldEnd()
10840 
    iprot.readStructEnd()
10841 
 
10842 
  def write(self, oprot):
10843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10845 
      return
10846 
    oprot.writeStructBegin('addStoreToCart_args')
10847 
    if self.cartId is not None:
10848 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10849 
      oprot.writeI64(self.cartId)
10850 
      oprot.writeFieldEnd()
10851 
    if self.storeId is not None:
10852 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
10853 
      oprot.writeI64(self.storeId)
10854 
      oprot.writeFieldEnd()
10855 
    oprot.writeFieldStop()
10856 
    oprot.writeStructEnd()
10857 
 
10858 
  def validate(self):
10859 
    return
10860 
 
10861 
 
10862 
  def __repr__(self):
10863 
    L = ['%s=%r' % (key, value)
10864 
      for key, value in self.__dict__.iteritems()]
10865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10866 
 
10867 
  def __eq__(self, other):
10868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10869 
 
10870 
  def __ne__(self, other):
10871 
    return not (self == other)
10872 
 
10873 
class addStoreToCart_result:
10874 
  """
10875 
  Attributes:
10876 
   - scx
10877 
  """
10878 
 
10879 
  thrift_spec = (
10880 
    None, # 0
10881 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10882 
  )
10883 
 
10884 
  def __init__(self, scx=None,):
10885 
    self.scx = scx
10886 
 
10887 
  def read(self, iprot):
10888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10890 
      return
10891 
    iprot.readStructBegin()
10892 
    while True:
10893 
      (fname, ftype, fid) = iprot.readFieldBegin()
10894 
      if ftype == TType.STOP:
10895 
        break
10896 
      if fid == 1:
10897 
        if ftype == TType.STRUCT:
10898 
          self.scx = ShoppingCartException()
10899 
          self.scx.read(iprot)
10900 
        else:
10901 
          iprot.skip(ftype)
10902 
      else:
10903 
        iprot.skip(ftype)
10904 
      iprot.readFieldEnd()
10905 
    iprot.readStructEnd()
10906 
 
10907 
  def write(self, oprot):
10908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10910 
      return
10911 
    oprot.writeStructBegin('addStoreToCart_result')
10912 
    if self.scx is not None:
10913 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10914 
      self.scx.write(oprot)
10915 
      oprot.writeFieldEnd()
10916 
    oprot.writeFieldStop()
10917 
    oprot.writeStructEnd()
10918 
 
10919 
  def validate(self):
10920 
    return
10921 
 
10922 
 
10923 
  def __repr__(self):
10924 
    L = ['%s=%r' % (key, value)
10925 
      for key, value in self.__dict__.iteritems()]
10926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10927 
 
10928 
  def __eq__(self, other):
10929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10930 
 
10931 
  def __ne__(self, other):
10932 
    return not (self == other)
10933 
 
1976 varun.gupt 10934 
class applyCouponToCart_args:
10935 
  """
10936 
  Attributes:
6922 anupam.sin 10937 
   - cart
1976 varun.gupt 10938 
   - couponCode
10939 
  """
10940 
 
10941 
  thrift_spec = (
10942 
    None, # 0
6922 anupam.sin 10943 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 10944 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10945 
  )
10946 
 
6922 anupam.sin 10947 
  def __init__(self, cart=None, couponCode=None,):
10948 
    self.cart = cart
1976 varun.gupt 10949 
    self.couponCode = couponCode
10950 
 
10951 
  def read(self, iprot):
10952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10954 
      return
10955 
    iprot.readStructBegin()
10956 
    while True:
10957 
      (fname, ftype, fid) = iprot.readFieldBegin()
10958 
      if ftype == TType.STOP:
10959 
        break
10960 
      if fid == 1:
6922 anupam.sin 10961 
        if ftype == TType.STRUCT:
10962 
          self.cart = Cart()
10963 
          self.cart.read(iprot)
1976 varun.gupt 10964 
        else:
10965 
          iprot.skip(ftype)
10966 
      elif fid == 2:
10967 
        if ftype == TType.STRING:
10968 
          self.couponCode = iprot.readString();
10969 
        else:
10970 
          iprot.skip(ftype)
10971 
      else:
10972 
        iprot.skip(ftype)
10973 
      iprot.readFieldEnd()
10974 
    iprot.readStructEnd()
10975 
 
10976 
  def write(self, oprot):
10977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10979 
      return
10980 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 10981 
    if self.cart is not None:
10982 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
10983 
      self.cart.write(oprot)
1976 varun.gupt 10984 
      oprot.writeFieldEnd()
3431 rajveer 10985 
    if self.couponCode is not None:
1976 varun.gupt 10986 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10987 
      oprot.writeString(self.couponCode)
10988 
      oprot.writeFieldEnd()
10989 
    oprot.writeFieldStop()
10990 
    oprot.writeStructEnd()
10991 
 
3431 rajveer 10992 
  def validate(self):
10993 
    return
10994 
 
10995 
 
1976 varun.gupt 10996 
  def __repr__(self):
10997 
    L = ['%s=%r' % (key, value)
10998 
      for key, value in self.__dict__.iteritems()]
10999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11000 
 
11001 
  def __eq__(self, other):
11002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11003 
 
11004 
  def __ne__(self, other):
11005 
    return not (self == other)
11006 
 
11007 
class applyCouponToCart_result:
11008 
  """
11009 
  Attributes:
11010 
   - scx
11011 
  """
11012 
 
11013 
  thrift_spec = (
11014 
    None, # 0
11015 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11016 
  )
11017 
 
11018 
  def __init__(self, scx=None,):
11019 
    self.scx = scx
11020 
 
11021 
  def read(self, iprot):
11022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11024 
      return
11025 
    iprot.readStructBegin()
11026 
    while True:
11027 
      (fname, ftype, fid) = iprot.readFieldBegin()
11028 
      if ftype == TType.STOP:
11029 
        break
11030 
      if fid == 1:
11031 
        if ftype == TType.STRUCT:
11032 
          self.scx = ShoppingCartException()
11033 
          self.scx.read(iprot)
11034 
        else:
11035 
          iprot.skip(ftype)
11036 
      else:
11037 
        iprot.skip(ftype)
11038 
      iprot.readFieldEnd()
11039 
    iprot.readStructEnd()
11040 
 
11041 
  def write(self, oprot):
11042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11044 
      return
11045 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11046 
    if self.scx is not None:
1976 varun.gupt 11047 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11048 
      self.scx.write(oprot)
11049 
      oprot.writeFieldEnd()
11050 
    oprot.writeFieldStop()
11051 
    oprot.writeStructEnd()
11052 
 
3431 rajveer 11053 
  def validate(self):
11054 
    return
11055 
 
11056 
 
1976 varun.gupt 11057 
  def __repr__(self):
11058 
    L = ['%s=%r' % (key, value)
11059 
      for key, value in self.__dict__.iteritems()]
11060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11061 
 
11062 
  def __eq__(self, other):
11063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11064 
 
11065 
  def __ne__(self, other):
11066 
    return not (self == other)
11067 
 
11068 
class removeCoupon_args:
11069 
  """
11070 
  Attributes:
11071 
   - cartId
11072 
  """
11073 
 
11074 
  thrift_spec = (
11075 
    None, # 0
11076 
    (1, TType.I64, 'cartId', None, None, ), # 1
11077 
  )
11078 
 
11079 
  def __init__(self, cartId=None,):
11080 
    self.cartId = cartId
11081 
 
11082 
  def read(self, iprot):
11083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11085 
      return
11086 
    iprot.readStructBegin()
11087 
    while True:
11088 
      (fname, ftype, fid) = iprot.readFieldBegin()
11089 
      if ftype == TType.STOP:
11090 
        break
11091 
      if fid == 1:
11092 
        if ftype == TType.I64:
11093 
          self.cartId = iprot.readI64();
11094 
        else:
11095 
          iprot.skip(ftype)
11096 
      else:
11097 
        iprot.skip(ftype)
11098 
      iprot.readFieldEnd()
11099 
    iprot.readStructEnd()
11100 
 
11101 
  def write(self, oprot):
11102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11104 
      return
11105 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11106 
    if self.cartId is not None:
1976 varun.gupt 11107 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11108 
      oprot.writeI64(self.cartId)
11109 
      oprot.writeFieldEnd()
11110 
    oprot.writeFieldStop()
11111 
    oprot.writeStructEnd()
11112 
 
3431 rajveer 11113 
  def validate(self):
11114 
    return
11115 
 
11116 
 
1976 varun.gupt 11117 
  def __repr__(self):
11118 
    L = ['%s=%r' % (key, value)
11119 
      for key, value in self.__dict__.iteritems()]
11120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11121 
 
11122 
  def __eq__(self, other):
11123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11124 
 
11125 
  def __ne__(self, other):
11126 
    return not (self == other)
11127 
 
11128 
class removeCoupon_result:
11129 
  """
11130 
  Attributes:
11131 
   - scx
11132 
  """
11133 
 
11134 
  thrift_spec = (
11135 
    None, # 0
11136 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11137 
  )
11138 
 
11139 
  def __init__(self, scx=None,):
11140 
    self.scx = scx
11141 
 
11142 
  def read(self, iprot):
11143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11145 
      return
11146 
    iprot.readStructBegin()
11147 
    while True:
11148 
      (fname, ftype, fid) = iprot.readFieldBegin()
11149 
      if ftype == TType.STOP:
11150 
        break
11151 
      if fid == 1:
11152 
        if ftype == TType.STRUCT:
11153 
          self.scx = ShoppingCartException()
11154 
          self.scx.read(iprot)
11155 
        else:
11156 
          iprot.skip(ftype)
11157 
      else:
11158 
        iprot.skip(ftype)
11159 
      iprot.readFieldEnd()
11160 
    iprot.readStructEnd()
11161 
 
11162 
  def write(self, oprot):
11163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11165 
      return
11166 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11167 
    if self.scx is not None:
1976 varun.gupt 11168 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11169 
      self.scx.write(oprot)
11170 
      oprot.writeFieldEnd()
11171 
    oprot.writeFieldStop()
11172 
    oprot.writeStructEnd()
11173 
 
3431 rajveer 11174 
  def validate(self):
11175 
    return
11176 
 
11177 
 
1976 varun.gupt 11178 
  def __repr__(self):
11179 
    L = ['%s=%r' % (key, value)
11180 
      for key, value in self.__dict__.iteritems()]
11181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11182 
 
11183 
  def __eq__(self, other):
11184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11185 
 
11186 
  def __ne__(self, other):
11187 
    return not (self == other)
11188 
 
3554 varun.gupt 11189 
class deleteDiscountsFromCart_args:
11190 
  """
11191 
  Attributes:
11192 
   - cartId
11193 
  """
11194 
 
11195 
  thrift_spec = (
11196 
    None, # 0
11197 
    (1, TType.I64, 'cartId', None, None, ), # 1
11198 
  )
11199 
 
11200 
  def __init__(self, cartId=None,):
11201 
    self.cartId = cartId
11202 
 
11203 
  def read(self, iprot):
11204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11206 
      return
11207 
    iprot.readStructBegin()
11208 
    while True:
11209 
      (fname, ftype, fid) = iprot.readFieldBegin()
11210 
      if ftype == TType.STOP:
11211 
        break
11212 
      if fid == 1:
11213 
        if ftype == TType.I64:
11214 
          self.cartId = iprot.readI64();
11215 
        else:
11216 
          iprot.skip(ftype)
11217 
      else:
11218 
        iprot.skip(ftype)
11219 
      iprot.readFieldEnd()
11220 
    iprot.readStructEnd()
11221 
 
11222 
  def write(self, oprot):
11223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11225 
      return
11226 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11227 
    if self.cartId is not None:
11228 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11229 
      oprot.writeI64(self.cartId)
11230 
      oprot.writeFieldEnd()
11231 
    oprot.writeFieldStop()
11232 
    oprot.writeStructEnd()
11233 
 
11234 
  def validate(self):
11235 
    return
11236 
 
11237 
 
11238 
  def __repr__(self):
11239 
    L = ['%s=%r' % (key, value)
11240 
      for key, value in self.__dict__.iteritems()]
11241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11242 
 
11243 
  def __eq__(self, other):
11244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11245 
 
11246 
  def __ne__(self, other):
11247 
    return not (self == other)
11248 
 
11249 
class deleteDiscountsFromCart_result:
11250 
  """
11251 
  Attributes:
11252 
   - scx
11253 
  """
11254 
 
11255 
  thrift_spec = (
11256 
    None, # 0
11257 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11258 
  )
11259 
 
11260 
  def __init__(self, scx=None,):
11261 
    self.scx = scx
11262 
 
11263 
  def read(self, iprot):
11264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11266 
      return
11267 
    iprot.readStructBegin()
11268 
    while True:
11269 
      (fname, ftype, fid) = iprot.readFieldBegin()
11270 
      if ftype == TType.STOP:
11271 
        break
11272 
      if fid == 1:
11273 
        if ftype == TType.STRUCT:
11274 
          self.scx = ShoppingCartException()
11275 
          self.scx.read(iprot)
11276 
        else:
11277 
          iprot.skip(ftype)
11278 
      else:
11279 
        iprot.skip(ftype)
11280 
      iprot.readFieldEnd()
11281 
    iprot.readStructEnd()
11282 
 
11283 
  def write(self, oprot):
11284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11286 
      return
11287 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11288 
    if self.scx is not None:
11289 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11290 
      self.scx.write(oprot)
11291 
      oprot.writeFieldEnd()
11292 
    oprot.writeFieldStop()
11293 
    oprot.writeStructEnd()
11294 
 
11295 
  def validate(self):
11296 
    return
11297 
 
11298 
 
11299 
  def __repr__(self):
11300 
    L = ['%s=%r' % (key, value)
11301 
      for key, value in self.__dict__.iteritems()]
11302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11303 
 
11304 
  def __eq__(self, other):
11305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11306 
 
11307 
  def __ne__(self, other):
11308 
    return not (self == other)
11309 
 
11310 
class saveDiscounts_args:
11311 
  """
11312 
  Attributes:
11313 
   - discounts
11314 
  """
11315 
 
11316 
  thrift_spec = (
11317 
    None, # 0
11318 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11319 
  )
11320 
 
11321 
  def __init__(self, discounts=None,):
11322 
    self.discounts = discounts
11323 
 
11324 
  def read(self, iprot):
11325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11327 
      return
11328 
    iprot.readStructBegin()
11329 
    while True:
11330 
      (fname, ftype, fid) = iprot.readFieldBegin()
11331 
      if ftype == TType.STOP:
11332 
        break
11333 
      if fid == 1:
11334 
        if ftype == TType.LIST:
11335 
          self.discounts = []
11592 amit.gupta 11336 
          (_etype163, _size160) = iprot.readListBegin()
11337 
          for _i164 in xrange(_size160):
11338 
            _elem165 = Discount()
11339 
            _elem165.read(iprot)
11340 
            self.discounts.append(_elem165)
3554 varun.gupt 11341 
          iprot.readListEnd()
11342 
        else:
11343 
          iprot.skip(ftype)
11344 
      else:
11345 
        iprot.skip(ftype)
11346 
      iprot.readFieldEnd()
11347 
    iprot.readStructEnd()
11348 
 
11349 
  def write(self, oprot):
11350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11352 
      return
11353 
    oprot.writeStructBegin('saveDiscounts_args')
11354 
    if self.discounts is not None:
11355 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11356 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11357 
      for iter166 in self.discounts:
11358 
        iter166.write(oprot)
3554 varun.gupt 11359 
      oprot.writeListEnd()
11360 
      oprot.writeFieldEnd()
11361 
    oprot.writeFieldStop()
11362 
    oprot.writeStructEnd()
11363 
 
11364 
  def validate(self):
11365 
    return
11366 
 
11367 
 
11368 
  def __repr__(self):
11369 
    L = ['%s=%r' % (key, value)
11370 
      for key, value in self.__dict__.iteritems()]
11371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11372 
 
11373 
  def __eq__(self, other):
11374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11375 
 
11376 
  def __ne__(self, other):
11377 
    return not (self == other)
11378 
 
11379 
class saveDiscounts_result:
11380 
  """
11381 
  Attributes:
11382 
   - scx
11383 
  """
11384 
 
11385 
  thrift_spec = (
11386 
    None, # 0
11387 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11388 
  )
11389 
 
11390 
  def __init__(self, scx=None,):
11391 
    self.scx = scx
11392 
 
11393 
  def read(self, iprot):
11394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11396 
      return
11397 
    iprot.readStructBegin()
11398 
    while True:
11399 
      (fname, ftype, fid) = iprot.readFieldBegin()
11400 
      if ftype == TType.STOP:
11401 
        break
11402 
      if fid == 1:
11403 
        if ftype == TType.STRUCT:
11404 
          self.scx = ShoppingCartException()
11405 
          self.scx.read(iprot)
11406 
        else:
11407 
          iprot.skip(ftype)
11408 
      else:
11409 
        iprot.skip(ftype)
11410 
      iprot.readFieldEnd()
11411 
    iprot.readStructEnd()
11412 
 
11413 
  def write(self, oprot):
11414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11416 
      return
11417 
    oprot.writeStructBegin('saveDiscounts_result')
11418 
    if self.scx is not None:
11419 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11420 
      self.scx.write(oprot)
11421 
      oprot.writeFieldEnd()
11422 
    oprot.writeFieldStop()
11423 
    oprot.writeStructEnd()
11424 
 
11425 
  def validate(self):
11426 
    return
11427 
 
11428 
 
11429 
  def __repr__(self):
11430 
    L = ['%s=%r' % (key, value)
11431 
      for key, value in self.__dict__.iteritems()]
11432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11433 
 
11434 
  def __eq__(self, other):
11435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11436 
 
11437 
  def __ne__(self, other):
11438 
    return not (self == other)
11439 
 
690 chandransh 11440 
class createOrders_args:
559 chandransh 11441 
  """
11442 
  Attributes:
11443 
   - cartId
2815 vikas 11444 
   - sessionSource
11445 
   - sessionStartTime
3858 vikas 11446 
   - firstSource
11447 
   - firstSourceTime
5326 rajveer 11448 
   - userId
6389 rajveer 11449 
   - schemeId
11526 amit.gupta 11450 
   - orderSource
559 chandransh 11451 
  """
11452 
 
11453 
  thrift_spec = (
11454 
    None, # 0
11455 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11456 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11457 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11458 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11459 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11460 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11461 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11462 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11463 
  )
11464 
 
11526 amit.gupta 11465 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11466 
    self.cartId = cartId
2815 vikas 11467 
    self.sessionSource = sessionSource
11468 
    self.sessionStartTime = sessionStartTime
3858 vikas 11469 
    self.firstSource = firstSource
11470 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11471 
    self.userId = userId
6389 rajveer 11472 
    self.schemeId = schemeId
11526 amit.gupta 11473 
    self.orderSource = orderSource
559 chandransh 11474 
 
11475 
  def read(self, iprot):
11476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11478 
      return
11479 
    iprot.readStructBegin()
11480 
    while True:
11481 
      (fname, ftype, fid) = iprot.readFieldBegin()
11482 
      if ftype == TType.STOP:
11483 
        break
11484 
      if fid == 1:
11485 
        if ftype == TType.I64:
11486 
          self.cartId = iprot.readI64();
11487 
        else:
11488 
          iprot.skip(ftype)
2815 vikas 11489 
      elif fid == 2:
11490 
        if ftype == TType.STRING:
11491 
          self.sessionSource = iprot.readString();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      elif fid == 3:
11495 
        if ftype == TType.I64:
11496 
          self.sessionStartTime = iprot.readI64();
11497 
        else:
11498 
          iprot.skip(ftype)
3858 vikas 11499 
      elif fid == 4:
11500 
        if ftype == TType.STRING:
11501 
          self.firstSource = iprot.readString();
11502 
        else:
11503 
          iprot.skip(ftype)
11504 
      elif fid == 5:
11505 
        if ftype == TType.I64:
11506 
          self.firstSourceTime = iprot.readI64();
11507 
        else:
11508 
          iprot.skip(ftype)
5326 rajveer 11509 
      elif fid == 6:
11510 
        if ftype == TType.I64:
11511 
          self.userId = iprot.readI64();
11512 
        else:
11513 
          iprot.skip(ftype)
6389 rajveer 11514 
      elif fid == 7:
11515 
        if ftype == TType.I64:
11516 
          self.schemeId = iprot.readI64();
11517 
        else:
11518 
          iprot.skip(ftype)
11526 amit.gupta 11519 
      elif fid == 8:
11520 
        if ftype == TType.I64:
11521 
          self.orderSource = iprot.readI64();
11522 
        else:
11523 
          iprot.skip(ftype)
559 chandransh 11524 
      else:
11525 
        iprot.skip(ftype)
11526 
      iprot.readFieldEnd()
11527 
    iprot.readStructEnd()
11528 
 
11529 
  def write(self, oprot):
11530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11532 
      return
690 chandransh 11533 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11534 
    if self.cartId is not None:
559 chandransh 11535 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11536 
      oprot.writeI64(self.cartId)
11537 
      oprot.writeFieldEnd()
3431 rajveer 11538 
    if self.sessionSource is not None:
2815 vikas 11539 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11540 
      oprot.writeString(self.sessionSource)
11541 
      oprot.writeFieldEnd()
3431 rajveer 11542 
    if self.sessionStartTime is not None:
2815 vikas 11543 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11544 
      oprot.writeI64(self.sessionStartTime)
11545 
      oprot.writeFieldEnd()
3858 vikas 11546 
    if self.firstSource is not None:
11547 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11548 
      oprot.writeString(self.firstSource)
11549 
      oprot.writeFieldEnd()
11550 
    if self.firstSourceTime is not None:
11551 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11552 
      oprot.writeI64(self.firstSourceTime)
11553 
      oprot.writeFieldEnd()
5326 rajveer 11554 
    if self.userId is not None:
11555 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11556 
      oprot.writeI64(self.userId)
11557 
      oprot.writeFieldEnd()
6389 rajveer 11558 
    if self.schemeId is not None:
11559 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11560 
      oprot.writeI64(self.schemeId)
11561 
      oprot.writeFieldEnd()
11526 amit.gupta 11562 
    if self.orderSource is not None:
11563 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
11564 
      oprot.writeI64(self.orderSource)
11565 
      oprot.writeFieldEnd()
559 chandransh 11566 
    oprot.writeFieldStop()
11567 
    oprot.writeStructEnd()
11568 
 
3431 rajveer 11569 
  def validate(self):
11570 
    return
11571 
 
11572 
 
559 chandransh 11573 
  def __repr__(self):
11574 
    L = ['%s=%r' % (key, value)
11575 
      for key, value in self.__dict__.iteritems()]
11576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11577 
 
11578 
  def __eq__(self, other):
11579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11580 
 
11581 
  def __ne__(self, other):
11582 
    return not (self == other)
11583 
 
690 chandransh 11584 
class createOrders_result:
559 chandransh 11585 
  """
11586 
  Attributes:
94 ashish 11587 
   - success
559 chandransh 11588 
   - scx
94 ashish 11589 
  """
11590 
 
11591 
  thrift_spec = (
575 chandransh 11592 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11593 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11594 
  )
11595 
 
559 chandransh 11596 
  def __init__(self, success=None, scx=None,):
94 ashish 11597 
    self.success = success
559 chandransh 11598 
    self.scx = scx
94 ashish 11599 
 
11600 
  def read(self, iprot):
11601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11603 
      return
11604 
    iprot.readStructBegin()
11605 
    while True:
11606 
      (fname, ftype, fid) = iprot.readFieldBegin()
11607 
      if ftype == TType.STOP:
11608 
        break
11609 
      if fid == 0:
575 chandransh 11610 
        if ftype == TType.I64:
11611 
          self.success = iprot.readI64();
94 ashish 11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      elif fid == 1:
11615 
        if ftype == TType.STRUCT:
559 chandransh 11616 
          self.scx = ShoppingCartException()
11617 
          self.scx.read(iprot)
94 ashish 11618 
        else:
11619 
          iprot.skip(ftype)
11620 
      else:
11621 
        iprot.skip(ftype)
11622 
      iprot.readFieldEnd()
11623 
    iprot.readStructEnd()
11624 
 
11625 
  def write(self, oprot):
11626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11628 
      return
690 chandransh 11629 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11630 
    if self.success is not None:
575 chandransh 11631 
      oprot.writeFieldBegin('success', TType.I64, 0)
11632 
      oprot.writeI64(self.success)
94 ashish 11633 
      oprot.writeFieldEnd()
3431 rajveer 11634 
    if self.scx is not None:
559 chandransh 11635 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11636 
      self.scx.write(oprot)
94 ashish 11637 
      oprot.writeFieldEnd()
11638 
    oprot.writeFieldStop()
11639 
    oprot.writeStructEnd()
11640 
 
3431 rajveer 11641 
  def validate(self):
11642 
    return
11643 
 
11644 
 
94 ashish 11645 
  def __repr__(self):
11646 
    L = ['%s=%r' % (key, value)
11647 
      for key, value in self.__dict__.iteritems()]
11648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11649 
 
11650 
  def __eq__(self, other):
11651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11652 
 
11653 
  def __ne__(self, other):
11654 
    return not (self == other)
11655 
 
559 chandransh 11656 
class validateCart_args:
94 ashish 11657 
  """
11658 
  Attributes:
559 chandransh 11659 
   - cartId
3557 rajveer 11660 
   - sourceId
94 ashish 11661 
  """
11662 
 
11663 
  thrift_spec = (
11664 
    None, # 0
559 chandransh 11665 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11666 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11667 
  )
11668 
 
3557 rajveer 11669 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11670 
    self.cartId = cartId
3557 rajveer 11671 
    self.sourceId = sourceId
94 ashish 11672 
 
11673 
  def read(self, iprot):
11674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11676 
      return
11677 
    iprot.readStructBegin()
11678 
    while True:
11679 
      (fname, ftype, fid) = iprot.readFieldBegin()
11680 
      if ftype == TType.STOP:
11681 
        break
11682 
      if fid == 1:
11683 
        if ftype == TType.I64:
559 chandransh 11684 
          self.cartId = iprot.readI64();
94 ashish 11685 
        else:
11686 
          iprot.skip(ftype)
3557 rajveer 11687 
      elif fid == 2:
11688 
        if ftype == TType.I64:
11689 
          self.sourceId = iprot.readI64();
11690 
        else:
11691 
          iprot.skip(ftype)
94 ashish 11692 
      else:
11693 
        iprot.skip(ftype)
11694 
      iprot.readFieldEnd()
11695 
    iprot.readStructEnd()
11696 
 
11697 
  def write(self, oprot):
11698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11700 
      return
559 chandransh 11701 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 11702 
    if self.cartId is not None:
559 chandransh 11703 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11704 
      oprot.writeI64(self.cartId)
94 ashish 11705 
      oprot.writeFieldEnd()
3557 rajveer 11706 
    if self.sourceId is not None:
11707 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11708 
      oprot.writeI64(self.sourceId)
11709 
      oprot.writeFieldEnd()
94 ashish 11710 
    oprot.writeFieldStop()
11711 
    oprot.writeStructEnd()
11712 
 
3431 rajveer 11713 
  def validate(self):
11714 
    return
11715 
 
11716 
 
94 ashish 11717 
  def __repr__(self):
11718 
    L = ['%s=%r' % (key, value)
11719 
      for key, value in self.__dict__.iteritems()]
11720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11721 
 
11722 
  def __eq__(self, other):
11723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11724 
 
11725 
  def __ne__(self, other):
11726 
    return not (self == other)
11727 
 
559 chandransh 11728 
class validateCart_result:
94 ashish 11729 
  """
11730 
  Attributes:
11731 
   - success
575 chandransh 11732 
   - scex
94 ashish 11733 
  """
11734 
 
11735 
  thrift_spec = (
6736 amit.gupta 11736 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 11737 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11738 
  )
11739 
 
575 chandransh 11740 
  def __init__(self, success=None, scex=None,):
94 ashish 11741 
    self.success = success
575 chandransh 11742 
    self.scex = scex
94 ashish 11743 
 
11744 
  def read(self, iprot):
11745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11747 
      return
11748 
    iprot.readStructBegin()
11749 
    while True:
11750 
      (fname, ftype, fid) = iprot.readFieldBegin()
11751 
      if ftype == TType.STOP:
11752 
        break
11753 
      if fid == 0:
6736 amit.gupta 11754 
        if ftype == TType.LIST:
11755 
          self.success = []
11592 amit.gupta 11756 
          (_etype170, _size167) = iprot.readListBegin()
11757 
          for _i171 in xrange(_size167):
11758 
            _elem172 = iprot.readString();
11759 
            self.success.append(_elem172)
6736 amit.gupta 11760 
          iprot.readListEnd()
94 ashish 11761 
        else:
11762 
          iprot.skip(ftype)
575 chandransh 11763 
      elif fid == 1:
11764 
        if ftype == TType.STRUCT:
11765 
          self.scex = ShoppingCartException()
11766 
          self.scex.read(iprot)
11767 
        else:
11768 
          iprot.skip(ftype)
94 ashish 11769 
      else:
11770 
        iprot.skip(ftype)
11771 
      iprot.readFieldEnd()
11772 
    iprot.readStructEnd()
11773 
 
11774 
  def write(self, oprot):
11775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11777 
      return
559 chandransh 11778 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 11779 
    if self.success is not None:
6736 amit.gupta 11780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11781 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 11782 
      for iter173 in self.success:
11783 
        oprot.writeString(iter173)
6736 amit.gupta 11784 
      oprot.writeListEnd()
94 ashish 11785 
      oprot.writeFieldEnd()
3431 rajveer 11786 
    if self.scex is not None:
575 chandransh 11787 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11788 
      self.scex.write(oprot)
11789 
      oprot.writeFieldEnd()
559 chandransh 11790 
    oprot.writeFieldStop()
11791 
    oprot.writeStructEnd()
11792 
 
3431 rajveer 11793 
  def validate(self):
11794 
    return
11795 
 
11796 
 
559 chandransh 11797 
  def __repr__(self):
11798 
    L = ['%s=%r' % (key, value)
11799 
      for key, value in self.__dict__.iteritems()]
11800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11801 
 
11802 
  def __eq__(self, other):
11803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11804 
 
11805 
  def __ne__(self, other):
11806 
    return not (self == other)
11807 
 
690 chandransh 11808 
class mergeCart_args:
575 chandransh 11809 
  """
11810 
  Attributes:
690 chandransh 11811 
   - fromCartId
11812 
   - toCartId
11813 
  """
11814 
 
11815 
  thrift_spec = (
11816 
    None, # 0
11817 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11818 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11819 
  )
11820 
 
11821 
  def __init__(self, fromCartId=None, toCartId=None,):
11822 
    self.fromCartId = fromCartId
11823 
    self.toCartId = toCartId
11824 
 
11825 
  def read(self, iprot):
11826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11828 
      return
11829 
    iprot.readStructBegin()
11830 
    while True:
11831 
      (fname, ftype, fid) = iprot.readFieldBegin()
11832 
      if ftype == TType.STOP:
11833 
        break
11834 
      if fid == 1:
11835 
        if ftype == TType.I64:
11836 
          self.fromCartId = iprot.readI64();
11837 
        else:
11838 
          iprot.skip(ftype)
11839 
      elif fid == 2:
11840 
        if ftype == TType.I64:
11841 
          self.toCartId = iprot.readI64();
11842 
        else:
11843 
          iprot.skip(ftype)
11844 
      else:
11845 
        iprot.skip(ftype)
11846 
      iprot.readFieldEnd()
11847 
    iprot.readStructEnd()
11848 
 
11849 
  def write(self, oprot):
11850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11852 
      return
11853 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 11854 
    if self.fromCartId is not None:
690 chandransh 11855 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11856 
      oprot.writeI64(self.fromCartId)
11857 
      oprot.writeFieldEnd()
3431 rajveer 11858 
    if self.toCartId is not None:
690 chandransh 11859 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11860 
      oprot.writeI64(self.toCartId)
11861 
      oprot.writeFieldEnd()
11862 
    oprot.writeFieldStop()
11863 
    oprot.writeStructEnd()
11864 
 
3431 rajveer 11865 
  def validate(self):
11866 
    return
11867 
 
11868 
 
690 chandransh 11869 
  def __repr__(self):
11870 
    L = ['%s=%r' % (key, value)
11871 
      for key, value in self.__dict__.iteritems()]
11872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11873 
 
11874 
  def __eq__(self, other):
11875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11876 
 
11877 
  def __ne__(self, other):
11878 
    return not (self == other)
11879 
 
11880 
class mergeCart_result:
11881 
 
11882 
  thrift_spec = (
11883 
  )
11884 
 
11885 
  def read(self, iprot):
11886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11888 
      return
11889 
    iprot.readStructBegin()
11890 
    while True:
11891 
      (fname, ftype, fid) = iprot.readFieldBegin()
11892 
      if ftype == TType.STOP:
11893 
        break
11894 
      else:
11895 
        iprot.skip(ftype)
11896 
      iprot.readFieldEnd()
11897 
    iprot.readStructEnd()
11898 
 
11899 
  def write(self, oprot):
11900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11902 
      return
11903 
    oprot.writeStructBegin('mergeCart_result')
11904 
    oprot.writeFieldStop()
11905 
    oprot.writeStructEnd()
11906 
 
3431 rajveer 11907 
  def validate(self):
11908 
    return
11909 
 
11910 
 
690 chandransh 11911 
  def __repr__(self):
11912 
    L = ['%s=%r' % (key, value)
11913 
      for key, value in self.__dict__.iteritems()]
11914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11915 
 
11916 
  def __eq__(self, other):
11917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11918 
 
11919 
  def __ne__(self, other):
11920 
    return not (self == other)
11921 
 
11922 
class checkOut_args:
11923 
  """
11924 
  Attributes:
575 chandransh 11925 
   - cartId
11926 
  """
11927 
 
11928 
  thrift_spec = (
11929 
    None, # 0
11930 
    (1, TType.I64, 'cartId', None, None, ), # 1
11931 
  )
11932 
 
11933 
  def __init__(self, cartId=None,):
11934 
    self.cartId = cartId
11935 
 
11936 
  def read(self, iprot):
11937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11939 
      return
11940 
    iprot.readStructBegin()
11941 
    while True:
11942 
      (fname, ftype, fid) = iprot.readFieldBegin()
11943 
      if ftype == TType.STOP:
11944 
        break
11945 
      if fid == 1:
11946 
        if ftype == TType.I64:
11947 
          self.cartId = iprot.readI64();
11948 
        else:
11949 
          iprot.skip(ftype)
11950 
      else:
11951 
        iprot.skip(ftype)
11952 
      iprot.readFieldEnd()
11953 
    iprot.readStructEnd()
11954 
 
11955 
  def write(self, oprot):
11956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11958 
      return
690 chandransh 11959 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 11960 
    if self.cartId is not None:
575 chandransh 11961 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11962 
      oprot.writeI64(self.cartId)
11963 
      oprot.writeFieldEnd()
11964 
    oprot.writeFieldStop()
11965 
    oprot.writeStructEnd()
11966 
 
3431 rajveer 11967 
  def validate(self):
11968 
    return
11969 
 
11970 
 
575 chandransh 11971 
  def __repr__(self):
11972 
    L = ['%s=%r' % (key, value)
11973 
      for key, value in self.__dict__.iteritems()]
11974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11975 
 
11976 
  def __eq__(self, other):
11977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11978 
 
11979 
  def __ne__(self, other):
11980 
    return not (self == other)
11981 
 
690 chandransh 11982 
class checkOut_result:
575 chandransh 11983 
  """
11984 
  Attributes:
11985 
   - success
11986 
   - scex
11987 
  """
11988 
 
11989 
  thrift_spec = (
11990 
    (0, TType.BOOL, 'success', None, None, ), # 0
11991 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11992 
  )
11993 
 
11994 
  def __init__(self, success=None, scex=None,):
11995 
    self.success = success
11996 
    self.scex = scex
11997 
 
11998 
  def read(self, iprot):
11999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12001 
      return
12002 
    iprot.readStructBegin()
12003 
    while True:
12004 
      (fname, ftype, fid) = iprot.readFieldBegin()
12005 
      if ftype == TType.STOP:
12006 
        break
12007 
      if fid == 0:
12008 
        if ftype == TType.BOOL:
12009 
          self.success = iprot.readBool();
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      elif fid == 1:
12013 
        if ftype == TType.STRUCT:
12014 
          self.scex = ShoppingCartException()
12015 
          self.scex.read(iprot)
12016 
        else:
12017 
          iprot.skip(ftype)
12018 
      else:
12019 
        iprot.skip(ftype)
12020 
      iprot.readFieldEnd()
12021 
    iprot.readStructEnd()
12022 
 
12023 
  def write(self, oprot):
12024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12026 
      return
690 chandransh 12027 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12028 
    if self.success is not None:
575 chandransh 12029 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12030 
      oprot.writeBool(self.success)
12031 
      oprot.writeFieldEnd()
3431 rajveer 12032 
    if self.scex is not None:
575 chandransh 12033 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12034 
      self.scex.write(oprot)
12035 
      oprot.writeFieldEnd()
12036 
    oprot.writeFieldStop()
12037 
    oprot.writeStructEnd()
12038 
 
3431 rajveer 12039 
  def validate(self):
12040 
    return
12041 
 
12042 
 
575 chandransh 12043 
  def __repr__(self):
12044 
    L = ['%s=%r' % (key, value)
12045 
      for key, value in self.__dict__.iteritems()]
12046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12047 
 
12048 
  def __eq__(self, other):
12049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12050 
 
12051 
  def __ne__(self, other):
12052 
    return not (self == other)
12053 
 
690 chandransh 12054 
class resetCart_args:
559 chandransh 12055 
  """
12056 
  Attributes:
690 chandransh 12057 
   - cartId
12058 
   - items
559 chandransh 12059 
  """
12060 
 
12061 
  thrift_spec = (
12062 
    None, # 0
690 chandransh 12063 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12064 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12065 
  )
12066 
 
690 chandransh 12067 
  def __init__(self, cartId=None, items=None,):
12068 
    self.cartId = cartId
12069 
    self.items = items
559 chandransh 12070 
 
12071 
  def read(self, iprot):
12072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12074 
      return
12075 
    iprot.readStructBegin()
12076 
    while True:
12077 
      (fname, ftype, fid) = iprot.readFieldBegin()
12078 
      if ftype == TType.STOP:
12079 
        break
12080 
      if fid == 1:
12081 
        if ftype == TType.I64:
690 chandransh 12082 
          self.cartId = iprot.readI64();
559 chandransh 12083 
        else:
12084 
          iprot.skip(ftype)
12085 
      elif fid == 2:
690 chandransh 12086 
        if ftype == TType.MAP:
12087 
          self.items = {}
11592 amit.gupta 12088 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
12089 
          for _i178 in xrange(_size174):
12090 
            _key179 = iprot.readI64();
12091 
            _val180 = iprot.readDouble();
12092 
            self.items[_key179] = _val180
690 chandransh 12093 
          iprot.readMapEnd()
559 chandransh 12094 
        else:
12095 
          iprot.skip(ftype)
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
690 chandransh 12105 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12106 
    if self.cartId is not None:
690 chandransh 12107 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12108 
      oprot.writeI64(self.cartId)
94 ashish 12109 
      oprot.writeFieldEnd()
3431 rajveer 12110 
    if self.items is not None:
690 chandransh 12111 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12112 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11592 amit.gupta 12113 
      for kiter181,viter182 in self.items.items():
12114 
        oprot.writeI64(kiter181)
12115 
        oprot.writeDouble(viter182)
690 chandransh 12116 
      oprot.writeMapEnd()
559 chandransh 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 
 
690 chandransh 12136 
class resetCart_result:
12137 
  """
12138 
  Attributes:
12139 
   - success
12140 
   - scex
12141 
  """
559 chandransh 12142 
 
12143 
  thrift_spec = (
690 chandransh 12144 
    (0, TType.BOOL, 'success', None, None, ), # 0
12145 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12146 
  )
12147 
 
690 chandransh 12148 
  def __init__(self, success=None, scex=None,):
12149 
    self.success = success
12150 
    self.scex = scex
12151 
 
559 chandransh 12152 
  def read(self, iprot):
12153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12155 
      return
12156 
    iprot.readStructBegin()
12157 
    while True:
12158 
      (fname, ftype, fid) = iprot.readFieldBegin()
12159 
      if ftype == TType.STOP:
12160 
        break
690 chandransh 12161 
      if fid == 0:
12162 
        if ftype == TType.BOOL:
12163 
          self.success = iprot.readBool();
12164 
        else:
12165 
          iprot.skip(ftype)
12166 
      elif fid == 1:
12167 
        if ftype == TType.STRUCT:
12168 
          self.scex = ShoppingCartException()
12169 
          self.scex.read(iprot)
12170 
        else:
12171 
          iprot.skip(ftype)
559 chandransh 12172 
      else:
12173 
        iprot.skip(ftype)
12174 
      iprot.readFieldEnd()
12175 
    iprot.readStructEnd()
12176 
 
12177 
  def write(self, oprot):
12178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12180 
      return
690 chandransh 12181 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12182 
    if self.success is not None:
690 chandransh 12183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12184 
      oprot.writeBool(self.success)
12185 
      oprot.writeFieldEnd()
3431 rajveer 12186 
    if self.scex is not None:
690 chandransh 12187 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12188 
      self.scex.write(oprot)
12189 
      oprot.writeFieldEnd()
559 chandransh 12190 
    oprot.writeFieldStop()
12191 
    oprot.writeStructEnd()
12192 
 
3431 rajveer 12193 
  def validate(self):
12194 
    return
12195 
 
12196 
 
559 chandransh 12197 
  def __repr__(self):
12198 
    L = ['%s=%r' % (key, value)
12199 
      for key, value in self.__dict__.iteritems()]
12200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12201 
 
12202 
  def __eq__(self, other):
12203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12204 
 
12205 
  def __ne__(self, other):
12206 
    return not (self == other)
12207 
 
2981 rajveer 12208 
class getUserCount_args:
94 ashish 12209 
  """
12210 
  Attributes:
2981 rajveer 12211 
   - userType
559 chandransh 12212 
  """
12213 
 
12214 
  thrift_spec = (
12215 
    None, # 0
2981 rajveer 12216 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12217 
  )
12218 
 
2981 rajveer 12219 
  def __init__(self, userType=None,):
12220 
    self.userType = userType
559 chandransh 12221 
 
12222 
  def read(self, iprot):
12223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12225 
      return
12226 
    iprot.readStructBegin()
12227 
    while True:
12228 
      (fname, ftype, fid) = iprot.readFieldBegin()
12229 
      if ftype == TType.STOP:
12230 
        break
12231 
      if fid == 1:
2981 rajveer 12232 
        if ftype == TType.I32:
12233 
          self.userType = iprot.readI32();
559 chandransh 12234 
        else:
12235 
          iprot.skip(ftype)
12236 
      else:
12237 
        iprot.skip(ftype)
12238 
      iprot.readFieldEnd()
12239 
    iprot.readStructEnd()
12240 
 
12241 
  def write(self, oprot):
12242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12244 
      return
2981 rajveer 12245 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12246 
    if self.userType is not None:
2981 rajveer 12247 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12248 
      oprot.writeI32(self.userType)
559 chandransh 12249 
      oprot.writeFieldEnd()
12250 
    oprot.writeFieldStop()
12251 
    oprot.writeStructEnd()
12252 
 
3431 rajveer 12253 
  def validate(self):
12254 
    return
12255 
 
12256 
 
559 chandransh 12257 
  def __repr__(self):
12258 
    L = ['%s=%r' % (key, value)
12259 
      for key, value in self.__dict__.iteritems()]
12260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12261 
 
12262 
  def __eq__(self, other):
12263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12264 
 
12265 
  def __ne__(self, other):
12266 
    return not (self == other)
12267 
 
2981 rajveer 12268 
class getUserCount_result:
94 ashish 12269 
  """
12270 
  Attributes:
12271 
   - success
12272 
  """
12273 
 
12274 
  thrift_spec = (
2981 rajveer 12275 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12276 
  )
12277 
 
2981 rajveer 12278 
  def __init__(self, success=None,):
94 ashish 12279 
    self.success = success
12280 
 
12281 
  def read(self, iprot):
12282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12284 
      return
12285 
    iprot.readStructBegin()
12286 
    while True:
12287 
      (fname, ftype, fid) = iprot.readFieldBegin()
12288 
      if ftype == TType.STOP:
12289 
        break
12290 
      if fid == 0:
2981 rajveer 12291 
        if ftype == TType.I64:
12292 
          self.success = iprot.readI64();
94 ashish 12293 
        else:
12294 
          iprot.skip(ftype)
12295 
      else:
12296 
        iprot.skip(ftype)
12297 
      iprot.readFieldEnd()
12298 
    iprot.readStructEnd()
12299 
 
12300 
  def write(self, oprot):
12301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12303 
      return
2981 rajveer 12304 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12305 
    if self.success is not None:
2981 rajveer 12306 
      oprot.writeFieldBegin('success', TType.I64, 0)
12307 
      oprot.writeI64(self.success)
94 ashish 12308 
      oprot.writeFieldEnd()
12309 
    oprot.writeFieldStop()
12310 
    oprot.writeStructEnd()
12311 
 
3431 rajveer 12312 
  def validate(self):
12313 
    return
12314 
 
12315 
 
94 ashish 12316 
  def __repr__(self):
12317 
    L = ['%s=%r' % (key, value)
12318 
      for key, value in self.__dict__.iteritems()]
12319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12320 
 
12321 
  def __eq__(self, other):
12322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12323 
 
12324 
  def __ne__(self, other):
12325 
    return not (self == other)
12326 
 
2981 rajveer 12327 
class getAllUsers_args:
94 ashish 12328 
  """
12329 
  Attributes:
2981 rajveer 12330 
   - userType
12331 
   - startDate
12332 
   - endDate
94 ashish 12333 
  """
12334 
 
12335 
  thrift_spec = (
12336 
    None, # 0
2981 rajveer 12337 
    (1, TType.I32, 'userType', None, None, ), # 1
12338 
    (2, TType.I64, 'startDate', None, None, ), # 2
12339 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12340 
  )
12341 
 
2981 rajveer 12342 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12343 
    self.userType = userType
12344 
    self.startDate = startDate
12345 
    self.endDate = endDate
94 ashish 12346 
 
12347 
  def read(self, iprot):
12348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12350 
      return
12351 
    iprot.readStructBegin()
12352 
    while True:
12353 
      (fname, ftype, fid) = iprot.readFieldBegin()
12354 
      if ftype == TType.STOP:
12355 
        break
12356 
      if fid == 1:
2981 rajveer 12357 
        if ftype == TType.I32:
12358 
          self.userType = iprot.readI32();
94 ashish 12359 
        else:
12360 
          iprot.skip(ftype)
12361 
      elif fid == 2:
559 chandransh 12362 
        if ftype == TType.I64:
2981 rajveer 12363 
          self.startDate = iprot.readI64();
94 ashish 12364 
        else:
12365 
          iprot.skip(ftype)
2981 rajveer 12366 
      elif fid == 3:
12367 
        if ftype == TType.I64:
12368 
          self.endDate = iprot.readI64();
12369 
        else:
12370 
          iprot.skip(ftype)
94 ashish 12371 
      else:
12372 
        iprot.skip(ftype)
12373 
      iprot.readFieldEnd()
12374 
    iprot.readStructEnd()
12375 
 
12376 
  def write(self, oprot):
12377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12379 
      return
2981 rajveer 12380 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12381 
    if self.userType is not None:
2981 rajveer 12382 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12383 
      oprot.writeI32(self.userType)
94 ashish 12384 
      oprot.writeFieldEnd()
3431 rajveer 12385 
    if self.startDate is not None:
2981 rajveer 12386 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12387 
      oprot.writeI64(self.startDate)
94 ashish 12388 
      oprot.writeFieldEnd()
3431 rajveer 12389 
    if self.endDate is not None:
2981 rajveer 12390 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12391 
      oprot.writeI64(self.endDate)
12392 
      oprot.writeFieldEnd()
94 ashish 12393 
    oprot.writeFieldStop()
12394 
    oprot.writeStructEnd()
12395 
 
3431 rajveer 12396 
  def validate(self):
12397 
    return
12398 
 
12399 
 
94 ashish 12400 
  def __repr__(self):
12401 
    L = ['%s=%r' % (key, value)
12402 
      for key, value in self.__dict__.iteritems()]
12403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12404 
 
12405 
  def __eq__(self, other):
12406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12407 
 
12408 
  def __ne__(self, other):
12409 
    return not (self == other)
12410 
 
2981 rajveer 12411 
class getAllUsers_result:
94 ashish 12412 
  """
12413 
  Attributes:
12414 
   - success
12415 
  """
12416 
 
12417 
  thrift_spec = (
2981 rajveer 12418 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12419 
  )
12420 
 
2981 rajveer 12421 
  def __init__(self, success=None,):
94 ashish 12422 
    self.success = success
12423 
 
12424 
  def read(self, iprot):
12425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12427 
      return
12428 
    iprot.readStructBegin()
12429 
    while True:
12430 
      (fname, ftype, fid) = iprot.readFieldBegin()
12431 
      if ftype == TType.STOP:
12432 
        break
12433 
      if fid == 0:
2981 rajveer 12434 
        if ftype == TType.LIST:
12435 
          self.success = []
11592 amit.gupta 12436 
          (_etype186, _size183) = iprot.readListBegin()
12437 
          for _i187 in xrange(_size183):
12438 
            _elem188 = User()
12439 
            _elem188.read(iprot)
12440 
            self.success.append(_elem188)
2981 rajveer 12441 
          iprot.readListEnd()
94 ashish 12442 
        else:
12443 
          iprot.skip(ftype)
12444 
      else:
12445 
        iprot.skip(ftype)
12446 
      iprot.readFieldEnd()
12447 
    iprot.readStructEnd()
12448 
 
12449 
  def write(self, oprot):
12450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12452 
      return
2981 rajveer 12453 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12454 
    if self.success is not None:
2981 rajveer 12455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12456 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 12457 
      for iter189 in self.success:
12458 
        iter189.write(oprot)
2981 rajveer 12459 
      oprot.writeListEnd()
94 ashish 12460 
      oprot.writeFieldEnd()
12461 
    oprot.writeFieldStop()
12462 
    oprot.writeStructEnd()
12463 
 
3431 rajveer 12464 
  def validate(self):
12465 
    return
12466 
 
12467 
 
94 ashish 12468 
  def __repr__(self):
12469 
    L = ['%s=%r' % (key, value)
12470 
      for key, value in self.__dict__.iteritems()]
12471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12472 
 
12473 
  def __eq__(self, other):
12474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12475 
 
12476 
  def __ne__(self, other):
12477 
    return not (self == other)
12478 
 
2981 rajveer 12479 
class getMyResearchItems_args:
559 chandransh 12480 
  """
12481 
  Attributes:
772 rajveer 12482 
   - userId
559 chandransh 12483 
  """
12484 
 
12485 
  thrift_spec = (
12486 
    None, # 0
772 rajveer 12487 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12488 
  )
12489 
 
772 rajveer 12490 
  def __init__(self, userId=None,):
12491 
    self.userId = userId
559 chandransh 12492 
 
12493 
  def read(self, iprot):
12494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12496 
      return
12497 
    iprot.readStructBegin()
12498 
    while True:
12499 
      (fname, ftype, fid) = iprot.readFieldBegin()
12500 
      if ftype == TType.STOP:
12501 
        break
12502 
      if fid == 1:
12503 
        if ftype == TType.I64:
772 rajveer 12504 
          self.userId = iprot.readI64();
559 chandransh 12505 
        else:
12506 
          iprot.skip(ftype)
12507 
      else:
12508 
        iprot.skip(ftype)
12509 
      iprot.readFieldEnd()
12510 
    iprot.readStructEnd()
12511 
 
12512 
  def write(self, oprot):
12513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12515 
      return
2981 rajveer 12516 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 12517 
    if self.userId is not None:
772 rajveer 12518 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12519 
      oprot.writeI64(self.userId)
559 chandransh 12520 
      oprot.writeFieldEnd()
12521 
    oprot.writeFieldStop()
12522 
    oprot.writeStructEnd()
12523 
 
3431 rajveer 12524 
  def validate(self):
12525 
    return
12526 
 
12527 
 
559 chandransh 12528 
  def __repr__(self):
12529 
    L = ['%s=%r' % (key, value)
12530 
      for key, value in self.__dict__.iteritems()]
12531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12532 
 
12533 
  def __eq__(self, other):
12534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12535 
 
12536 
  def __ne__(self, other):
12537 
    return not (self == other)
12538 
 
2981 rajveer 12539 
class getMyResearchItems_result:
559 chandransh 12540 
  """
12541 
  Attributes:
130 ashish 12542 
   - success
559 chandransh 12543 
   - scx
130 ashish 12544 
  """
12545 
 
12546 
  thrift_spec = (
2981 rajveer 12547 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12548 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12549 
  )
12550 
 
559 chandransh 12551 
  def __init__(self, success=None, scx=None,):
130 ashish 12552 
    self.success = success
559 chandransh 12553 
    self.scx = scx
130 ashish 12554 
 
12555 
  def read(self, iprot):
12556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12558 
      return
12559 
    iprot.readStructBegin()
12560 
    while True:
12561 
      (fname, ftype, fid) = iprot.readFieldBegin()
12562 
      if ftype == TType.STOP:
12563 
        break
12564 
      if fid == 0:
2981 rajveer 12565 
        if ftype == TType.LIST:
12566 
          self.success = []
11592 amit.gupta 12567 
          (_etype193, _size190) = iprot.readListBegin()
12568 
          for _i194 in xrange(_size190):
12569 
            _elem195 = iprot.readI64();
12570 
            self.success.append(_elem195)
2981 rajveer 12571 
          iprot.readListEnd()
130 ashish 12572 
        else:
12573 
          iprot.skip(ftype)
12574 
      elif fid == 1:
12575 
        if ftype == TType.STRUCT:
559 chandransh 12576 
          self.scx = WidgetException()
12577 
          self.scx.read(iprot)
130 ashish 12578 
        else:
12579 
          iprot.skip(ftype)
12580 
      else:
12581 
        iprot.skip(ftype)
12582 
      iprot.readFieldEnd()
12583 
    iprot.readStructEnd()
12584 
 
12585 
  def write(self, oprot):
12586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12588 
      return
2981 rajveer 12589 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 12590 
    if self.success is not None:
2981 rajveer 12591 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12592 
      oprot.writeListBegin(TType.I64, len(self.success))
11592 amit.gupta 12593 
      for iter196 in self.success:
12594 
        oprot.writeI64(iter196)
2981 rajveer 12595 
      oprot.writeListEnd()
130 ashish 12596 
      oprot.writeFieldEnd()
3431 rajveer 12597 
    if self.scx is not None:
559 chandransh 12598 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12599 
      self.scx.write(oprot)
130 ashish 12600 
      oprot.writeFieldEnd()
12601 
    oprot.writeFieldStop()
12602 
    oprot.writeStructEnd()
12603 
 
3431 rajveer 12604 
  def validate(self):
12605 
    return
12606 
 
12607 
 
130 ashish 12608 
  def __repr__(self):
12609 
    L = ['%s=%r' % (key, value)
12610 
      for key, value in self.__dict__.iteritems()]
12611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12612 
 
12613 
  def __eq__(self, other):
12614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12615 
 
12616 
  def __ne__(self, other):
12617 
    return not (self == other)
12618 
 
2981 rajveer 12619 
class updateMyResearch_args:
130 ashish 12620 
  """
12621 
  Attributes:
2981 rajveer 12622 
   - userId
12623 
   - itemId
130 ashish 12624 
  """
12625 
 
12626 
  thrift_spec = (
12627 
    None, # 0
2981 rajveer 12628 
    (1, TType.I64, 'userId', None, None, ), # 1
12629 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12630 
  )
12631 
 
2981 rajveer 12632 
  def __init__(self, userId=None, itemId=None,):
12633 
    self.userId = userId
12634 
    self.itemId = itemId
130 ashish 12635 
 
12636 
  def read(self, iprot):
12637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12639 
      return
12640 
    iprot.readStructBegin()
12641 
    while True:
12642 
      (fname, ftype, fid) = iprot.readFieldBegin()
12643 
      if ftype == TType.STOP:
12644 
        break
12645 
      if fid == 1:
559 chandransh 12646 
        if ftype == TType.I64:
2981 rajveer 12647 
          self.userId = iprot.readI64();
130 ashish 12648 
        else:
12649 
          iprot.skip(ftype)
12650 
      elif fid == 2:
559 chandransh 12651 
        if ftype == TType.I64:
2981 rajveer 12652 
          self.itemId = iprot.readI64();
559 chandransh 12653 
        else:
12654 
          iprot.skip(ftype)
130 ashish 12655 
      else:
12656 
        iprot.skip(ftype)
12657 
      iprot.readFieldEnd()
12658 
    iprot.readStructEnd()
12659 
 
12660 
  def write(self, oprot):
12661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12663 
      return
2981 rajveer 12664 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 12665 
    if self.userId is not None:
2981 rajveer 12666 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12667 
      oprot.writeI64(self.userId)
130 ashish 12668 
      oprot.writeFieldEnd()
3431 rajveer 12669 
    if self.itemId is not None:
2981 rajveer 12670 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12671 
      oprot.writeI64(self.itemId)
130 ashish 12672 
      oprot.writeFieldEnd()
12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
3431 rajveer 12676 
  def validate(self):
12677 
    return
12678 
 
12679 
 
130 ashish 12680 
  def __repr__(self):
12681 
    L = ['%s=%r' % (key, value)
12682 
      for key, value in self.__dict__.iteritems()]
12683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12684 
 
12685 
  def __eq__(self, other):
12686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12687 
 
12688 
  def __ne__(self, other):
12689 
    return not (self == other)
12690 
 
2981 rajveer 12691 
class updateMyResearch_result:
12692 
  """
12693 
  Attributes:
12694 
   - success
12695 
   - scx
12696 
  """
559 chandransh 12697 
 
12698 
  thrift_spec = (
2981 rajveer 12699 
    (0, TType.BOOL, 'success', None, None, ), # 0
12700 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12701 
  )
12702 
 
2981 rajveer 12703 
  def __init__(self, success=None, scx=None,):
12704 
    self.success = success
12705 
    self.scx = scx
12706 
 
559 chandransh 12707 
  def read(self, iprot):
12708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12710 
      return
12711 
    iprot.readStructBegin()
12712 
    while True:
12713 
      (fname, ftype, fid) = iprot.readFieldBegin()
12714 
      if ftype == TType.STOP:
12715 
        break
2981 rajveer 12716 
      if fid == 0:
12717 
        if ftype == TType.BOOL:
12718 
          self.success = iprot.readBool();
12719 
        else:
12720 
          iprot.skip(ftype)
12721 
      elif fid == 1:
12722 
        if ftype == TType.STRUCT:
12723 
          self.scx = WidgetException()
12724 
          self.scx.read(iprot)
12725 
        else:
12726 
          iprot.skip(ftype)
559 chandransh 12727 
      else:
12728 
        iprot.skip(ftype)
12729 
      iprot.readFieldEnd()
12730 
    iprot.readStructEnd()
12731 
 
12732 
  def write(self, oprot):
12733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12735 
      return
2981 rajveer 12736 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 12737 
    if self.success is not None:
2981 rajveer 12738 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12739 
      oprot.writeBool(self.success)
12740 
      oprot.writeFieldEnd()
3431 rajveer 12741 
    if self.scx is not None:
2981 rajveer 12742 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12743 
      self.scx.write(oprot)
12744 
      oprot.writeFieldEnd()
559 chandransh 12745 
    oprot.writeFieldStop()
12746 
    oprot.writeStructEnd()
12747 
 
3431 rajveer 12748 
  def validate(self):
12749 
    return
12750 
 
12751 
 
559 chandransh 12752 
  def __repr__(self):
12753 
    L = ['%s=%r' % (key, value)
12754 
      for key, value in self.__dict__.iteritems()]
12755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12756 
 
12757 
  def __eq__(self, other):
12758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12759 
 
12760 
  def __ne__(self, other):
12761 
    return not (self == other)
12762 
 
2981 rajveer 12763 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12764 
  """
12765 
  Attributes:
2981 rajveer 12766 
   - userId
12767 
   - itemId
1596 ankur.sing 12768 
  """
559 chandransh 12769 
 
1596 ankur.sing 12770 
  thrift_spec = (
12771 
    None, # 0
2981 rajveer 12772 
    (1, TType.I64, 'userId', None, None, ), # 1
12773 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12774 
  )
12775 
 
2981 rajveer 12776 
  def __init__(self, userId=None, itemId=None,):
12777 
    self.userId = userId
12778 
    self.itemId = itemId
1596 ankur.sing 12779 
 
12780 
  def read(self, iprot):
12781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12783 
      return
12784 
    iprot.readStructBegin()
12785 
    while True:
12786 
      (fname, ftype, fid) = iprot.readFieldBegin()
12787 
      if ftype == TType.STOP:
12788 
        break
12789 
      if fid == 1:
2981 rajveer 12790 
        if ftype == TType.I64:
12791 
          self.userId = iprot.readI64();
1596 ankur.sing 12792 
        else:
12793 
          iprot.skip(ftype)
2981 rajveer 12794 
      elif fid == 2:
12795 
        if ftype == TType.I64:
12796 
          self.itemId = iprot.readI64();
12797 
        else:
12798 
          iprot.skip(ftype)
1596 ankur.sing 12799 
      else:
12800 
        iprot.skip(ftype)
12801 
      iprot.readFieldEnd()
12802 
    iprot.readStructEnd()
12803 
 
12804 
  def write(self, oprot):
12805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12807 
      return
2981 rajveer 12808 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 12809 
    if self.userId is not None:
2981 rajveer 12810 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12811 
      oprot.writeI64(self.userId)
1596 ankur.sing 12812 
      oprot.writeFieldEnd()
3431 rajveer 12813 
    if self.itemId is not None:
2981 rajveer 12814 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12815 
      oprot.writeI64(self.itemId)
12816 
      oprot.writeFieldEnd()
1596 ankur.sing 12817 
    oprot.writeFieldStop()
12818 
    oprot.writeStructEnd()
12819 
 
3431 rajveer 12820 
  def validate(self):
12821 
    return
12822 
 
12823 
 
1596 ankur.sing 12824 
  def __repr__(self):
12825 
    L = ['%s=%r' % (key, value)
12826 
      for key, value in self.__dict__.iteritems()]
12827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12828 
 
12829 
  def __eq__(self, other):
12830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12831 
 
12832 
  def __ne__(self, other):
12833 
    return not (self == other)
12834 
 
2981 rajveer 12835 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12836 
  """
12837 
  Attributes:
2981 rajveer 12838 
   - scx
1596 ankur.sing 12839 
  """
12840 
 
12841 
  thrift_spec = (
2981 rajveer 12842 
    None, # 0
12843 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12844 
  )
12845 
 
2981 rajveer 12846 
  def __init__(self, scx=None,):
12847 
    self.scx = scx
1596 ankur.sing 12848 
 
12849 
  def read(self, iprot):
12850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12852 
      return
12853 
    iprot.readStructBegin()
12854 
    while True:
12855 
      (fname, ftype, fid) = iprot.readFieldBegin()
12856 
      if ftype == TType.STOP:
12857 
        break
2981 rajveer 12858 
      if fid == 1:
12859 
        if ftype == TType.STRUCT:
12860 
          self.scx = WidgetException()
12861 
          self.scx.read(iprot)
1596 ankur.sing 12862 
        else:
12863 
          iprot.skip(ftype)
12864 
      else:
12865 
        iprot.skip(ftype)
12866 
      iprot.readFieldEnd()
12867 
    iprot.readStructEnd()
12868 
 
12869 
  def write(self, oprot):
12870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12872 
      return
2981 rajveer 12873 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 12874 
    if self.scx is not None:
2981 rajveer 12875 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12876 
      self.scx.write(oprot)
1596 ankur.sing 12877 
      oprot.writeFieldEnd()
12878 
    oprot.writeFieldStop()
12879 
    oprot.writeStructEnd()
12880 
 
3431 rajveer 12881 
  def validate(self):
12882 
    return
12883 
 
12884 
 
1596 ankur.sing 12885 
  def __repr__(self):
12886 
    L = ['%s=%r' % (key, value)
12887 
      for key, value in self.__dict__.iteritems()]
12888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12889 
 
12890 
  def __eq__(self, other):
12891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12892 
 
12893 
  def __ne__(self, other):
12894 
    return not (self == other)
12895 
 
2981 rajveer 12896 
class getBrowseHistoryItems_args:
1673 ankur.sing 12897 
  """
12898 
  Attributes:
2981 rajveer 12899 
   - userId
1673 ankur.sing 12900 
  """
1596 ankur.sing 12901 
 
1673 ankur.sing 12902 
  thrift_spec = (
12903 
    None, # 0
2981 rajveer 12904 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12905 
  )
12906 
 
2981 rajveer 12907 
  def __init__(self, userId=None,):
12908 
    self.userId = userId
1673 ankur.sing 12909 
 
12910 
  def read(self, iprot):
12911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12913 
      return
12914 
    iprot.readStructBegin()
12915 
    while True:
12916 
      (fname, ftype, fid) = iprot.readFieldBegin()
12917 
      if ftype == TType.STOP:
12918 
        break
12919 
      if fid == 1:
1891 ankur.sing 12920 
        if ftype == TType.I64:
2981 rajveer 12921 
          self.userId = iprot.readI64();
1891 ankur.sing 12922 
        else:
12923 
          iprot.skip(ftype)
1673 ankur.sing 12924 
      else:
12925 
        iprot.skip(ftype)
12926 
      iprot.readFieldEnd()
12927 
    iprot.readStructEnd()
12928 
 
12929 
  def write(self, oprot):
12930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12932 
      return
2981 rajveer 12933 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 12934 
    if self.userId is not None:
2981 rajveer 12935 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12936 
      oprot.writeI64(self.userId)
1673 ankur.sing 12937 
      oprot.writeFieldEnd()
12938 
    oprot.writeFieldStop()
12939 
    oprot.writeStructEnd()
12940 
 
3431 rajveer 12941 
  def validate(self):
12942 
    return
12943 
 
12944 
 
1673 ankur.sing 12945 
  def __repr__(self):
12946 
    L = ['%s=%r' % (key, value)
12947 
      for key, value in self.__dict__.iteritems()]
12948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12949 
 
12950 
  def __eq__(self, other):
12951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12952 
 
12953 
  def __ne__(self, other):
12954 
    return not (self == other)
12955 
 
2981 rajveer 12956 
class getBrowseHistoryItems_result:
1673 ankur.sing 12957 
  """
12958 
  Attributes:
12959 
   - success
2981 rajveer 12960 
   - scx
1673 ankur.sing 12961 
  """
12962 
 
12963 
  thrift_spec = (
2981 rajveer 12964 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12965 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12966 
  )
12967 
 
2981 rajveer 12968 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12969 
    self.success = success
2981 rajveer 12970 
    self.scx = scx
1673 ankur.sing 12971 
 
12972 
  def read(self, iprot):
12973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12975 
      return
12976 
    iprot.readStructBegin()
12977 
    while True:
12978 
      (fname, ftype, fid) = iprot.readFieldBegin()
12979 
      if ftype == TType.STOP:
12980 
        break
12981 
      if fid == 0:
12982 
        if ftype == TType.LIST:
12983 
          self.success = []
11592 amit.gupta 12984 
          (_etype200, _size197) = iprot.readListBegin()
12985 
          for _i201 in xrange(_size197):
12986 
            _elem202 = iprot.readI64();
12987 
            self.success.append(_elem202)
1673 ankur.sing 12988 
          iprot.readListEnd()
12989 
        else:
12990 
          iprot.skip(ftype)
2981 rajveer 12991 
      elif fid == 1:
12992 
        if ftype == TType.STRUCT:
12993 
          self.scx = WidgetException()
12994 
          self.scx.read(iprot)
12995 
        else:
12996 
          iprot.skip(ftype)
1673 ankur.sing 12997 
      else:
12998 
        iprot.skip(ftype)
12999 
      iprot.readFieldEnd()
13000 
    iprot.readStructEnd()
13001 
 
13002 
  def write(self, oprot):
13003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13005 
      return
2981 rajveer 13006 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13007 
    if self.success is not None:
1673 ankur.sing 13008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13009 
      oprot.writeListBegin(TType.I64, len(self.success))
11592 amit.gupta 13010 
      for iter203 in self.success:
13011 
        oprot.writeI64(iter203)
1673 ankur.sing 13012 
      oprot.writeListEnd()
13013 
      oprot.writeFieldEnd()
3431 rajveer 13014 
    if self.scx is not None:
2981 rajveer 13015 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13016 
      self.scx.write(oprot)
2642 varun.gupt 13017 
      oprot.writeFieldEnd()
13018 
    oprot.writeFieldStop()
13019 
    oprot.writeStructEnd()
13020 
 
3431 rajveer 13021 
  def validate(self):
13022 
    return
13023 
 
13024 
 
2642 varun.gupt 13025 
  def __repr__(self):
13026 
    L = ['%s=%r' % (key, value)
13027 
      for key, value in self.__dict__.iteritems()]
13028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13029 
 
13030 
  def __eq__(self, other):
13031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13032 
 
13033 
  def __ne__(self, other):
13034 
    return not (self == other)
13035 
 
2981 rajveer 13036 
class updateBrowseHistory_args:
2642 varun.gupt 13037 
  """
13038 
  Attributes:
2981 rajveer 13039 
   - userId
13040 
   - itemId
2642 varun.gupt 13041 
  """
13042 
 
13043 
  thrift_spec = (
13044 
    None, # 0
2981 rajveer 13045 
    (1, TType.I64, 'userId', None, None, ), # 1
13046 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13047 
  )
13048 
 
2981 rajveer 13049 
  def __init__(self, userId=None, itemId=None,):
13050 
    self.userId = userId
13051 
    self.itemId = itemId
2642 varun.gupt 13052 
 
13053 
  def read(self, iprot):
13054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13056 
      return
13057 
    iprot.readStructBegin()
13058 
    while True:
13059 
      (fname, ftype, fid) = iprot.readFieldBegin()
13060 
      if ftype == TType.STOP:
13061 
        break
13062 
      if fid == 1:
13063 
        if ftype == TType.I64:
2981 rajveer 13064 
          self.userId = iprot.readI64();
2642 varun.gupt 13065 
        else:
13066 
          iprot.skip(ftype)
13067 
      elif fid == 2:
13068 
        if ftype == TType.I64:
2981 rajveer 13069 
          self.itemId = iprot.readI64();
2642 varun.gupt 13070 
        else:
13071 
          iprot.skip(ftype)
13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
2981 rajveer 13081 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13082 
    if self.userId is not None:
2981 rajveer 13083 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13084 
      oprot.writeI64(self.userId)
2642 varun.gupt 13085 
      oprot.writeFieldEnd()
3431 rajveer 13086 
    if self.itemId is not None:
2981 rajveer 13087 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13088 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13089 
      oprot.writeFieldEnd()
13090 
    oprot.writeFieldStop()
13091 
    oprot.writeStructEnd()
13092 
 
3431 rajveer 13093 
  def validate(self):
13094 
    return
13095 
 
13096 
 
2642 varun.gupt 13097 
  def __repr__(self):
13098 
    L = ['%s=%r' % (key, value)
13099 
      for key, value in self.__dict__.iteritems()]
13100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13101 
 
13102 
  def __eq__(self, other):
13103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13104 
 
13105 
  def __ne__(self, other):
13106 
    return not (self == other)
13107 
 
2981 rajveer 13108 
class updateBrowseHistory_result:
2642 varun.gupt 13109 
 
13110 
  thrift_spec = (
13111 
  )
13112 
 
13113 
  def read(self, iprot):
13114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13116 
      return
13117 
    iprot.readStructBegin()
13118 
    while True:
13119 
      (fname, ftype, fid) = iprot.readFieldBegin()
13120 
      if ftype == TType.STOP:
13121 
        break
13122 
      else:
13123 
        iprot.skip(ftype)
13124 
      iprot.readFieldEnd()
13125 
    iprot.readStructEnd()
13126 
 
13127 
  def write(self, oprot):
13128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13130 
      return
2981 rajveer 13131 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13132 
    oprot.writeFieldStop()
13133 
    oprot.writeStructEnd()
13134 
 
3431 rajveer 13135 
  def validate(self):
13136 
    return
13137 
 
13138 
 
2642 varun.gupt 13139 
  def __repr__(self):
13140 
    L = ['%s=%r' % (key, value)
13141 
      for key, value in self.__dict__.iteritems()]
13142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13143 
 
13144 
  def __eq__(self, other):
13145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13146 
 
13147 
  def __ne__(self, other):
13148 
    return not (self == other)
13149 
 
3385 varun.gupt 13150 
class getCartsWithCouponCount_args:
13151 
  """
13152 
  Attributes:
13153 
   - couponCode
13154 
  """
2642 varun.gupt 13155 
 
3385 varun.gupt 13156 
  thrift_spec = (
13157 
    None, # 0
13158 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13159 
  )
13160 
 
13161 
  def __init__(self, couponCode=None,):
13162 
    self.couponCode = couponCode
13163 
 
13164 
  def read(self, iprot):
13165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13167 
      return
13168 
    iprot.readStructBegin()
13169 
    while True:
13170 
      (fname, ftype, fid) = iprot.readFieldBegin()
13171 
      if ftype == TType.STOP:
13172 
        break
13173 
      if fid == 1:
13174 
        if ftype == TType.STRING:
13175 
          self.couponCode = iprot.readString();
13176 
        else:
13177 
          iprot.skip(ftype)
13178 
      else:
13179 
        iprot.skip(ftype)
13180 
      iprot.readFieldEnd()
13181 
    iprot.readStructEnd()
13182 
 
13183 
  def write(self, oprot):
13184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13186 
      return
13187 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13188 
    if self.couponCode is not None:
3385 varun.gupt 13189 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13190 
      oprot.writeString(self.couponCode)
13191 
      oprot.writeFieldEnd()
13192 
    oprot.writeFieldStop()
13193 
    oprot.writeStructEnd()
13194 
 
3431 rajveer 13195 
  def validate(self):
13196 
    return
13197 
 
13198 
 
3385 varun.gupt 13199 
  def __repr__(self):
13200 
    L = ['%s=%r' % (key, value)
13201 
      for key, value in self.__dict__.iteritems()]
13202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13203 
 
13204 
  def __eq__(self, other):
13205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13206 
 
13207 
  def __ne__(self, other):
13208 
    return not (self == other)
13209 
 
13210 
class getCartsWithCouponCount_result:
13211 
  """
13212 
  Attributes:
13213 
   - success
13214 
  """
13215 
 
13216 
  thrift_spec = (
13217 
    (0, TType.I64, 'success', None, None, ), # 0
13218 
  )
13219 
 
13220 
  def __init__(self, success=None,):
13221 
    self.success = success
13222 
 
13223 
  def read(self, iprot):
13224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13226 
      return
13227 
    iprot.readStructBegin()
13228 
    while True:
13229 
      (fname, ftype, fid) = iprot.readFieldBegin()
13230 
      if ftype == TType.STOP:
13231 
        break
13232 
      if fid == 0:
13233 
        if ftype == TType.I64:
13234 
          self.success = iprot.readI64();
13235 
        else:
13236 
          iprot.skip(ftype)
13237 
      else:
13238 
        iprot.skip(ftype)
13239 
      iprot.readFieldEnd()
13240 
    iprot.readStructEnd()
13241 
 
13242 
  def write(self, oprot):
13243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13245 
      return
13246 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13247 
    if self.success is not None:
3385 varun.gupt 13248 
      oprot.writeFieldBegin('success', TType.I64, 0)
13249 
      oprot.writeI64(self.success)
13250 
      oprot.writeFieldEnd()
13251 
    oprot.writeFieldStop()
13252 
    oprot.writeStructEnd()
13253 
 
3431 rajveer 13254 
  def validate(self):
13255 
    return
13256 
 
13257 
 
3385 varun.gupt 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)
3499 mandeep.dh 13268 
 
13269 
class increaseTrustLevel_args:
13270 
  """
13271 
  Attributes:
13272 
   - userId
13273 
   - trustLevelDelta
13274 
  """
13275 
 
13276 
  thrift_spec = (
13277 
    None, # 0
13278 
    (1, TType.I64, 'userId', None, None, ), # 1
13279 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13280 
  )
13281 
 
13282 
  def __init__(self, userId=None, trustLevelDelta=None,):
13283 
    self.userId = userId
13284 
    self.trustLevelDelta = trustLevelDelta
13285 
 
13286 
  def read(self, iprot):
13287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13289 
      return
13290 
    iprot.readStructBegin()
13291 
    while True:
13292 
      (fname, ftype, fid) = iprot.readFieldBegin()
13293 
      if ftype == TType.STOP:
13294 
        break
13295 
      if fid == 1:
13296 
        if ftype == TType.I64:
13297 
          self.userId = iprot.readI64();
13298 
        else:
13299 
          iprot.skip(ftype)
13300 
      elif fid == 2:
13301 
        if ftype == TType.DOUBLE:
13302 
          self.trustLevelDelta = iprot.readDouble();
13303 
        else:
13304 
          iprot.skip(ftype)
13305 
      else:
13306 
        iprot.skip(ftype)
13307 
      iprot.readFieldEnd()
13308 
    iprot.readStructEnd()
13309 
 
13310 
  def write(self, oprot):
13311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13313 
      return
13314 
    oprot.writeStructBegin('increaseTrustLevel_args')
13315 
    if self.userId is not None:
13316 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13317 
      oprot.writeI64(self.userId)
13318 
      oprot.writeFieldEnd()
13319 
    if self.trustLevelDelta is not None:
13320 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13321 
      oprot.writeDouble(self.trustLevelDelta)
13322 
      oprot.writeFieldEnd()
13323 
    oprot.writeFieldStop()
13324 
    oprot.writeStructEnd()
13325 
 
13326 
  def validate(self):
13327 
    return
13328 
 
13329 
 
13330 
  def __repr__(self):
13331 
    L = ['%s=%r' % (key, value)
13332 
      for key, value in self.__dict__.iteritems()]
13333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13334 
 
13335 
  def __eq__(self, other):
13336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13337 
 
13338 
  def __ne__(self, other):
13339 
    return not (self == other)
4668 varun.gupt 13340 
 
5407 amar.kumar 13341 
class getTrustLevel_args:
13342 
  """
13343 
  Attributes:
13344 
   - userId
13345 
  """
13346 
 
13347 
  thrift_spec = (
13348 
    None, # 0
13349 
    (1, TType.I64, 'userId', None, None, ), # 1
13350 
  )
13351 
 
13352 
  def __init__(self, userId=None,):
13353 
    self.userId = userId
13354 
 
13355 
  def read(self, iprot):
13356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13358 
      return
13359 
    iprot.readStructBegin()
13360 
    while True:
13361 
      (fname, ftype, fid) = iprot.readFieldBegin()
13362 
      if ftype == TType.STOP:
13363 
        break
13364 
      if fid == 1:
13365 
        if ftype == TType.I64:
13366 
          self.userId = iprot.readI64();
13367 
        else:
13368 
          iprot.skip(ftype)
13369 
      else:
13370 
        iprot.skip(ftype)
13371 
      iprot.readFieldEnd()
13372 
    iprot.readStructEnd()
13373 
 
13374 
  def write(self, oprot):
13375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13377 
      return
13378 
    oprot.writeStructBegin('getTrustLevel_args')
13379 
    if self.userId is not None:
13380 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13381 
      oprot.writeI64(self.userId)
13382 
      oprot.writeFieldEnd()
13383 
    oprot.writeFieldStop()
13384 
    oprot.writeStructEnd()
13385 
 
13386 
  def validate(self):
13387 
    return
13388 
 
13389 
 
13390 
  def __repr__(self):
13391 
    L = ['%s=%r' % (key, value)
13392 
      for key, value in self.__dict__.iteritems()]
13393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13394 
 
13395 
  def __eq__(self, other):
13396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13397 
 
13398 
  def __ne__(self, other):
13399 
    return not (self == other)
13400 
 
13401 
class getTrustLevel_result:
13402 
  """
13403 
  Attributes:
13404 
   - success
13405 
  """
13406 
 
13407 
  thrift_spec = (
13408 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13409 
  )
13410 
 
13411 
  def __init__(self, success=None,):
13412 
    self.success = success
13413 
 
13414 
  def read(self, iprot):
13415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13417 
      return
13418 
    iprot.readStructBegin()
13419 
    while True:
13420 
      (fname, ftype, fid) = iprot.readFieldBegin()
13421 
      if ftype == TType.STOP:
13422 
        break
13423 
      if fid == 0:
13424 
        if ftype == TType.DOUBLE:
13425 
          self.success = iprot.readDouble();
13426 
        else:
13427 
          iprot.skip(ftype)
13428 
      else:
13429 
        iprot.skip(ftype)
13430 
      iprot.readFieldEnd()
13431 
    iprot.readStructEnd()
13432 
 
13433 
  def write(self, oprot):
13434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13436 
      return
13437 
    oprot.writeStructBegin('getTrustLevel_result')
13438 
    if self.success is not None:
13439 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13440 
      oprot.writeDouble(self.success)
13441 
      oprot.writeFieldEnd()
13442 
    oprot.writeFieldStop()
13443 
    oprot.writeStructEnd()
13444 
 
13445 
  def validate(self):
13446 
    return
13447 
 
13448 
 
13449 
  def __repr__(self):
13450 
    L = ['%s=%r' % (key, value)
13451 
      for key, value in self.__dict__.iteritems()]
13452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13453 
 
13454 
  def __eq__(self, other):
13455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13456 
 
13457 
  def __ne__(self, other):
13458 
    return not (self == other)
13459 
 
4668 varun.gupt 13460 
class showCODOption_args:
13461 
  """
13462 
  Attributes:
13463 
   - cartId
13464 
   - sourceId
13465 
   - pincode
13466 
  """
13467 
 
13468 
  thrift_spec = (
13469 
    None, # 0
13470 
    (1, TType.I64, 'cartId', None, None, ), # 1
13471 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13472 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13473 
  )
13474 
 
13475 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13476 
    self.cartId = cartId
13477 
    self.sourceId = sourceId
13478 
    self.pincode = pincode
13479 
 
13480 
  def read(self, iprot):
13481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13483 
      return
13484 
    iprot.readStructBegin()
13485 
    while True:
13486 
      (fname, ftype, fid) = iprot.readFieldBegin()
13487 
      if ftype == TType.STOP:
13488 
        break
13489 
      if fid == 1:
13490 
        if ftype == TType.I64:
13491 
          self.cartId = iprot.readI64();
13492 
        else:
13493 
          iprot.skip(ftype)
13494 
      elif fid == 2:
13495 
        if ftype == TType.I64:
13496 
          self.sourceId = iprot.readI64();
13497 
        else:
13498 
          iprot.skip(ftype)
13499 
      elif fid == 3:
13500 
        if ftype == TType.STRING:
13501 
          self.pincode = iprot.readString();
13502 
        else:
13503 
          iprot.skip(ftype)
13504 
      else:
13505 
        iprot.skip(ftype)
13506 
      iprot.readFieldEnd()
13507 
    iprot.readStructEnd()
13508 
 
13509 
  def write(self, oprot):
13510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13512 
      return
13513 
    oprot.writeStructBegin('showCODOption_args')
13514 
    if self.cartId is not None:
13515 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13516 
      oprot.writeI64(self.cartId)
13517 
      oprot.writeFieldEnd()
13518 
    if self.sourceId is not None:
13519 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13520 
      oprot.writeI64(self.sourceId)
13521 
      oprot.writeFieldEnd()
13522 
    if self.pincode is not None:
13523 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
13524 
      oprot.writeString(self.pincode)
13525 
      oprot.writeFieldEnd()
13526 
    oprot.writeFieldStop()
13527 
    oprot.writeStructEnd()
13528 
 
13529 
  def validate(self):
13530 
    return
13531 
 
13532 
 
13533 
  def __repr__(self):
13534 
    L = ['%s=%r' % (key, value)
13535 
      for key, value in self.__dict__.iteritems()]
13536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13537 
 
13538 
  def __eq__(self, other):
13539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13540 
 
13541 
  def __ne__(self, other):
13542 
    return not (self == other)
13543 
 
13544 
class showCODOption_result:
13545 
  """
13546 
  Attributes:
13547 
   - success
13548 
  """
13549 
 
13550 
  thrift_spec = (
13551 
    (0, TType.BOOL, 'success', None, None, ), # 0
13552 
  )
13553 
 
13554 
  def __init__(self, success=None,):
13555 
    self.success = success
13556 
 
13557 
  def read(self, iprot):
13558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13560 
      return
13561 
    iprot.readStructBegin()
13562 
    while True:
13563 
      (fname, ftype, fid) = iprot.readFieldBegin()
13564 
      if ftype == TType.STOP:
13565 
        break
13566 
      if fid == 0:
13567 
        if ftype == TType.BOOL:
13568 
          self.success = iprot.readBool();
13569 
        else:
13570 
          iprot.skip(ftype)
13571 
      else:
13572 
        iprot.skip(ftype)
13573 
      iprot.readFieldEnd()
13574 
    iprot.readStructEnd()
13575 
 
13576 
  def write(self, oprot):
13577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13579 
      return
13580 
    oprot.writeStructBegin('showCODOption_result')
13581 
    if self.success is not None:
13582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13583 
      oprot.writeBool(self.success)
13584 
      oprot.writeFieldEnd()
13585 
    oprot.writeFieldStop()
13586 
    oprot.writeStructEnd()
13587 
 
13588 
  def validate(self):
13589 
    return
13590 
 
13591 
 
13592 
  def __repr__(self):
13593 
    L = ['%s=%r' % (key, value)
13594 
      for key, value in self.__dict__.iteritems()]
13595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13596 
 
13597 
  def __eq__(self, other):
13598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13599 
 
13600 
  def __ne__(self, other):
13601 
    return not (self == other)
5623 anupam.sin 13602 
 
13603 
class getUserEmails_args:
13604 
  """
13605 
  Attributes:
13606 
   - startDate
13607 
   - endDate
13608 
  """
13609 
 
13610 
  thrift_spec = (
13611 
    None, # 0
13612 
    (1, TType.I64, 'startDate', None, None, ), # 1
13613 
    (2, TType.I64, 'endDate', None, None, ), # 2
13614 
  )
13615 
 
13616 
  def __init__(self, startDate=None, endDate=None,):
13617 
    self.startDate = startDate
13618 
    self.endDate = endDate
13619 
 
13620 
  def read(self, iprot):
13621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13623 
      return
13624 
    iprot.readStructBegin()
13625 
    while True:
13626 
      (fname, ftype, fid) = iprot.readFieldBegin()
13627 
      if ftype == TType.STOP:
13628 
        break
13629 
      if fid == 1:
13630 
        if ftype == TType.I64:
13631 
          self.startDate = iprot.readI64();
13632 
        else:
13633 
          iprot.skip(ftype)
13634 
      elif fid == 2:
13635 
        if ftype == TType.I64:
13636 
          self.endDate = iprot.readI64();
13637 
        else:
13638 
          iprot.skip(ftype)
13639 
      else:
13640 
        iprot.skip(ftype)
13641 
      iprot.readFieldEnd()
13642 
    iprot.readStructEnd()
13643 
 
13644 
  def write(self, oprot):
13645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13647 
      return
13648 
    oprot.writeStructBegin('getUserEmails_args')
13649 
    if self.startDate is not None:
13650 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
13651 
      oprot.writeI64(self.startDate)
13652 
      oprot.writeFieldEnd()
13653 
    if self.endDate is not None:
13654 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
13655 
      oprot.writeI64(self.endDate)
13656 
      oprot.writeFieldEnd()
13657 
    oprot.writeFieldStop()
13658 
    oprot.writeStructEnd()
13659 
 
13660 
  def validate(self):
13661 
    return
13662 
 
13663 
 
13664 
  def __repr__(self):
13665 
    L = ['%s=%r' % (key, value)
13666 
      for key, value in self.__dict__.iteritems()]
13667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13668 
 
13669 
  def __eq__(self, other):
13670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13671 
 
13672 
  def __ne__(self, other):
13673 
    return not (self == other)
13674 
 
13675 
class getUserEmails_result:
13676 
  """
13677 
  Attributes:
13678 
   - success
13679 
  """
13680 
 
13681 
  thrift_spec = (
13682 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13683 
  )
13684 
 
13685 
  def __init__(self, success=None,):
13686 
    self.success = success
13687 
 
13688 
  def read(self, iprot):
13689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13691 
      return
13692 
    iprot.readStructBegin()
13693 
    while True:
13694 
      (fname, ftype, fid) = iprot.readFieldBegin()
13695 
      if ftype == TType.STOP:
13696 
        break
13697 
      if fid == 0:
13698 
        if ftype == TType.LIST:
13699 
          self.success = []
11592 amit.gupta 13700 
          (_etype207, _size204) = iprot.readListBegin()
13701 
          for _i208 in xrange(_size204):
13702 
            _elem209 = iprot.readString();
13703 
            self.success.append(_elem209)
5623 anupam.sin 13704 
          iprot.readListEnd()
13705 
        else:
13706 
          iprot.skip(ftype)
13707 
      else:
13708 
        iprot.skip(ftype)
13709 
      iprot.readFieldEnd()
13710 
    iprot.readStructEnd()
13711 
 
13712 
  def write(self, oprot):
13713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13715 
      return
13716 
    oprot.writeStructBegin('getUserEmails_result')
13717 
    if self.success is not None:
13718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13719 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 13720 
      for iter210 in self.success:
13721 
        oprot.writeString(iter210)
5623 anupam.sin 13722 
      oprot.writeListEnd()
13723 
      oprot.writeFieldEnd()
13724 
    oprot.writeFieldStop()
13725 
    oprot.writeStructEnd()
13726 
 
13727 
  def validate(self):
13728 
    return
13729 
 
13730 
 
13731 
  def __repr__(self):
13732 
    L = ['%s=%r' % (key, value)
13733 
      for key, value in self.__dict__.iteritems()]
13734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13735 
 
13736 
  def __eq__(self, other):
13737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13738 
 
13739 
  def __ne__(self, other):
13740 
    return not (self == other)
6821 amar.kumar 13741 
 
6903 anupam.sin 13742 
class insureItem_args:
13743 
  """
13744 
  Attributes:
13745 
   - itemId
13746 
   - cartId
13747 
   - toInsure
9299 kshitij.so 13748 
   - insurerType
6903 anupam.sin 13749 
  """
13750 
 
13751 
  thrift_spec = (
13752 
    None, # 0
13753 
    (1, TType.I64, 'itemId', None, None, ), # 1
13754 
    (2, TType.I64, 'cartId', None, None, ), # 2
13755 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 13756 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 13757 
  )
13758 
 
9299 kshitij.so 13759 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 13760 
    self.itemId = itemId
13761 
    self.cartId = cartId
13762 
    self.toInsure = toInsure
9299 kshitij.so 13763 
    self.insurerType = insurerType
6903 anupam.sin 13764 
 
13765 
  def read(self, iprot):
13766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13768 
      return
13769 
    iprot.readStructBegin()
13770 
    while True:
13771 
      (fname, ftype, fid) = iprot.readFieldBegin()
13772 
      if ftype == TType.STOP:
13773 
        break
13774 
      if fid == 1:
13775 
        if ftype == TType.I64:
13776 
          self.itemId = iprot.readI64();
13777 
        else:
13778 
          iprot.skip(ftype)
13779 
      elif fid == 2:
13780 
        if ftype == TType.I64:
13781 
          self.cartId = iprot.readI64();
13782 
        else:
13783 
          iprot.skip(ftype)
13784 
      elif fid == 3:
13785 
        if ftype == TType.BOOL:
13786 
          self.toInsure = iprot.readBool();
13787 
        else:
13788 
          iprot.skip(ftype)
9299 kshitij.so 13789 
      elif fid == 4:
13790 
        if ftype == TType.I32:
13791 
          self.insurerType = iprot.readI32();
13792 
        else:
13793 
          iprot.skip(ftype)
6903 anupam.sin 13794 
      else:
13795 
        iprot.skip(ftype)
13796 
      iprot.readFieldEnd()
13797 
    iprot.readStructEnd()
13798 
 
13799 
  def write(self, oprot):
13800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13802 
      return
13803 
    oprot.writeStructBegin('insureItem_args')
13804 
    if self.itemId is not None:
13805 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13806 
      oprot.writeI64(self.itemId)
13807 
      oprot.writeFieldEnd()
13808 
    if self.cartId is not None:
13809 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
13810 
      oprot.writeI64(self.cartId)
13811 
      oprot.writeFieldEnd()
13812 
    if self.toInsure is not None:
13813 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
13814 
      oprot.writeBool(self.toInsure)
13815 
      oprot.writeFieldEnd()
9299 kshitij.so 13816 
    if self.insurerType is not None:
13817 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
13818 
      oprot.writeI32(self.insurerType)
13819 
      oprot.writeFieldEnd()
6903 anupam.sin 13820 
    oprot.writeFieldStop()
13821 
    oprot.writeStructEnd()
13822 
 
13823 
  def validate(self):
13824 
    return
13825 
 
13826 
 
13827 
  def __repr__(self):
13828 
    L = ['%s=%r' % (key, value)
13829 
      for key, value in self.__dict__.iteritems()]
13830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13831 
 
13832 
  def __eq__(self, other):
13833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13834 
 
13835 
  def __ne__(self, other):
13836 
    return not (self == other)
13837 
 
13838 
class insureItem_result:
13839 
  """
13840 
  Attributes:
13841 
   - success
13842 
  """
13843 
 
13844 
  thrift_spec = (
13845 
    (0, TType.BOOL, 'success', None, None, ), # 0
13846 
  )
13847 
 
13848 
  def __init__(self, success=None,):
13849 
    self.success = success
13850 
 
13851 
  def read(self, iprot):
13852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13854 
      return
13855 
    iprot.readStructBegin()
13856 
    while True:
13857 
      (fname, ftype, fid) = iprot.readFieldBegin()
13858 
      if ftype == TType.STOP:
13859 
        break
13860 
      if fid == 0:
13861 
        if ftype == TType.BOOL:
13862 
          self.success = iprot.readBool();
13863 
        else:
13864 
          iprot.skip(ftype)
13865 
      else:
13866 
        iprot.skip(ftype)
13867 
      iprot.readFieldEnd()
13868 
    iprot.readStructEnd()
13869 
 
13870 
  def write(self, oprot):
13871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13873 
      return
13874 
    oprot.writeStructBegin('insureItem_result')
13875 
    if self.success is not None:
13876 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13877 
      oprot.writeBool(self.success)
13878 
      oprot.writeFieldEnd()
13879 
    oprot.writeFieldStop()
13880 
    oprot.writeStructEnd()
13881 
 
13882 
  def validate(self):
13883 
    return
13884 
 
13885 
 
13886 
  def __repr__(self):
13887 
    L = ['%s=%r' % (key, value)
13888 
      for key, value in self.__dict__.iteritems()]
13889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13890 
 
13891 
  def __eq__(self, other):
13892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13893 
 
13894 
  def __ne__(self, other):
13895 
    return not (self == other)
13896 
 
13897 
class cancelInsurance_args:
13898 
  """
13899 
  Attributes:
13900 
   - cartId
13901 
  """
13902 
 
13903 
  thrift_spec = (
13904 
    None, # 0
13905 
    (1, TType.I64, 'cartId', None, None, ), # 1
13906 
  )
13907 
 
13908 
  def __init__(self, cartId=None,):
13909 
    self.cartId = cartId
13910 
 
13911 
  def read(self, iprot):
13912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13914 
      return
13915 
    iprot.readStructBegin()
13916 
    while True:
13917 
      (fname, ftype, fid) = iprot.readFieldBegin()
13918 
      if ftype == TType.STOP:
13919 
        break
13920 
      if fid == 1:
13921 
        if ftype == TType.I64:
13922 
          self.cartId = iprot.readI64();
13923 
        else:
13924 
          iprot.skip(ftype)
13925 
      else:
13926 
        iprot.skip(ftype)
13927 
      iprot.readFieldEnd()
13928 
    iprot.readStructEnd()
13929 
 
13930 
  def write(self, oprot):
13931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13933 
      return
13934 
    oprot.writeStructBegin('cancelInsurance_args')
13935 
    if self.cartId is not None:
13936 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13937 
      oprot.writeI64(self.cartId)
13938 
      oprot.writeFieldEnd()
13939 
    oprot.writeFieldStop()
13940 
    oprot.writeStructEnd()
13941 
 
13942 
  def validate(self):
13943 
    return
13944 
 
13945 
 
13946 
  def __repr__(self):
13947 
    L = ['%s=%r' % (key, value)
13948 
      for key, value in self.__dict__.iteritems()]
13949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13950 
 
13951 
  def __eq__(self, other):
13952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13953 
 
13954 
  def __ne__(self, other):
13955 
    return not (self == other)
13956 
 
13957 
class cancelInsurance_result:
13958 
  """
13959 
  Attributes:
13960 
   - success
13961 
  """
13962 
 
13963 
  thrift_spec = (
13964 
    (0, TType.BOOL, 'success', None, None, ), # 0
13965 
  )
13966 
 
13967 
  def __init__(self, success=None,):
13968 
    self.success = success
13969 
 
13970 
  def read(self, iprot):
13971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13973 
      return
13974 
    iprot.readStructBegin()
13975 
    while True:
13976 
      (fname, ftype, fid) = iprot.readFieldBegin()
13977 
      if ftype == TType.STOP:
13978 
        break
13979 
      if fid == 0:
13980 
        if ftype == TType.BOOL:
13981 
          self.success = iprot.readBool();
13982 
        else:
13983 
          iprot.skip(ftype)
13984 
      else:
13985 
        iprot.skip(ftype)
13986 
      iprot.readFieldEnd()
13987 
    iprot.readStructEnd()
13988 
 
13989 
  def write(self, oprot):
13990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13992 
      return
13993 
    oprot.writeStructBegin('cancelInsurance_result')
13994 
    if self.success is not None:
13995 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13996 
      oprot.writeBool(self.success)
13997 
      oprot.writeFieldEnd()
13998 
    oprot.writeFieldStop()
13999 
    oprot.writeStructEnd()
14000 
 
14001 
  def validate(self):
14002 
    return
14003 
 
14004 
 
14005 
  def __repr__(self):
14006 
    L = ['%s=%r' % (key, value)
14007 
      for key, value in self.__dict__.iteritems()]
14008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14009 
 
14010 
  def __eq__(self, other):
14011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14012 
 
14013 
  def __ne__(self, other):
14014 
    return not (self == other)
14015 
 
14016 
class storeInsuranceSpecificDetails_args:
14017 
  """
14018 
  Attributes:
14019 
   - addressId
14020 
   - dob
14021 
   - guardianName
14022 
  """
14023 
 
14024 
  thrift_spec = (
14025 
    None, # 0
14026 
    (1, TType.I64, 'addressId', None, None, ), # 1
14027 
    (2, TType.STRING, 'dob', None, None, ), # 2
14028 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14029 
  )
14030 
 
14031 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14032 
    self.addressId = addressId
14033 
    self.dob = dob
14034 
    self.guardianName = guardianName
14035 
 
14036 
  def read(self, iprot):
14037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14039 
      return
14040 
    iprot.readStructBegin()
14041 
    while True:
14042 
      (fname, ftype, fid) = iprot.readFieldBegin()
14043 
      if ftype == TType.STOP:
14044 
        break
14045 
      if fid == 1:
14046 
        if ftype == TType.I64:
14047 
          self.addressId = iprot.readI64();
14048 
        else:
14049 
          iprot.skip(ftype)
14050 
      elif fid == 2:
14051 
        if ftype == TType.STRING:
14052 
          self.dob = iprot.readString();
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      elif fid == 3:
14056 
        if ftype == TType.STRING:
14057 
          self.guardianName = iprot.readString();
14058 
        else:
14059 
          iprot.skip(ftype)
14060 
      else:
14061 
        iprot.skip(ftype)
14062 
      iprot.readFieldEnd()
14063 
    iprot.readStructEnd()
14064 
 
14065 
  def write(self, oprot):
14066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14068 
      return
14069 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14070 
    if self.addressId is not None:
14071 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14072 
      oprot.writeI64(self.addressId)
14073 
      oprot.writeFieldEnd()
14074 
    if self.dob is not None:
14075 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14076 
      oprot.writeString(self.dob)
14077 
      oprot.writeFieldEnd()
14078 
    if self.guardianName is not None:
14079 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14080 
      oprot.writeString(self.guardianName)
14081 
      oprot.writeFieldEnd()
14082 
    oprot.writeFieldStop()
14083 
    oprot.writeStructEnd()
14084 
 
14085 
  def validate(self):
14086 
    return
14087 
 
14088 
 
14089 
  def __repr__(self):
14090 
    L = ['%s=%r' % (key, value)
14091 
      for key, value in self.__dict__.iteritems()]
14092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14093 
 
14094 
  def __eq__(self, other):
14095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14096 
 
14097 
  def __ne__(self, other):
14098 
    return not (self == other)
14099 
 
14100 
class storeInsuranceSpecificDetails_result:
14101 
  """
14102 
  Attributes:
14103 
   - success
14104 
  """
14105 
 
14106 
  thrift_spec = (
14107 
    (0, TType.BOOL, 'success', None, None, ), # 0
14108 
  )
14109 
 
14110 
  def __init__(self, success=None,):
14111 
    self.success = success
14112 
 
14113 
  def read(self, iprot):
14114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14116 
      return
14117 
    iprot.readStructBegin()
14118 
    while True:
14119 
      (fname, ftype, fid) = iprot.readFieldBegin()
14120 
      if ftype == TType.STOP:
14121 
        break
14122 
      if fid == 0:
14123 
        if ftype == TType.BOOL:
14124 
          self.success = iprot.readBool();
14125 
        else:
14126 
          iprot.skip(ftype)
14127 
      else:
14128 
        iprot.skip(ftype)
14129 
      iprot.readFieldEnd()
14130 
    iprot.readStructEnd()
14131 
 
14132 
  def write(self, oprot):
14133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14135 
      return
14136 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14137 
    if self.success is not None:
14138 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14139 
      oprot.writeBool(self.success)
14140 
      oprot.writeFieldEnd()
14141 
    oprot.writeFieldStop()
14142 
    oprot.writeStructEnd()
14143 
 
14144 
  def validate(self):
14145 
    return
14146 
 
14147 
 
14148 
  def __repr__(self):
14149 
    L = ['%s=%r' % (key, value)
14150 
      for key, value in self.__dict__.iteritems()]
14151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14152 
 
14153 
  def __eq__(self, other):
14154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14155 
 
14156 
  def __ne__(self, other):
14157 
    return not (self == other)
14158 
 
14159 
class isInsuranceDetailPresent_args:
14160 
  """
14161 
  Attributes:
14162 
   - addressId
14163 
  """
14164 
 
14165 
  thrift_spec = (
14166 
    None, # 0
14167 
    (1, TType.I64, 'addressId', None, None, ), # 1
14168 
  )
14169 
 
14170 
  def __init__(self, addressId=None,):
14171 
    self.addressId = addressId
14172 
 
14173 
  def read(self, iprot):
14174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14176 
      return
14177 
    iprot.readStructBegin()
14178 
    while True:
14179 
      (fname, ftype, fid) = iprot.readFieldBegin()
14180 
      if ftype == TType.STOP:
14181 
        break
14182 
      if fid == 1:
14183 
        if ftype == TType.I64:
14184 
          self.addressId = iprot.readI64();
14185 
        else:
14186 
          iprot.skip(ftype)
14187 
      else:
14188 
        iprot.skip(ftype)
14189 
      iprot.readFieldEnd()
14190 
    iprot.readStructEnd()
14191 
 
14192 
  def write(self, oprot):
14193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14195 
      return
14196 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14197 
    if self.addressId is not None:
14198 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14199 
      oprot.writeI64(self.addressId)
14200 
      oprot.writeFieldEnd()
14201 
    oprot.writeFieldStop()
14202 
    oprot.writeStructEnd()
14203 
 
14204 
  def validate(self):
14205 
    return
14206 
 
14207 
 
14208 
  def __repr__(self):
14209 
    L = ['%s=%r' % (key, value)
14210 
      for key, value in self.__dict__.iteritems()]
14211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14212 
 
14213 
  def __eq__(self, other):
14214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14215 
 
14216 
  def __ne__(self, other):
14217 
    return not (self == other)
14218 
 
14219 
class isInsuranceDetailPresent_result:
14220 
  """
14221 
  Attributes:
14222 
   - success
14223 
  """
14224 
 
14225 
  thrift_spec = (
14226 
    (0, TType.BOOL, 'success', None, None, ), # 0
14227 
  )
14228 
 
14229 
  def __init__(self, success=None,):
14230 
    self.success = success
14231 
 
14232 
  def read(self, iprot):
14233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14235 
      return
14236 
    iprot.readStructBegin()
14237 
    while True:
14238 
      (fname, ftype, fid) = iprot.readFieldBegin()
14239 
      if ftype == TType.STOP:
14240 
        break
14241 
      if fid == 0:
14242 
        if ftype == TType.BOOL:
14243 
          self.success = iprot.readBool();
14244 
        else:
14245 
          iprot.skip(ftype)
14246 
      else:
14247 
        iprot.skip(ftype)
14248 
      iprot.readFieldEnd()
14249 
    iprot.readStructEnd()
14250 
 
14251 
  def write(self, oprot):
14252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14254 
      return
14255 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14256 
    if self.success is not None:
14257 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14258 
      oprot.writeBool(self.success)
14259 
      oprot.writeFieldEnd()
14260 
    oprot.writeFieldStop()
14261 
    oprot.writeStructEnd()
14262 
 
14263 
  def validate(self):
14264 
    return
14265 
 
14266 
 
14267 
  def __repr__(self):
14268 
    L = ['%s=%r' % (key, value)
14269 
      for key, value in self.__dict__.iteritems()]
14270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14271 
 
14272 
  def __eq__(self, other):
14273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14274 
 
14275 
  def __ne__(self, other):
14276 
    return not (self == other)
14277 
 
9791 rajveer 14278 
class getProductsAddedToCart_args:
6821 amar.kumar 14279 
  """
14280 
  Attributes:
14281 
   - startDate
14282 
   - endDate
14283 
  """
14284 
 
14285 
  thrift_spec = (
14286 
    None, # 0
9791 rajveer 14287 
    (1, TType.I64, 'startDate', None, None, ), # 1
14288 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14289 
  )
14290 
 
9791 rajveer 14291 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14292 
    self.startDate = startDate
14293 
    self.endDate = endDate
14294 
 
14295 
  def read(self, iprot):
14296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14298 
      return
14299 
    iprot.readStructBegin()
14300 
    while True:
14301 
      (fname, ftype, fid) = iprot.readFieldBegin()
14302 
      if ftype == TType.STOP:
14303 
        break
14304 
      if fid == 1:
14305 
        if ftype == TType.I64:
9791 rajveer 14306 
          self.startDate = iprot.readI64();
6821 amar.kumar 14307 
        else:
14308 
          iprot.skip(ftype)
14309 
      elif fid == 2:
14310 
        if ftype == TType.I64:
14311 
          self.endDate = iprot.readI64();
14312 
        else:
14313 
          iprot.skip(ftype)
14314 
      else:
14315 
        iprot.skip(ftype)
14316 
      iprot.readFieldEnd()
14317 
    iprot.readStructEnd()
14318 
 
14319 
  def write(self, oprot):
14320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14322 
      return
9791 rajveer 14323 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14324 
    if self.startDate is not None:
9791 rajveer 14325 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14326 
      oprot.writeI64(self.startDate)
14327 
      oprot.writeFieldEnd()
14328 
    if self.endDate is not None:
9791 rajveer 14329 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14330 
      oprot.writeI64(self.endDate)
14331 
      oprot.writeFieldEnd()
14332 
    oprot.writeFieldStop()
14333 
    oprot.writeStructEnd()
14334 
 
14335 
  def validate(self):
14336 
    return
14337 
 
14338 
 
14339 
  def __repr__(self):
14340 
    L = ['%s=%r' % (key, value)
14341 
      for key, value in self.__dict__.iteritems()]
14342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14343 
 
14344 
  def __eq__(self, other):
14345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14346 
 
14347 
  def __ne__(self, other):
14348 
    return not (self == other)
14349 
 
9791 rajveer 14350 
class getProductsAddedToCart_result:
6821 amar.kumar 14351 
  """
14352 
  Attributes:
14353 
   - success
14354 
  """
14355 
 
14356 
  thrift_spec = (
9791 rajveer 14357 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14358 
  )
14359 
 
14360 
  def __init__(self, success=None,):
14361 
    self.success = success
14362 
 
14363 
  def read(self, iprot):
14364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14366 
      return
14367 
    iprot.readStructBegin()
14368 
    while True:
14369 
      (fname, ftype, fid) = iprot.readFieldBegin()
14370 
      if ftype == TType.STOP:
14371 
        break
14372 
      if fid == 0:
9791 rajveer 14373 
        if ftype == TType.LIST:
14374 
          self.success = []
11592 amit.gupta 14375 
          (_etype214, _size211) = iprot.readListBegin()
14376 
          for _i215 in xrange(_size211):
14377 
            _elem216 = iprot.readI64();
14378 
            self.success.append(_elem216)
9791 rajveer 14379 
          iprot.readListEnd()
6821 amar.kumar 14380 
        else:
14381 
          iprot.skip(ftype)
14382 
      else:
14383 
        iprot.skip(ftype)
14384 
      iprot.readFieldEnd()
14385 
    iprot.readStructEnd()
14386 
 
14387 
  def write(self, oprot):
14388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14390 
      return
9791 rajveer 14391 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14392 
    if self.success is not None:
9791 rajveer 14393 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14394 
      oprot.writeListBegin(TType.I64, len(self.success))
11592 amit.gupta 14395 
      for iter217 in self.success:
14396 
        oprot.writeI64(iter217)
9791 rajveer 14397 
      oprot.writeListEnd()
6821 amar.kumar 14398 
      oprot.writeFieldEnd()
14399 
    oprot.writeFieldStop()
14400 
    oprot.writeStructEnd()
14401 
 
14402 
  def validate(self):
14403 
    return
14404 
 
14405 
 
14406 
  def __repr__(self):
14407 
    L = ['%s=%r' % (key, value)
14408 
      for key, value in self.__dict__.iteritems()]
14409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14410 
 
14411 
  def __eq__(self, other):
14412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14413 
 
14414 
  def __ne__(self, other):
14415 
    return not (self == other)
11592 amit.gupta 14416 
 
14417 
class validateCartPlus_args:
14418 
  """
14419 
  Attributes:
14420 
   - cartId
14421 
   - sourceId
14422 
  """
14423 
 
14424 
  thrift_spec = (
14425 
    None, # 0
14426 
    (1, TType.I64, 'cartId', None, None, ), # 1
14427 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14428 
  )
14429 
 
14430 
  def __init__(self, cartId=None, sourceId=None,):
14431 
    self.cartId = cartId
14432 
    self.sourceId = sourceId
14433 
 
14434 
  def read(self, iprot):
14435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14437 
      return
14438 
    iprot.readStructBegin()
14439 
    while True:
14440 
      (fname, ftype, fid) = iprot.readFieldBegin()
14441 
      if ftype == TType.STOP:
14442 
        break
14443 
      if fid == 1:
14444 
        if ftype == TType.I64:
14445 
          self.cartId = iprot.readI64();
14446 
        else:
14447 
          iprot.skip(ftype)
14448 
      elif fid == 2:
14449 
        if ftype == TType.I64:
14450 
          self.sourceId = iprot.readI64();
14451 
        else:
14452 
          iprot.skip(ftype)
14453 
      else:
14454 
        iprot.skip(ftype)
14455 
      iprot.readFieldEnd()
14456 
    iprot.readStructEnd()
14457 
 
14458 
  def write(self, oprot):
14459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14461 
      return
14462 
    oprot.writeStructBegin('validateCartPlus_args')
14463 
    if self.cartId is not None:
14464 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14465 
      oprot.writeI64(self.cartId)
14466 
      oprot.writeFieldEnd()
14467 
    if self.sourceId is not None:
14468 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14469 
      oprot.writeI64(self.sourceId)
14470 
      oprot.writeFieldEnd()
14471 
    oprot.writeFieldStop()
14472 
    oprot.writeStructEnd()
14473 
 
14474 
  def validate(self):
14475 
    return
14476 
 
14477 
 
14478 
  def __repr__(self):
14479 
    L = ['%s=%r' % (key, value)
14480 
      for key, value in self.__dict__.iteritems()]
14481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14482 
 
14483 
  def __eq__(self, other):
14484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14485 
 
14486 
  def __ne__(self, other):
14487 
    return not (self == other)
14488 
 
14489 
class validateCartPlus_result:
14490 
  """
14491 
  Attributes:
14492 
   - success
14493 
   - scex
14494 
  """
14495 
 
14496 
  thrift_spec = (
14497 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
14498 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
14499 
  )
14500 
 
14501 
  def __init__(self, success=None, scex=None,):
14502 
    self.success = success
14503 
    self.scex = scex
14504 
 
14505 
  def read(self, iprot):
14506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14508 
      return
14509 
    iprot.readStructBegin()
14510 
    while True:
14511 
      (fname, ftype, fid) = iprot.readFieldBegin()
14512 
      if ftype == TType.STOP:
14513 
        break
14514 
      if fid == 0:
14515 
        if ftype == TType.STRUCT:
14516 
          self.success = CartPlus()
14517 
          self.success.read(iprot)
14518 
        else:
14519 
          iprot.skip(ftype)
14520 
      elif fid == 1:
14521 
        if ftype == TType.STRUCT:
14522 
          self.scex = ShoppingCartException()
14523 
          self.scex.read(iprot)
14524 
        else:
14525 
          iprot.skip(ftype)
14526 
      else:
14527 
        iprot.skip(ftype)
14528 
      iprot.readFieldEnd()
14529 
    iprot.readStructEnd()
14530 
 
14531 
  def write(self, oprot):
14532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14534 
      return
14535 
    oprot.writeStructBegin('validateCartPlus_result')
14536 
    if self.success is not None:
14537 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14538 
      self.success.write(oprot)
14539 
      oprot.writeFieldEnd()
14540 
    if self.scex is not None:
14541 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
14542 
      self.scex.write(oprot)
14543 
      oprot.writeFieldEnd()
14544 
    oprot.writeFieldStop()
14545 
    oprot.writeStructEnd()
14546 
 
14547 
  def validate(self):
14548 
    return
14549 
 
14550 
 
14551 
  def __repr__(self):
14552 
    L = ['%s=%r' % (key, value)
14553 
      for key, value in self.__dict__.iteritems()]
14554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14555 
 
14556 
  def __eq__(self, other):
14557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14558 
 
14559 
  def __ne__(self, other):
14560 
    return not (self == other)
11679 vikram.rag 14561 
 
14562 
class isPrivateDealUser_args:
14563 
  """
14564 
  Attributes:
14565 
   - userId
14566 
  """
14567 
 
14568 
  thrift_spec = (
14569 
    None, # 0
14570 
    (1, TType.I64, 'userId', None, None, ), # 1
14571 
  )
14572 
 
14573 
  def __init__(self, userId=None,):
14574 
    self.userId = userId
14575 
 
14576 
  def read(self, iprot):
14577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14579 
      return
14580 
    iprot.readStructBegin()
14581 
    while True:
14582 
      (fname, ftype, fid) = iprot.readFieldBegin()
14583 
      if ftype == TType.STOP:
14584 
        break
14585 
      if fid == 1:
14586 
        if ftype == TType.I64:
14587 
          self.userId = iprot.readI64();
14588 
        else:
14589 
          iprot.skip(ftype)
14590 
      else:
14591 
        iprot.skip(ftype)
14592 
      iprot.readFieldEnd()
14593 
    iprot.readStructEnd()
14594 
 
14595 
  def write(self, oprot):
14596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14598 
      return
14599 
    oprot.writeStructBegin('isPrivateDealUser_args')
14600 
    if self.userId is not None:
14601 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14602 
      oprot.writeI64(self.userId)
14603 
      oprot.writeFieldEnd()
14604 
    oprot.writeFieldStop()
14605 
    oprot.writeStructEnd()
14606 
 
14607 
  def validate(self):
14608 
    return
14609 
 
14610 
 
14611 
  def __repr__(self):
14612 
    L = ['%s=%r' % (key, value)
14613 
      for key, value in self.__dict__.iteritems()]
14614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14615 
 
14616 
  def __eq__(self, other):
14617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14618 
 
14619 
  def __ne__(self, other):
14620 
    return not (self == other)
14621 
 
14622 
class isPrivateDealUser_result:
14623 
  """
14624 
  Attributes:
14625 
   - success
14626 
  """
14627 
 
14628 
  thrift_spec = (
14629 
    (0, TType.BOOL, 'success', None, None, ), # 0
14630 
  )
14631 
 
14632 
  def __init__(self, success=None,):
14633 
    self.success = success
14634 
 
14635 
  def read(self, iprot):
14636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14638 
      return
14639 
    iprot.readStructBegin()
14640 
    while True:
14641 
      (fname, ftype, fid) = iprot.readFieldBegin()
14642 
      if ftype == TType.STOP:
14643 
        break
14644 
      if fid == 0:
14645 
        if ftype == TType.BOOL:
14646 
          self.success = iprot.readBool();
14647 
        else:
14648 
          iprot.skip(ftype)
14649 
      else:
14650 
        iprot.skip(ftype)
14651 
      iprot.readFieldEnd()
14652 
    iprot.readStructEnd()
14653 
 
14654 
  def write(self, oprot):
14655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14657 
      return
14658 
    oprot.writeStructBegin('isPrivateDealUser_result')
14659 
    if self.success is not None:
14660 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14661 
      oprot.writeBool(self.success)
14662 
      oprot.writeFieldEnd()
14663 
    oprot.writeFieldStop()
14664 
    oprot.writeStructEnd()
14665 
 
14666 
  def validate(self):
14667 
    return
14668 
 
14669 
 
14670 
  def __repr__(self):
14671 
    L = ['%s=%r' % (key, value)
14672 
      for key, value in self.__dict__.iteritems()]
14673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14674 
 
14675 
  def __eq__(self, other):
14676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14677 
 
14678 
  def __ne__(self, other):
14679 
    return not (self == other)
11890 kshitij.so 14680 
 
14681 
class addPrivateDealUser_args:
14682 
  """
14683 
  Attributes:
14684 
   - userId
14685 
  """
14686 
 
14687 
  thrift_spec = (
14688 
    None, # 0
14689 
    (1, TType.I64, 'userId', None, None, ), # 1
14690 
  )
14691 
 
14692 
  def __init__(self, userId=None,):
14693 
    self.userId = userId
14694 
 
14695 
  def read(self, iprot):
14696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14698 
      return
14699 
    iprot.readStructBegin()
14700 
    while True:
14701 
      (fname, ftype, fid) = iprot.readFieldBegin()
14702 
      if ftype == TType.STOP:
14703 
        break
14704 
      if fid == 1:
14705 
        if ftype == TType.I64:
14706 
          self.userId = iprot.readI64();
14707 
        else:
14708 
          iprot.skip(ftype)
14709 
      else:
14710 
        iprot.skip(ftype)
14711 
      iprot.readFieldEnd()
14712 
    iprot.readStructEnd()
14713 
 
14714 
  def write(self, oprot):
14715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14717 
      return
14718 
    oprot.writeStructBegin('addPrivateDealUser_args')
14719 
    if self.userId is not None:
14720 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14721 
      oprot.writeI64(self.userId)
14722 
      oprot.writeFieldEnd()
14723 
    oprot.writeFieldStop()
14724 
    oprot.writeStructEnd()
14725 
 
14726 
  def validate(self):
14727 
    return
14728 
 
14729 
 
14730 
  def __repr__(self):
14731 
    L = ['%s=%r' % (key, value)
14732 
      for key, value in self.__dict__.iteritems()]
14733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14734 
 
14735 
  def __eq__(self, other):
14736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14737 
 
14738 
  def __ne__(self, other):
14739 
    return not (self == other)
14740 
 
14741 
class addPrivateDealUser_result:
14742 
  """
14743 
  Attributes:
14744 
   - success
14745 
  """
14746 
 
14747 
  thrift_spec = (
14748 
    (0, TType.BOOL, 'success', None, None, ), # 0
14749 
  )
14750 
 
14751 
  def __init__(self, success=None,):
14752 
    self.success = success
14753 
 
14754 
  def read(self, iprot):
14755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14757 
      return
14758 
    iprot.readStructBegin()
14759 
    while True:
14760 
      (fname, ftype, fid) = iprot.readFieldBegin()
14761 
      if ftype == TType.STOP:
14762 
        break
14763 
      if fid == 0:
14764 
        if ftype == TType.BOOL:
14765 
          self.success = iprot.readBool();
14766 
        else:
14767 
          iprot.skip(ftype)
14768 
      else:
14769 
        iprot.skip(ftype)
14770 
      iprot.readFieldEnd()
14771 
    iprot.readStructEnd()
14772 
 
14773 
  def write(self, oprot):
14774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14776 
      return
14777 
    oprot.writeStructBegin('addPrivateDealUser_result')
14778 
    if self.success is not None:
14779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14780 
      oprot.writeBool(self.success)
14781 
      oprot.writeFieldEnd()
14782 
    oprot.writeFieldStop()
14783 
    oprot.writeStructEnd()
14784 
 
14785 
  def validate(self):
14786 
    return
14787 
 
14788 
 
14789 
  def __repr__(self):
14790 
    L = ['%s=%r' % (key, value)
14791 
      for key, value in self.__dict__.iteritems()]
14792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14793 
 
14794 
  def __eq__(self, other):
14795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14796 
 
14797 
  def __ne__(self, other):
14798 
    return not (self == other)
14799 
 
14800 
class changePrivateDealUserStatus_args:
14801 
  """
14802 
  Attributes:
14803 
   - userId
14804 
   - isActive
14805 
  """
14806 
 
14807 
  thrift_spec = (
14808 
    None, # 0
14809 
    (1, TType.I64, 'userId', None, None, ), # 1
14810 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
14811 
  )
14812 
 
14813 
  def __init__(self, userId=None, isActive=None,):
14814 
    self.userId = userId
14815 
    self.isActive = isActive
14816 
 
14817 
  def read(self, iprot):
14818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14820 
      return
14821 
    iprot.readStructBegin()
14822 
    while True:
14823 
      (fname, ftype, fid) = iprot.readFieldBegin()
14824 
      if ftype == TType.STOP:
14825 
        break
14826 
      if fid == 1:
14827 
        if ftype == TType.I64:
14828 
          self.userId = iprot.readI64();
14829 
        else:
14830 
          iprot.skip(ftype)
14831 
      elif fid == 2:
14832 
        if ftype == TType.BOOL:
14833 
          self.isActive = iprot.readBool();
14834 
        else:
14835 
          iprot.skip(ftype)
14836 
      else:
14837 
        iprot.skip(ftype)
14838 
      iprot.readFieldEnd()
14839 
    iprot.readStructEnd()
14840 
 
14841 
  def write(self, oprot):
14842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14844 
      return
14845 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
14846 
    if self.userId is not None:
14847 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14848 
      oprot.writeI64(self.userId)
14849 
      oprot.writeFieldEnd()
14850 
    if self.isActive is not None:
14851 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
14852 
      oprot.writeBool(self.isActive)
14853 
      oprot.writeFieldEnd()
14854 
    oprot.writeFieldStop()
14855 
    oprot.writeStructEnd()
14856 
 
14857 
  def validate(self):
14858 
    return
14859 
 
14860 
 
14861 
  def __repr__(self):
14862 
    L = ['%s=%r' % (key, value)
14863 
      for key, value in self.__dict__.iteritems()]
14864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14865 
 
14866 
  def __eq__(self, other):
14867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14868 
 
14869 
  def __ne__(self, other):
14870 
    return not (self == other)
14871 
 
14872 
class changePrivateDealUserStatus_result:
14873 
  """
14874 
  Attributes:
14875 
   - success
14876 
  """
14877 
 
14878 
  thrift_spec = (
14879 
    (0, TType.BOOL, 'success', None, None, ), # 0
14880 
  )
14881 
 
14882 
  def __init__(self, success=None,):
14883 
    self.success = success
14884 
 
14885 
  def read(self, iprot):
14886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14888 
      return
14889 
    iprot.readStructBegin()
14890 
    while True:
14891 
      (fname, ftype, fid) = iprot.readFieldBegin()
14892 
      if ftype == TType.STOP:
14893 
        break
14894 
      if fid == 0:
14895 
        if ftype == TType.BOOL:
14896 
          self.success = iprot.readBool();
14897 
        else:
14898 
          iprot.skip(ftype)
14899 
      else:
14900 
        iprot.skip(ftype)
14901 
      iprot.readFieldEnd()
14902 
    iprot.readStructEnd()
14903 
 
14904 
  def write(self, oprot):
14905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14907 
      return
14908 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
14909 
    if self.success is not None:
14910 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14911 
      oprot.writeBool(self.success)
14912 
      oprot.writeFieldEnd()
14913 
    oprot.writeFieldStop()
14914 
    oprot.writeStructEnd()
14915 
 
14916 
  def validate(self):
14917 
    return
14918 
 
14919 
 
14920 
  def __repr__(self):
14921 
    L = ['%s=%r' % (key, value)
14922 
      for key, value in self.__dict__.iteritems()]
14923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14924 
 
14925 
  def __eq__(self, other):
14926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14927 
 
14928 
  def __ne__(self, other):
14929 
    return not (self == other)
14930 
 
14931 
class getPrivateDealUser_args:
14932 
  """
14933 
  Attributes:
14934 
   - userId
14935 
  """
14936 
 
14937 
  thrift_spec = (
14938 
    None, # 0
14939 
    (1, TType.I64, 'userId', None, None, ), # 1
14940 
  )
14941 
 
14942 
  def __init__(self, userId=None,):
14943 
    self.userId = userId
14944 
 
14945 
  def read(self, iprot):
14946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14948 
      return
14949 
    iprot.readStructBegin()
14950 
    while True:
14951 
      (fname, ftype, fid) = iprot.readFieldBegin()
14952 
      if ftype == TType.STOP:
14953 
        break
14954 
      if fid == 1:
14955 
        if ftype == TType.I64:
14956 
          self.userId = iprot.readI64();
14957 
        else:
14958 
          iprot.skip(ftype)
14959 
      else:
14960 
        iprot.skip(ftype)
14961 
      iprot.readFieldEnd()
14962 
    iprot.readStructEnd()
14963 
 
14964 
  def write(self, oprot):
14965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14967 
      return
14968 
    oprot.writeStructBegin('getPrivateDealUser_args')
14969 
    if self.userId is not None:
14970 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14971 
      oprot.writeI64(self.userId)
14972 
      oprot.writeFieldEnd()
14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
14990 
 
14991 
class getPrivateDealUser_result:
14992 
  """
14993 
  Attributes:
14994 
   - success
14995 
  """
14996 
 
14997 
  thrift_spec = (
14998 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
14999 
  )
15000 
 
15001 
  def __init__(self, success=None,):
15002 
    self.success = success
15003 
 
15004 
  def read(self, iprot):
15005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15007 
      return
15008 
    iprot.readStructBegin()
15009 
    while True:
15010 
      (fname, ftype, fid) = iprot.readFieldBegin()
15011 
      if ftype == TType.STOP:
15012 
        break
15013 
      if fid == 0:
15014 
        if ftype == TType.STRUCT:
15015 
          self.success = PrivateDealUser()
15016 
          self.success.read(iprot)
15017 
        else:
15018 
          iprot.skip(ftype)
15019 
      else:
15020 
        iprot.skip(ftype)
15021 
      iprot.readFieldEnd()
15022 
    iprot.readStructEnd()
15023 
 
15024 
  def write(self, oprot):
15025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15027 
      return
15028 
    oprot.writeStructBegin('getPrivateDealUser_result')
15029 
    if self.success is not None:
15030 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15031 
      self.success.write(oprot)
15032 
      oprot.writeFieldEnd()
15033 
    oprot.writeFieldStop()
15034 
    oprot.writeStructEnd()
15035 
 
15036 
  def validate(self):
15037 
    return
15038 
 
15039 
 
15040 
  def __repr__(self):
15041 
    L = ['%s=%r' % (key, value)
15042 
      for key, value in self.__dict__.iteritems()]
15043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15044 
 
15045 
  def __eq__(self, other):
15046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15047 
 
15048 
  def __ne__(self, other):
15049 
    return not (self == other)